# Copyright 2015 Open Platform for NFV Project, Inc. and its contributors
# This software is distributed under the terms and conditions of the 'Apache-2.0'
# license which can be found in the file 'LICENSE' in this package distribution
# or at 'http://www.apache.org/licenses/LICENSE-2.0'.

from oslo_log import log as logging
from oslo_config import cfg
from stevedore.driver import DriverManager
from moon_utilities import configuration
from moon_db.api import model, policy, pdp, keystone

CONF = cfg.CONF
LOG = logging.getLogger("moon.db")


class Driver(DriverManager):

    def __init__(self, driver_name, engine_name):
        LOG.info("initialization of Driver {}".format(driver_name))
        super(Driver, self).__init__(
            namespace='moon_db.driver',
            name=driver_name,
            invoke_on_load=True,
            invoke_args=(engine_name, ),
        )


class ModelDriver(Driver):

    def __init__(self, driver_name, engine_name):
        super(ModelDriver, self).__init__(driver_name, engine_name)

    def update_model(self, model_id, value):
        raise NotImplementedError()  # pragma: no cover

    def delete_model(self, model_id):
        raise NotImplementedError()  # pragma: no cover

    def add_model(self, model_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def get_models(self, model_id=None):
        raise NotImplementedError()  # pragma: no cover

    def set_meta_rule(self, meta_rule_id, value):
        raise NotImplementedError()  # pragma: no cover

    def get_meta_rules(self, meta_rule_id=None):
        raise NotImplementedError()  # pragma: no cover

    def delete_meta_rule(self, meta_rule_id=None):
        raise NotImplementedError()  # pragma: no cover

    def get_subject_categories(self, category_id=None):
        raise NotImplementedError()  # pragma: no cover

    def add_subject_category(self, name, description):
        raise NotImplementedError()  # pragma: no cover

    def delete_subject_category(self, category_id):
        raise NotImplementedError()  # pragma: no cover

    def get_object_categories(self, category_id):
        raise NotImplementedError()  # pragma: no cover

    def add_object_category(self, category_id, value):
        raise NotImplementedError()  # pragma: no cover

    def delete_object_category(self, category_id):
        raise NotImplementedError()  # pragma: no cover

    def get_action_categories(self, category_id):
        raise NotImplementedError()  # pragma: no cover

    def add_action_category(self, category_id, value):
        raise NotImplementedError()  # pragma: no cover

    def delete_action_category(self, category_id):
        raise NotImplementedError()  # pragma: no cover


class PolicyDriver(Driver):

    def __init__(self, driver_name, engine_name):
        super(PolicyDriver, self).__init__(driver_name, engine_name)

    def update_policy(self, policy_id, value):
        raise NotImplementedError()  # pragma: no cover

    def delete_policy(self, policy_id):
        raise NotImplementedError()  # pragma: no cover

    def add_policy(self, policy_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def get_policies(self, policy_id=None):
        raise NotImplementedError()  # pragma: no cover

    def get_subjects(self, policy_id, perimeter_id=None):
        raise NotImplementedError()  # pragma: no cover

    def set_subject(self, policy_id, perimeter_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def delete_subject(self, policy_id, perimeter_id):
        raise NotImplementedError()  # pragma: no cover

    def get_objects(self, policy_id, perimeter_id=None):
        raise NotImplementedError()  # pragma: no cover

    def set_object(self, policy_id, perimeter_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def delete_object(self, policy_id, perimeter_id):
        raise NotImplementedError()  # pragma: no cover

    def get_actions(self, policy_id, perimeter_id=None):
        raise NotImplementedError()  # pragma: no cover

    def set_action(self, policy_id, perimeter_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def delete_action(self, policy_id, perimeter_id):
        raise NotImplementedError()  # pragma: no cover

    def get_subject_data(self, policy_id, data_id=None, category_id=None):
        raise NotImplementedError()  # pragma: no cover

    def set_subject_data(self, policy_id, data_id=None, category_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def delete_subject_data(self, policy_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def get_object_data(self, policy_id, data_id=None, category_id=None):
        raise NotImplementedError()  # pragma: no cover

    def set_object_data(self, policy_id, data_id=None, category_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def delete_object_data(self, policy_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def get_action_data(self, policy_id, data_id=None, category_id=None):
        raise NotImplementedError()  # pragma: no cover

    def set_action_data(self, policy_id, data_id=None, category_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def delete_action_data(self, policy_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def get_subject_assignments(self, policy_id, subject_id=None, category_id=None):
        raise NotImplementedError()  # pragma: no cover

    def add_subject_assignment(self, policy_id, subject_id, category_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def delete_subject_assignment(self, policy_id, subject_id, category_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def get_object_assignments(self, policy_id, assignment_id=None):
        raise NotImplementedError()  # pragma: no cover

    def add_object_assignment(self, policy_id, subject_id, category_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def delete_object_assignment(self, policy_id, object_id, category_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def get_action_assignments(self, policy_id, assignment_id=None):
        raise NotImplementedError()  # pragma: no cover

    def add_action_assignment(self, policy_id, action_id, category_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def delete_action_assignment(self, policy_id, action_id, category_id, data_id):
        raise NotImplementedError()  # pragma: no cover

    def get_rules(self, policy_id, rule_id=None, meta_rule_id=None):
        raise NotImplementedError()  # pragma: no cover

    def add_rule(self, policy_id, meta_rule_id, value):
        raise NotImplementedError()  # pragma: no cover

    def delete_rule(self, policy_id, rule_id):
        raise NotImplementedError()  # pragma: no cover


class PDPDriver(Driver):

    def __init__(self, driver_name, engine_name):
        super(PDPDriver, self).__init__(driver_name, engine_name)

    def update_pdp(self, pdp_id, value):
        raise NotImplementedError()  # pragma: no cover

    def delete_pdp(self, pdp_id):
        raise NotImplementedError()  # pragma: no cover

    def add_pdp(self, pdp_id=None, value=None):
        raise NotImplementedError()  # pragma: no cover

    def get_pdp(self, pdp_id=None):
        raise NotImplementedError()  # pragma: no cover


class KeystoneDriver(Driver):

    def __init__(self, driver_name, engine_name):
        super(KeystoneDriver, self).__init__(driver_name, engine_name)


conf = configuration.get_configuration("database")['database']
KeystoneManager = keystone.KeystoneManager(
    KeystoneDriver(conf['driver'], conf['url'])
)

ModelManager = model.ModelManager(
    ModelDriver(conf['driver'], conf['url'])
)

PolicyManager = policy.PolicyManager(
    PolicyDriver(conf['driver'], conf['url'])
)

PDPManager = pdp.PDPManager(
    PDPDriver(conf['driver'], conf['url'])
)


# class LogDriver(object):
#
#     def authz(self, message):
#         """Log authorization message
#
#         :param message: the message to log
#         :type message: string
#         :return: None
#         """
#         raise NotImplementedError()  # pragma: no cover
#
#     def debug(self, message):
#         """Log debug message
#
#         :param message: the message to log
#         :type message: string
#         :return: None
#         """
#         raise NotImplementedError()  # pragma: no cover
#
#     def info(self, message):
#         """Log informational message
#
#         :param message: the message to log
#         :type message: string
#         :return: None
#         """
#         raise NotImplementedError()  # pragma: no cover
#
#     def warning(self, message):
#         """Log warning message
#
#         :param message: the message to log
#         :type message: string
#         :return: None
#         """
#         raise NotImplementedError()  # pragma: no cover
#
#     def error(self, message):
#         """Log error message
#
#         :param message: the message to log
#         :type message: string
#         :return: None
#         """
#         raise NotImplementedError()  # pragma: no cover
#
#     def critical(self, message):
#         """Log critical message
#
#         :param message: the message to log
#         :type message: string
#         :return: None
#         """
#         raise NotImplementedError()  # pragma: no cover
#
#     def get_logs(self, options):
#         """Get logs
#
#         :param options: options to filter log events
#         :type options: string eg: "event_number=10,from=2014-01-01-10:10:10,to=2014-01-01-12:10:10,filter=expression"
#         :return: a list of log events
#
#         TIME_FORMAT is '%Y-%m-%d-%H:%M:%S'
#         """
#         raise NotImplementedError()  # pragma: no cover