# Copyright 2014 TrilioData Inc.
# All Rights Reserved.

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

import functools
import json
import webob
from webob import exc

from nova import exception as novaexc
from nova.api.openstack import common
from nova.api.openstack import extensions
from nova.api.openstack import wsgi
from nova.api.openstack.compute.views import servers as views_servers


from contego.nova.api import API

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

try:
    from oslo_policy import policy
    from nova.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 novaexc.QuotaError as error:
            raise error
        except novaexc.NovaException 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["nova.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 Contego 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()
        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'}

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

    @wsgi.action('contego_vast_freeze')
    @convert_exception
    @authorize
    def _vast_freeze(self, req, id, body):
        context = req.environ["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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["nova.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 = "Contego"
        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 = "Contego"
        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