from django.apps import AppConfig
import json
from django.conf import settings
import logging
import inspect
from jinja2 import Template

from MG.itasker.iTaskerGraph import graph
from MG.itasker.iTaskerGraph import nodes


MASTER_JSON = 'MG/itasker/itasker.json.jinja'


class ItaskerConfig(AppConfig):
    name = 'MG.itasker'
    ValItaskerJsonError = type('ValItaskerJsonError', (Exception, ), {})

    def _check_signature(self, *exceptions):
        sign = inspect.signature(self.func)
        sign_parameters = list(sign.parameters.items())
        check_attributes = [True if key_arg[0] in self.func_args else False
                            for key_arg in sign_parameters
                            if key_arg[0] not in exceptions]
        if not all(check_attributes):
            wrong_parameters = []
            for arg, check in zip(sign_parameters, check_attributes):
                if not check:
                    wrong_parameters.append(arg[0])
            raise self.not_all_parameter_defined('Parameters "{}" not found'.format('" & "'.join(wrong_parameters)))

    def _validate_graph(self, json_graph):
        try:
            graph_task = graph.ITaskerGraph.parse_graph(json_graph,
                                                        nodes_cls={'ROOT': nodes.ConnectionNodeRoot,
                                                                   'NONLOCALROOT': nodes.ConnectionNodeNonLocalRoot,
                                                                   'LEAVE': nodes.ConnectionNodeLeave,
                                                                   'NONLOCALLEAVE': nodes.ConnectionNodeNonLocalLeave,
                                                                   'LINKER': nodes.ConnectionNodeLinker,
                                                                   'TMP': nodes.ConnectionNodeTemp,
                                                                   'SUBTASK': nodes.SubTaskNode,
                                                                   'ONLY_ONE': nodes.ConnectionOnlyOneNode},
                                                        common_params={'user': None, 'layer': False})
        except Exception as e:
            raise self.ValItaskerJsonError('Task {task} not well defined.\n'
                                           'Error validating parameters, error {error}'.format(task=json_graph['name'],
                                                                                               error=e))
        for node in [graph_task.nodes[node] for node in graph_task.nodes if isinstance(graph_task.nodes[node],
                                                                                       nodes.SubTaskNode)]:
            function_signature = inspect.signature(node.func)

            required_function_signature = {key: function_signature.parameters[key]
                                           for key in function_signature.parameters.keys() if
                                           function_signature.parameters[key].default ==
                                           inspect.Parameter.empty}
            function_signature_0 = set(required_function_signature.keys())
            function_signature = function_signature_0.copy()
            # Check inputs
            inputs = node.ancestors(1, '==')
            for input_node in inputs:
                input_node_arg_name = input_node.param_id[node.id]
                function_signature = function_signature - {input_node_arg_name}
            # Check parameters
            parameters = node.params_dict
            parameters.update({'user': None})
            parameters.update({'task': None})
            parameters_list = set(parameters.keys())
            function_signature = function_signature-parameters_list
            # Check output
            outputs = node.succesors()
            for output_node in outputs:
                try:
                    input_node_arg_name = output_node.param_id[node.id]
                except Exception as e:
                    raise self.ValItaskerJsonError('Task {task} not well defined.\n'
                                                   'Error validating parameters, error {error}.\n'
                                                   'Maybe a subtask without an output?'.format(task=json_graph['name'],
                                                                                               error=e))
                function_signature = function_signature - {input_node_arg_name}
            if len(function_signature) > 0:
                raise self.ValItaskerJsonError('Task {task} not well defined.\n'
                                               'Error validating {subtask} parameters, \n'
                                               'must have {parameters_initial},\n'
                                               'but {parameters_remain} '
                                               'are not defined'.format(task=json_graph['name'],
                                                                        subtask=node.id,
                                                                        parameters_initial=function_signature_0,
                                                                        parameters_remain=function_signature))

    def ready(self):
        env_conf = settings.ENV_CONF
        with open(MASTER_JSON, 'r', encoding="utf-8") as f:
            json_string = f.read()
        # Replacing variables
        vars_value = env_conf.search("env_.*")
        json_string = Template(json_string)
        json_string = json_string.render(**vars_value)
        # Validating JSON ###########################################
        itasker_json = json.loads(json_string)
        for task in itasker_json:
            self._validate_graph(task)
        #############################################################
        settings.MASTER_JSON = json.loads(json_string)

        # Logging conf
        # ## Disabling TaskMonitor info logging
        log_django = logging.getLogger('django.server')

        def filter_mont_info(record):
            if '/MG/itasker/get_task_monitor' in record.args[0]:
                return False
            else:
                return True

        log_django.addFilter(filter_mont_info)
        # ## END