# -*- coding: utf-8 -*-

from functools import reduce

class Node(object):
    def __init__(self, id:str, name:str):
        super(Node, self).__init__()

        self.id = id
        self.name = name

    def __repr__(self):
        return f"Node {{id: {self.id}, name: {self.name}}}"

    def __getitem__(self, name):
        ret = None

        if name == "name":
            ret = self.name
        elif name == "id":
            ret = self.id

        return ret


class Edge(object):
    def __init__(self, id:str, name:str, node1:Node = None, node2:Node = None):
        super(Edge, self).__init__()

        self.id = id
        self.name = name

        self.node1 = node1
        self.node2 = node2

        self.enable = True

    def __repr__(self):
        return f"Edge {{id: {self.id}, enable: {self.enable}, name: {self.name}, self.node1: {self.node1}, self.node2: {self.node2},}}"

    def __getitem__(self, name):
        ret = None

        if name == "name":
            ret = self.name
        elif name == "id":
            ret = self.id
        elif name == "node1":
            ret = self.node1.name
        elif name == "node2":
            ret = self.node2.name
        elif name == "enable":
            ret = self.enable

        return ret

    def enable(self):
        self.enable = True

    def disable(self):
        self.enable = False


class Graph(object):
    def __init__(self):
        super(Graph, self).__init__()

        self._nodes_ids = 0
        self._edges_ids = 0

        self._nodes = []
        self._edges = []

    def __repr__(self):
        return f"Graph {{nodes: {self._nodes}, edges: {self._edges}}}"

    def nodes(self):
        return self._nodes.copy()

    def edges(self):
        return self._edges.copy()

    def nodes_counts(self):
        return len(self._nodes)

    def edges_counts(self):
        return len(self._edges)

    def is_node_exists(self, node_name):
        return reduce(
            lambda acc, n: (acc or (n.name == node_name)),
            self._nodes,
            False
        )

    def is_edge_exists(self, edge_name):
        return reduce(
            lambda acc, e: (acc or (e.name == edge_name)),
            self._edges,
            False
        )

    def add_node(self):
        node = Node(self._nodes_ids, f"Node {self._nodes_ids}")
        self._nodes.append(node)
        self._nodes_ids += 1
        return node

    def add_edge(self, n1:Node, n2:Node):
        edge = Edge(self._edges_ids, f"Edge {self._edges_ids}", n1, n2)
        self._edges.append(edge)
        self._edges_ids += 1
        return edge

    def remove_node(self, node_name:str):
        self._nodes = filter(lambda n: n.name != node_name, self._nodes)

    def remove_edge(self, edge_name:str):
        self._edges = filter(lambda e: e.name != edge_name, self._edges)