# 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.compute.views import servers as views_servers


from dmapi.api.openstack.api import API

LOG = logging.getLogger(__name__)
# authorizer = extensions.extension_authorizer('compute', 'contego')

#try:
    #from oslo_policy import policy
    #from dmapi.policies import base
    #import itertools
#except Exception as ex:
    #pass

#ALIAS = 'CO'
#POLICY_ROOT = 'os_compute_api:CO:%s'

#try:
    #CO_policies = [
        #policy.RuleDefault(
            #name=POLICY_ROOT % 'discoverable',
            #check_str=base.RULE_ANY),
    #]
#except Exception as ex:
    #pass


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
    """

    #_view_builder_class = views_servers.ViewBuilder

    def __init__(self):
        super(ContegoServerControllerExtension, self).__init__()
        #
        self.contego_api =  API()
        #self.contego_api = None
        try:
            from nova.policy import _ENFORCER as enforcer
            enforcer.register_defaults(itertools.chain(CO_policies))
        except Exception as ex:
            pass
        # 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


#"""
#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