import matplotlib.pyplot as plt
import random
import networkx as nx
import csv
from multiprocessing.dummy import Pool as ThreadPool
from decimal import *


class Vertex:
    def __init__(self, key, is_active=False):
        self.key = key
        self.neighbors = {}
        self.is_active = is_active
        self.nextState = is_active

    def add_neighbor(self, nbr, weight=0):
        self.neighbors[nbr] = weight

    def __str__(self):
        return str(self.key) + ' sąsiedzi: ' + str([vert.key for vert in self.neighbors])

    def get_connections(self):
        return self.neighbors.keys()

    def get_key(self):
        return self.key

    def get_weight(self, nbr):
        return self.neighbors[nbr]

    def get_active(self):
        return self.is_active

    def update_state(self):
        self.is_active = self.nextState

    def set_next_state(self, neighbor_counter):
        if not self.is_active and (neighbor_counter == 3 or neighbor_counter == 6):
            self.nextState = True
        elif self.is_active and (neighbor_counter == 2 or neighbor_counter == 3):
            self.nextState = True
        else:
            self.nextState = False


class Graph:
    def __init__(self):
        self.vertices = {}
        self.active_vertices = 0

    def add_vertex(self, vertex):
        self.vertices[vertex.key] = vertex

    def get_vertex(self, key):
        try:
            return self.vertices[key]
        except KeyError:
            return None

    def __contains__(self, key):
        return key in self.vertices

    def add_edge_directed(self, from_key, to_key, weight=0):
        if from_key not in self.vertices:
            self.add_vertex(Vertex(from_key))
        if to_key not in self.vertices:
            self.add_vertex(Vertex(to_key))
        self.vertices[from_key].add_neighbor(self.vertices[to_key], weight)

    def add_edge_undirected(self, from_key, to_key, weight=0):
        if from_key not in self.vertices:
            self.add_vertex(Vertex(from_key))
        if to_key not in self.vertices:
            self.add_vertex(Vertex(to_key))
        self.vertices[from_key].add_neighbor(self.vertices[to_key], weight)
        self.vertices[to_key].add_neighbor(self.vertices[from_key], weight)

    def get_vertices(self):
        return self.vertices.keys()

    def __iter__(self):
        return iter(self.vertices.values())

    def get_active_vertices(self):
        return sum(1 for v in self.vertices.values() if v.get_active())

    def simulate(self):
        for vert in self.vertices.values():
            number_of_actives = sum(1 for nbr in vert.get_connections() if nbr.get_active())
            vert.set_next_state(number_of_actives)
        for vert in self.vertices.values():
            vert.update_state()

    def active_connections(self):
        return [(vert, x) for vert in (vert for vert in self.vertices.values() if vert.is_active) for x in
                (neighbour for neighbour in vert.get_connections() if neighbour.is_active)]

    def add_all_neighbors(self, dim):
        for x in range(dim):
            for y in range(dim):
                # pomocnicze indeksy
                mx = x - 1
                if mx < 0:
                    mx = dim - 1
                my = y - 1
                if my < 0:
                    my = dim - 1
                gx = (x + 1) % dim
                gy = (y + 1) % dim

                self.add_edge_directed((x, y), (mx, my))
                self.add_edge_directed((x, y), (mx, y))
                self.add_edge_directed((x, y), (mx, gy))
                self.add_edge_directed((x, y), (x, my))
                self.add_edge_directed((x, y), (x, gy))
                self.add_edge_directed((x, y), (gx, my))
                self.add_edge_directed((x, y), (gx, y))
                self.add_edge_directed((x, y), (gx, gy))

    def generate_vertices(self, dim, probability):
        for i in range(dim):
            for j in range(dim):
                self.add_vertex(Vertex((i, j), random.random() < probability))

    def vertices_in_strongly_connected_component(self):
        return len(max(nx.strongly_connected_components(nx.DiGraph(self.active_connections())), key=len))