"""
   OpenNebula Endpoint base class implementation for the OpenNebula cloud service.
"""

from __future__ import print_function
from __future__ import division
from __future__ import absolute_import

__RCSID__ = "$Id"

import os
import base64
import ssl
from requests.auth import HTTPBasicAuth
try:
  from xmlrpc.client import ServerProxy
except ImportError:
  # python2 compat
  from xmlrpclib import ServerProxy

# DIRAC
from DIRAC import gLogger, S_OK, S_ERROR
from DIRAC.Resources.Cloud.Endpoint import Endpoint
from DIRAC.Core.Utilities.File import makeGuid

DEBUG = False  # In case of debugging, switch


class OpenNebulaEndpoint(Endpoint):
  """ OpenNebula implementation of the Cloud Endpoint interface
  """

  def __init__(self, parameters=None):
    super(OpenNebulaEndpoint, self).__init__(
        parameters=parameters, bootstrapParameters=parameters)

    self.parameters['HostCert'] = self.parameters.get("HostCert")
    self.parameters['HostKey'] = self.parameters.get("HostKey")
    self.bootstrapParameters['HostCert'] = self.parameters['HostCert']
    self.bootstrapParameters['HostKey'] = self.parameters['HostKey']

    self.log = gLogger.getSubLogger('OpenNebulaEndpoint')

    self.valid = False
    self.vmType = self.parameters.get('VMType')
    self.site = self.parameters.get('Site')

    # Prepare the authentication request parameters
    self.session = None
    self.authArgs = {}
    self.user = self.parameters.get("User")
    self.password = self.parameters.get("Password")
    self.loginMode = False

    if self.user and self.password:
      # we have the login/password case
      self.authArgs['auth'] = HTTPBasicAuth(self.user, self.password)
      self.authArgs['verify'] = False
      self.loginMode = True
      self.oneauth = self.user + ':' + self.password
    else:
      # we have the user proxy case
      # TODO: test
      self.userProxy = os.environ.get('X509_USER_PROXY')
      self.userProxy = self.parameters.get("Proxy", self.userProxy)
      if self.userProxy is None:
        self.log.error("User proxy is not defined")
        self.valid = False
        return
      self.authArgs['cert'] = self.userProxy
      self.caPath = self.parameters.get('CAPath')
      self.authArgs['verify'] = self.caPath
      if self.parameters.get("Auth") == "voms":
        self.authArgs['data'] = '{"auth":{"voms": true}}'

    self.serviceUrl = self.parameters.get('EndpointUrl')

    result = self.initialize()
    if result['OK']:
      self.log.debug('OpenNebulaEndpoint created and validated')
      self.valid = True

  def initialize(self):
    self.log.info('INITIALIZE')

    ssl_ctx = ssl.create_default_context()
    ssl_ctx.check_hostname = False
    ssl_ctx.verify_mode = ssl.CERT_NONE

    self.rpcproxy = ServerProxy(self.serviceUrl, context=ssl_ctx)

    return S_OK()

  def createInstances(self, vmsToSubmit):
    outputDict = {}
    message = ''
    self.log.debug("vmsToSubmit " + str(vmsToSubmit))
    for nvm in range(vmsToSubmit):
      instanceID = makeGuid()[:8]
      createPublicIP = 'ipPool' in self.parameters

      result = self.createInstance(instanceID, createPublicIP)
      if result['OK']:
        nodeID, publicIP = result['Value']
        self.log.debug(
            'Created VM instance %s/%s with publicIP %s' % (nodeID, instanceID, publicIP))
        nodeDict = {}
        nodeDict['PublicIP'] = publicIP
        nodeDict['InstanceID'] = instanceID
        nodeDict['NumberOfProcessors'] = self.parameters.get("NumberOfProcessors", 1)
        outputDict[nodeID] = nodeDict
      else:
        message = result['Message']
        break

    # We failed submission utterly
    if not outputDict:
      return S_ERROR('No VM submitted: %s' % message)

    return S_OK(outputDict)

  def createInstance(self, instanceID='', createPublicIP=True):
    """
    Creates VM in OpenNebula cloud.

    one.template.instantiate XML-RPC method is called with the following parameters
    This creates a VM instance for the given boot image
    and creates a context script, taken the given parameters.
    Successful creation returns instance VM

    Boots a new node on the OpenStack server defined by self.endpointConfig. The
    'personality' of the node is done by self.imageConfig. Both variables are
    defined on initialization phase.

    * template ID is obtained from Endpoint's `TemplateID` constructor parameter
    * VM name equals to `instanceID` method argument
    * onhold flag is obtained from Endpoint's `Onhold` constructor parameter
    * template string contains userdata scripts encoded in base64 and DNS
      servers adresses

    The node name has the following format:
    <bootImageName><contextMethod><time>

    :Parameters:
      **instanceID** - `string`
        name of a new VM
      **createPublicIP** - `bool`
        ignored

    It boots the node. If IPpool is defined on the imageConfiguration, a floating
    IP is created and assigned to the node.

    :return: S_OK( ( nodeID, publicIP ) ) | S_ERROR
    """

    # TODO: which templateId to use?
    templateId = int(self.parameters.get('TemplateID'))  # 1627 )
    onhold = self.parameters.get('Onhold', False)

    # TODO: remove this stuff (required by _createUserDataScript)
    self.parameters['VMUUID'] = instanceID
    self.parameters['VMType'] = self.parameters.get('CEType', 'OpenNebula')
    result = self._createUserDataScript()
    if not result['OK']:
      return result
    userData = str(result['Value'])

    # TODO: Should we have it as a parameter???
    template = '''CONTEXT = [
NETWORK = "YES",
USER_DATA = "{}",
DNS = "8.8.8.8 8.8.4.4",
USERDATA_ENCODING = "base64"
]'''.format(base64.b64encode(userData))

    ret = self.rpcproxy.one.template.instantiate(
        self.oneauth, templateId, instanceID, onhold, template
    )

    # XXX: Sometimes it returns 4 values although documemntation says otherwise
    ok, payload, error = ret[:3]

    if ok:
      return S_OK((payload, None))

    return S_ERROR('one.template.instantiate failed with code: %s message: %s ' % (error, payload))

  def getVMIDs(self):
    """ Get all the VM IDs on the endpoint

    :return: list of VM ids
    """
    return S_ERROR('getVMIDs is not implemented')

  def getVMStatus(self, nodeID):
    """
    Get the status for a given node ID. libcloud translates the status into a digit
    from 0 to 4 using a many-to-one relation ( ACTIVE and RUNNING -> 0 ), which
    means we cannot undo that translation. It uses an intermediate states mapping
    dictionary, SITEMAP, which we use here inverted to return the status as a
    meaningful string. The five possible states are ( ordered from 0 to 4 ):
    RUNNING, REBOOTING, TERMINATED, PENDING & UNKNOWN.

    :Parameters:
      **uniqueId** - `string`
        openstack node id ( not uuid ! )

    :return: S_OK( status ) | S_ERROR
    """
    return S_ERROR('getVMStatus is not implemented')

  def getVMNetworks(self):
    """ Get a network object corresponding to the networkName

    :param str networkName: network name
    :return: S_OK|S_ERROR network object in case of S_OK
    """
    return S_ERROR('getVMNetworks is not implemented')

  def getVMNetworkInterface(self, network):
    """ Get a network object corresponding to the networkName

    :param str networkName: network name
    :return: S_OK|S_ERROR network object in case of S_OK
    """
    return S_ERROR('getVMNetworkInterface is not implemented')

  def stopVM(self, nodeID, publicIP=''):
    """
    Terminates VM specified by nodeID by sending one.vm.action(..., 'delete', ..)
    request.

    :Parameters:
      **nodeID** - `string`
        OpenNebula VM id specifier
      **publicIP** - `string`
        ignored

    :return: S_OK | S_ERROR
    """
    self.log.info('DELETE ID: ' + str(nodeID))

    ret = self.rpcproxy.one.vm.action(self.oneauth, 'delete', int(nodeID))

    # XXX: Sometimes it returns 4 values although documemntation says otherwise
    ok = ret[0]
    payload = ret[1]
    error = ret[2]

    self.log.debug('Delete OK: ' + str(ok))
    self.log.debug('Payload: ' + str(payload))
    self.log.debug('Error: ' + str(error))

    if ok:
      return S_OK(payload)

    return S_ERROR('one.vm.action failed with code: %s message: %s ' % (error, payload))

  def assignFloatingIP(self, nodeID):
    """
    Given a node, assign a floating IP from the ipPool defined on the imageConfiguration
    on the CS.

    :Parameters:
      **node** - `libcloud.compute.base.Node`
        node object with the vm details

    :return: S_OK | S_ERROR
    """
    return S_ERROR('assignFloatingIP is not implemented')

  def getVMFloatingIP(self, publicIP):
    return S_ERROR('Not implemented')

  def deleteFloatingIP(self, nodeID):
    """
    Deletes a floating IP <public_ip> from the server.

    :param str publicIP: public IP to be deleted
    :param object node: node to which IP is attached
    :return: S_OK | S_ERROR
    """
    return S_ERROR('deleteFloatingIP is not implemnted')