from django.urls.resolvers import get_resolver
from django.http.request import HttpRequest
import json
import networkx as nx


class Node(object):
    INFO_REFRESH = 0.5  # seconds

    def __init__(self, node_id, parent_graph, **kwargs):
        self.id = node_id
        self.params_dict = {}
        self.parent_graph = parent_graph
        self.result = None
        self.backward = {}
        for kwarg in kwargs:
            self.params_dict[kwarg] = kwargs[kwarg]

    @classmethod
    def parse(cls, node_json, parent_graph):
        return None

    def set_param(self, key, value):
        self.params_dict[key] = value

    def run(self, *args, **kwargs):
        return True

    def collect_parameters(self):
        ancestors = nx.ancestors(self.parent_graph.nx_graph, self.id)
        for ancestor in ancestors:
            try:
                length = nx.shortest_path_length(self.parent_graph.nx_graph, ancestor, self.id)
                if length > 1:
                    continue
            except nx.NetworkXNoPath:
                continue
            while not self.parent_graph.nodes[ancestor].result:
                continue
            param_id = self.parent_graph.nodes[ancestor].param_id
            # Creo que no pasa con ningún nodo
            if param_id == '':
                continue
            #####################################
            if self.id in param_id.keys():
                argument_name = param_id[self.id]
                if argument_name in self.backward.keys():
                    if isinstance(self.backward[argument_name], list):
                        self.backward[argument_name].append(self.parent_graph.nodes[ancestor].result)
                    else:
                        self.backward[argument_name] = [self.backward[argument_name],
                                                        self.parent_graph.nodes[ancestor].result]
                else:
                    self.backward[argument_name] = self.parent_graph.nodes[ancestor].result
        self.params_dict.update(self.backward)

    def super_run(self, *args, **kwargs):
        self.collect_parameters()
        result = self.run(*args, **kwargs)
        self.result = result
        return result

    def is_root(self):
        roots = self.parent_graph.get_roots()
        return self.id in roots

    def is_leave(self):
        leaves = self.parent_graph.get_leaves()
        return self.id in leaves

    def ancestors(self, length_target=1, logical_operator='='):
        ancestors = nx.ancestors(self.parent_graph.nx_graph, self.id)
        ancestors_list = []
        for ancestor in ancestors:
            try:
                length = nx.shortest_path_length(self.parent_graph.nx_graph, ancestor, self.id)
                if eval('{length} {logical_operator} {length_target}'.format(length=length,
                                                                             logical_operator=logical_operator,
                                                                             length_target=length_target)):
                    ancestors_list.append(self.parent_graph.nodes[ancestor])
            except nx.NetworkXNoPath:
                continue
        return ancestors_list

    def succesors(self):
        return [self.parent_graph.nodes[suc] for suc in self.parent_graph.nx_graph.successors(self.id)]