# Copyright 2018 TrilioData Inc.
# All Rights Reserved.

try:
    from oslo_log import log as logging
except ImportError:
    from dmapi.openstack.common import log as logging

import functools
import json
import webob
from webob import exc

from dmapi import exception as dmapiexc
from dmapi.api.openstack import wsgi
from dmapi.api.openstack.api import API
from oslo_config import cfg
from oslo_policy import policy
from dmapi import policies as dm_policy
import itertools

CONF = cfg.CONF

LOG = logging.getLogger(__name__)
POLICY_ROOT = 'os_compute_api:CO:%s'

def convert_exception(action):

    def fn(self, *args, **kwargs):
        try:
            return action(self, *args, **kwargs)
        except dmapiexc.QuotaError as error:
            raise error
        except dmapiexc.DmapiException as error:
            raise exc.HTTPBadRequest(explanation=str(error))

    # Openstack sometimes does matching on the function name so we need to
    # ensure that the decorated function returns with the same function
    # name as the action.
    fn.__name__ = action.__name__
    return fn


def authorize(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        context = kwargs['req'].environ["dmapi.context"]
        # authorizer(context)
        return f(*args, **kwargs)
    return wrapper


class ContegoInfoController(object):

    def __init__(self):
        self.cobalt_api = API()

    @convert_exception
    @authorize
    def index(self, req):
        return webob.Response(status_int=200,
                              body=json.dumps(self.contego_api.get_info()))


class ContegoServerControllerExtension(wsgi.Controller):
    """
    The OpenStack Extension definition for Dmapi capabilities.
    Currently this includes:
        * VAST an existing virtual machine
    """

    def __init__(self):
        super(ContegoServerControllerExtension, self).__init__()
        self.contego_api =  API()
        try:
            CO_policies = [
                          policy.RuleDefault(
                          name=POLICY_ROOT % 'discoverable',
                          check_str=dm_policy.RULE_ANY),
                          ]
            _ENFORCER = policy.Enforcer(CONF)
            _ENFORCER.register_defaults(itertools.chain(CO_policies))

        except Exception as ex:
            LOG.exception(ex)
        # Add the contego-specific states to the state map
        #common._STATE_MAP['vasted'] = {'default': 'VASTED'}

    @authorize
    @convert_exception
    def _vast_prepare(self, req, id, body):
        #
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_prepare',
                          body.get('contego_vast_prepare', {}))
        result = self.contego_api.vast_prepare(context, id, params)
        return result

    @convert_exception
    @authorize
    def _vast_freeze(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_freeze',
                          body.get('contego_vast_freeze', {}))
        result = self.contego_api.vast_freeze(context, id, params)
        return result

    #@wsgi.action('contego_vast_thaw')
    @convert_exception
    @authorize
    def _vast_thaw(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_thaw',
                          body.get('contego_vast_thaw', {}))
        result = self.contego_api.vast_thaw(context, id, params)
        return result

    #@wsgi.action('contego_vast_get_info')
    @convert_exception
    @authorize
    def _vast_get_info(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_get_info',
                          body.get('contego_vast_get_info', {}))
        result = self.contego_api.vast_get_info(context, id, params)
        return result

    #@wsgi.action('contego_vast_instance')
    @convert_exception
    @authorize
    def _vast_instance(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_instance',
                          body.get('contego_vast_instance', {}))
        result = self.contego_api.vast_instance(context, id, params)
        return result

    #@wsgi.action('contego_vast_data_url')
    @convert_exception
    @authorize
    def _vast_data_url(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_data_url',
                          body.get('contego_vast_data_url', {}))
        result = self.contego_api.vast_data_url(context, id, params)
        return result

    #@wsgi.action('contego_vast_data_transfer')
    @convert_exception
    @authorize
    def _vast_data_transfer(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_data_transfer',
                          body.get('contego_vast_data_transfer', {}))
        result = self.contego_api.vast_data_transfer(context, id, params)
        return result

    #@wsgi.action('contego_vast_check_prev_snapshot')
    @convert_exception
    @authorize
    def _vast_check_prev_snapshot(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_check_prev_snapshot',
                          body.get('contego_vast_check_prev_snapshot', {}))
        result = self.contego_api.vast_check_prev_snapshot(context, id, params)
        return result

    #@wsgi.action('contego_vast_async_task_status')
    @convert_exception
    @authorize
    def _vast_async_task_status(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_async_task_status',
                          body.get('contego_vast_async_task_status', {}))
        result = self.contego_api.vast_async_task_status(context, id, params)
        return result

    #@wsgi.action('contego_vast_finalize')
    @convert_exception
    @authorize
    def _vast_finalize(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_finalize',
                          body.get('contego_vast_finalize', {}))
        result = self.contego_api.vast_finalize(context, id, params)
        return result

    #@wsgi.action('contego_vast_reset')
    @convert_exception
    @authorize
    def _vast_reset(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_reset',
                          body.get('contego_vast_reset', {}))
        result = self.contego_api.vast_reset(context, id, params)
        return result

    #@wsgi.action('contego_vast_commit_image')
    @convert_exception
    @authorize
    def _vast_commit_image(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_commit_image',
                          body.get('contego_vast_commit_image', {}))
        result = self.contego_api.vast_commit_image(context, id, params)
        return result

    #@wsgi.action('contego_map_snapshot_files')
    @convert_exception
    @authorize
    def _map_snapshot_files(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_map_snapshot_files',
                          body.get('contego_map_snapshot_files', {}))
        result = self.contego_api.map_snapshot_files(context, id, params)
        return result

    #@wsgi.action('contego_copy_backup_image_to_volume')
    @convert_exception
    @authorize
    def _copy_backup_image_to_volume(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_copy_backup_image_to_volume',
                          body.get('contego_copy_backup_image_to_volume', {}))
        result = self.contego_api.copy_backup_image_to_volume(
            context, id, params)
        return result

    #@wsgi.action('contego_vast_config_backup')
    @convert_exception
    @authorize
    def _vast_config_backup(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_config_backup')
        result = self.contego_api.vast_config_backup(context, id, params)
        return result

    #@wsgi.action('contego_validate_database_creds')
    @convert_exception
    @authorize
    def _validate_database_creds(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_validate_database_creds')
        result = self.contego_api.validate_database_creds(context, params)
        return result

    #@wsgi.action('contego_validate_trusted_user_and_key')
    @convert_exception
    @authorize
    def _validate_trusted_user_and_key(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_validate_trusted_user_and_key')
        result = self.contego_api.validate_trusted_user_and_key(
            context, params)
        return result

    #@wsgi.action('contego_get_controller_nodes')
    @convert_exception
    @authorize
    def _get_controller_nodes(self, req, id, body):
        context = req.environ["dmapi.context"]
        result = self.contego_api.get_controller_nodes(context)
        return result

    @convert_exception
    @authorize
    def _vast_disk_check(self, req, id, body):
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_disk_check',
                          body.get('contego_vast_disk_check', {}))
        result = self.contego_api.vast_disk_check(context, id, params)
        return result

    @authorize
    @convert_exception
    def _vast_clean_nbd_devices(self, req, id, body):
        #
        context = req.environ["dmapi.context"]
        params = body.get('contego_vast_clean_nbd_devices',
                          body.get('contego_vast_clean_nbd_devices', {}))
        result = self.contego_api.vast_clean_nbd_devices(context, id, params)
        return result

    @convert_exception
    @authorize
    def index(self, req):
        context = req.environ["dmapi.context"]
        result = self.contego_api.list_services(context)
        return result

#"""
#The OpenStack Extension definition for the contego capabilities.
#Currently this includes:
#* VAST an instance
#"""
#if hasattr(extensions, "V21APIExtensionBase"):
    #class ContegoExtension(extensions.V21APIExtensionBase):
        #"""
        #The OpenStack Extension definition for the contego capabilities.
        #Currently this includes:
        #* VAST an instance
        #"""

        #name = "Dmapi"
        #alias = "CO"
        #namespace = "http://docs.triliodata.com/openstack/ext/api/v1"
        #updated = '2014-02-10T11:52:50-07:00'  # TIMESTAMP
        #version = 1

        #def get_resources(self):
            #return []

        #def get_controller_extensions(self):
            #extension_list = []
            #extension_set = [(ContegoServerControllerExtension, 'servers'), ]
            #for klass, collection in extension_set:
                #controller = klass()
                #ext = extensions.ControllerExtension(self, collection,
                                                     #controller)
                #extension_list.append(ext)

            #return extension_list

        #def is_valid(self):
            #"""Validate required fields for extensions.

            #Raises an attribute error if the attr is not defined
            #"""
            #for attr in ('name', 'alias', 'updated', 'namespace'):
                #if getattr(self, attr) is None:
                    #raise AttributeError(
                        #"%s is None, needs to be defined" % attr)
            #return True
#else:
    #class contego_extension(object):

        #name = "Dmapi"
        #alias = "CO"
        #namespace = "http://docs.triliodata.com/openstack/ext/api/v1"
        #updated = '2014-02-10T11:52:50-07:00'   # TIMESTAMP

        #def __init__(self, ext_mgr):
            #ext_mgr.register(self)

        #def get_resources(self):
            #info_controller = ContegoInfoController()
            #return [extensions.ResourceExtension('contegoinfo',
                                                 #info_controller), ]

        #def get_controller_extensions(self):
            #extension_list = []
            #extension_set = [(ContegoServerControllerExtension, 'servers'), ]
            #for klass, collection in extension_set:
                #controller = klass()
                #ext = extensions.ControllerExtension(self, collection,
                                                     #controller)
                #extension_list.append(ext)

            #return extension_list

        #def is_valid(self):
            #"""Validate required fields for extensions.

            #Raises an attribute error if the attr is not defined
            #"""
            #for attr in ('name', 'alias', 'updated', 'namespace'):
                #if getattr(self, attr) is None:
                    #raise AttributeError(
                        #"%s is None, needs to be defined" % attr)
            #return True