#pip install itables
#pip install tabulate
#pip install adjustText

import numpy as np
import pandas as pd
import networkx as nx
from tqdm import tqdm
from tabulate import tabulate
import matplotlib.pyplot as plt

from zipfile import ZipFile
from io import BytesIO
import requests

import warnings
warnings.filterwarnings('ignore')

def top_hero_from_graph2(data, Graph, k: int, p=None):

    top = data.groupby(['hero'])['hero'].size().sort_values(ascending=False).head(k)
    links = data.loc[data['hero'].isin(top.keys())]
    edg = list(links.apply(lambda row: (row['hero'], row['comic']), axis=1))
    s_g = nx.edge_subgraph(Graph, edg)
    #print("  sub-{}".format(nx.info(s_g)))
    nodesComics = [x for x,y in s_g.nodes(data=True) if y["type"]=="comic"]
    result = [node for node in nodesComics if s_g.degree(node) > 1 ]
    new_graph = s_g.subgraph(result + list(top.keys()))
    if p is not None:
        print("  sub-{}".format(nx.info(new_graph)))
    
    return new_graph, top

def funzione_1():
    
    print(" ")
    graph_type = int(input(" - Graph type (1 or 2) : "))
    top_N = int(input(" - Top N heroes that should be considered : "))
    info = [ ["Number of Nodes", "Density of the Network", "Average Degree of the Network", "is Sparse or Dense"] ]
    print(" ")
    
    if graph_type == 1:
        
        sub_graph = find_top1(G_hero, top_N )
        
        n_nodes = len(sub_graph.nodes)                      # number of nodes in the sub network
        density = nx.density(sub_graph)                     # sub network's density
        average_degree = sum([sub_graph.degree[i] for i in sub_graph.nodes])/len(sub_graph.nodes)  # average degree 
        s_or_d  = "Sparse" if density < 0.5 else "Dense"                                                 #of the network
        
        info.append([n_nodes, round(density, 3), round(average_degree, 3), s_or_d] ) 
        print(tabulate(info, headers="firstrow", tablefmt="fancy_grid", numalign='center', stralign="center"))
        
        
        ## Finding the number of collaborations of each superhero with the others :
        
        lista = []
        for i in sub_graph.nodes:
            apparizioni = sum([x[2] for x in sub_graph.edges(i, data="collab")])
            lista.append((i, apparizioni))
        lista = sorted(lista, key=lambda tup: tup[1], reverse=True)
        
        # Degree Distribution:
        
        dist = [(hero, sub_graph.degree(hero)) for hero in sub_graph.nodes()]
        
        # Finding Hubs:
        
        soglia = np.percentile([x[1] for x in dist], 0.95)
        hubs = [(x[0],x[1]) for x in dist if x[1] >= soglia]
        
        return sub_graph, info, lista, hubs, dist
    
    if graph_type == 2:
        
        sub_graph, top = top_hero_from_graph2(edges, G, top_N, p= True)
        
        n_nodes = len(sub_graph.nodes)        # number of nodes in the sub network
        density = nx.density(sub_graph)       # sub network's density
        average_degree = sum([sub_graph.degree[i] for i in sub_graph.nodes])/len(sub_graph.nodes)     # average degree of the network
        s_or_d  = "Sparse" if density < 0.5 else "Dense"
        
        info.append([n_nodes, round(density, 3), round(average_degree, 3), s_or_d] ) 
        print(tabulate(info, headers="firstrow", tablefmt="fancy_grid", numalign='center', stralign="center"))
        
        # Finding the number of heroes that have appeared in each comic:
        
        selected_nodes = [n for n,v in sub_graph.nodes(data=True) if v['type'] == 'hero'] 
        degreeC_dict = nx.degree_centrality(sub_graph)
        top = sorted(degreeC_dict.items(), key=lambda item: item[1], reverse =True)[:25+top_N]
        top_comics = [x for x in top if x[0] not in selected_nodes]
        heroes_in_comic = [ (node[0], sub_graph.degree(node[0]) ) for node in top_comics ]

        # Finding Hubs second graph:
        
        h, a = nx.hits(sub_graph, max_iter=1000)
        h = sorted(h.items(), key=lambda x:x[1], reverse= True)
        h = [(x[0],(round(x[1], 6))) for x in h]
        soglia  = np.quantile(np.array([x[1]for x in h]), 0.95)
        hubs = [(x[0],x[1]) for x in h if x[1] >= soglia ]
        
        ## Degree Distribution:
        
        dist = [(hero, sub_graph.degree(hero)) for hero in sub_graph.nodes()]
        
        return sub_graph, info, heroes_in_comic, hubs, dist

top_heros = edges.groupby(['hero']).count()
top_heros = top_heros.sort_values('comic', ascending=False)
n_heros=list(top_heros.index)

def func2(G, node, metric, n_heros, N=len(G.nodes())):
    
    if (G==G_hero):   # If the input graph is the first graph
        # I create the subgraph taking only the N top heroes as nodes
        H_hero_net1 = G.subgraph(n_heros[:N])
    
        # I use the pre-implemented functions to calculate the value of the chosen metric on all the nodes of the graph
        # and I take the value of the metric corresponding to 'node'
        if (metric=='Betweeness'):
            if node in H_hero_net1.nodes():
                return nx.betweenness_centrality(H_hero_net1, weight='weight'), nx.betweenness_centrality(H_hero_net1, weight='weight')[node]
            else:
                return nx.betweenness_centrality(H_hero_net1, weight='weight'), '{} is not in the top {} heroes'.format(node, N)
        elif (metric=='PageRank'):
            if node in H_hero_net1.nodes():
                return nx.pagerank_numpy(H_hero_net1, weight='weight'), nx.pagerank_numpy(H_hero_net1, weight='weight')[node]
            else:
                return nx.pagerank_numpy(H_hero_net1, weight='weight'), '{} is not in the top {} heroes'.format(node, N)
        elif (metric=='ClosenessCentrality'):
            if node in H_hero_net1.nodes():
                return nx.closeness_centrality(H_hero_net1, distance='weight'), nx.closeness_centrality(H_hero_net1, distance='weight')[node]
            else:
                return nx.closeness_centrality(H_hero_net1, distance='weight'), '{} is not in the top {} heroes'.format(node, N)
        else:
            if node in H_hero_net1.nodes():
                return nx.degree_centrality(H_hero_net1), nx.degree_centrality(H_hero_net1)[node]
            else:
                return nx.degree_centrality(H_hero_net1), '{} is not in the top {} heroes'.format(node, N)
    
    else:# If the input graph is the second graph
        # I create the subgraph considering the top N heroes and considering their edges with the comics
        H_hero_net2, _ = top_hero_from_graph2(edges, G, N)
        
        # I do the same things I did before, this time, however, the graph is not weighted
        if (metric=='Betweeness'):
            if node in H_hero_net2.nodes():
                return nx.betweenness_centrality(H_hero_net2), nx.betweenness_centrality(H_hero_net2)[node]
            else:
                return nx.betweenness_centrality(H_hero_net2), '{} is not in the top {} heroes'.format(node, N)
        elif (metric=='PageRank'):
            if node in H_hero_net2.nodes():
                return nx.pagerank_numpy(H_hero_net2), nx.pagerank_numpy(H_hero_net2)[node]
            else:
                return nx.pagerank_numpy(H_hero_net2), '{} is not in the top {} heroes'.format(node, N)
        elif (metric=='ClosenessCentrality'):
            if node in H_hero_net2.nodes():
                return nx.closeness_centrality(H_hero_net2), nx.closeness_centrality(H_hero_net2)[node]
            else:
                return nx.closeness_centrality(H_hero_net2), '{} is not in the top {} heroes'.format(node, N)
        else:
            if node in H_hero_net2.nodes():
                return nx.degree_centrality(H_hero_net2), nx.degree_centrality(H_hero_net2)[node]
            else:
                return nx.degree_centrality(H_hero_net2), '{} is not in the top {} heroes'.format(node, N)
            

def dijsktra(G, h_1, h_n):
    # tup is a dict of nodes. It contains tuples of (previous node, weight)
    tup = {h_1: (None, 0)}
    node = h_1
    visited = set()
    
    # As long as the node I'm considering is different from the destination node
    while node != h_n:
        # I mark the node as visited
        visited.add(node)
        # I create a list with the neighbors of the node 'node'
        neigh = list(G.neighbors(node))
        weight_node = tup[node][1]

        for neighbor in neigh:
            # The end node is a neighbor of the initial node
            if neighbor == h_n:
                weight = 1 + weight_node
                if neighbor not in tup:
                    tup[neighbor] = (node, weight)
                else:
                    shortest_weight = tup[neighbor][1]
                    if shortest_weight > weight:
                        tup[neighbor] = (node, weight)
            # The end node is not a neighbor of the initial node
            else:
                # I check that the node is a comic
                if G.nodes()[neighbor]['type']=='comic':
                    weight = 1 + weight_node
                    if neighbor not in tup:
                        tup[neighbor] = (node, weight)
                    else:
                        shortest_weight = tup[neighbor][1]
                        if shortest_weight > weight:
                            tup[neighbor] = (node, weight)
        
        # I create a dictionary that contains the possible destinations, i.e. the nodes that have not yet been visited
        poss_dest = {n: tup[n] for n in tup if n not in visited}
        
        # If the dictionary containing the possible destinations is empty, I print
        if not poss_dest:
            return "There is no such path"
        
        # I choose the next node as the node with the lowest weight "There is no such path"
        node = min(poss_dest, key=lambda k: poss_dest[k][1])
    
    # I choose the shortest path between the two nodes
    path = []
    while node is not None:
        path.append(node)
        next_node = tup[node][0]
        node = next_node
    # Reverse path
    path = path[::-1]
    # From the path I remove the first and last elements which are h_1 and h_n
    return path[1:-1]

def func3(G, h, h_1, h_n, n_heros, N=len(G.nodes())):
    
    # create the subgraph considering the top N heroes and considering their edges with the comics
    H_hero_net2, top = top_hero_from_graph2(edges, G, N, p= True)
    
    # create the path between h_1 and the first element of the list h
    path = dijsktra(G, h_1, h[0])
    node_list = [h_1] + dijsktra(G, h_1, h[0]) + [h[0]]
    
    # create the path between the elements of the list h
    for i in range(len(h)-1):
        
        if (dijsktra(G, h[i], h[i+1]) != "There is no such path"):
            
            path = path + dijsktra(G, h[i], h[i+1])
            node_list = node_list + dijsktra(G, h[i], h[i+1]) + [h[i+1]]
    
    # create the path between the last element of the list h and h_n
    path = path + dijsktra(G, h[-1], h_n)
    node_list = node_list + dijsktra(G, h[-1], h_n) +[h_n]
    
    return path, node_list

import random

def min_cut(G, hero_a, hero_b):
    
    M = nx.MultiGraph(G)
    
    while len(M) > 2:
        # Choose a neighbor of hero_a randomly (except hero_b)
        neig = list(M[hero_a])
        
        # Remove hero_b if it is among the neighbors of hero_a
        if hero_b in neig:
            neig.remove(hero_b)

        if len(neig)>0:
            v = random.choice(neig)
        else:
            break

        # Merge hero_a and v into a single node
        M = nx.contracted_nodes(M, hero_a, v, self_loops=False)
        
    return len(list(M.edges))

def func4(Ggg, hero_a, hero_b, N ):
    
    m=[]      # iterate the min_cut 100 times and I take the minimum of the elements of the list
    
    if (Ggg==G_hero):  
        print(" ")
        sub = find_top1(G_hero, N)    # create subgraph taking only the N top heroes as nodes
        
        for i in range(20):
            m.append(min_cut(sub, hero_a,hero_b))
        
        print('The minimum number of links required to disconnect the original graph in two disconnected subgraphs is: {}'.format(min(m)))
        print(" ")
        return (min(m))
    else: 
        # create the subgraph considering the top N heroes and considering their edges with the comics
        print("--> it doesnt work with Graph 2")
        pass

from networkx.algorithms import community

def funzione_5(graph, top_N, hero1, hero2):
    
    sub_graph = find_top1(graph, top_N )

    communities_generator = community.girvan_newman(sub_graph)
    result = tuple(sorted(c) for c in next(communities_generator))
    result = sorted(result, key=len, reverse=True)
    print(" ")
    labeldict={}
    
    if (hero1 in result[0] and hero2 in result[0]) | (hero1 in result[1] and hero2 in result[1]):
        print("{} and {}  →  belongs to the same community".format(hero1,hero2))
        labeldict = {hero1 : hero1.split("/")[0], hero2 : hero2.split("/")[0], result[1][0] : result[1][0].split("/")[0]}
        
    else:
        print("{} and {}  →  DO NOT belong to the same community".format(hero1,hero2))
        labeldict = {hero1 : hero1.split("/")[0], hero2 : hero2.split("/")[0]}
    edges_removed = sub_graph.degree[result[0][0]]


    print("\nThe minimum number of edges that should be removed to form communities :", edges_removed)
    
    return sub_graph, result, labeldict

def query_for_func2(G1,G2):
    
    avg, node_measure = ([] for i in range(2))
    measure=['Betweeness', 'PageRank', 'ClosenessCentrality', 'DegreeCentrality']   ## List containing all possible metrics
        
    g_type = int(input("\n - Graph type (1 or 2) : "))
    my_node = str(input(" - pick a node (hero or comic): "))
    N = int(input(" - Top N heroes that should be considered : "))
    graph_type = G1 if g_type == 1 else G2

    for i in tqdm(measure): ## For every possible metric
            
        cen_measure=func2(graph_type, my_node, i, n_heros, N)
            # calculate the mean of the dictionary values and insert the mean in the list avg
        mean=sum(cen_measure[0].values())/len(cen_measure[0])
        avg.append(round(mean,3))
            # insert the value of the metric on the node in the list node_measure
        if (type(cen_measure[1]) == float):
            node_measure.append(round(cen_measure[1],3))
        else:
            node_measure.append(cen_measure[1])

    print(" ")
    print(tabulate({'Measure': measure, 'Average_measure': avg, 'Node_measure': node_measure}, headers='keys', tablefmt='fancy_grid'))

# HULK/DR. ROBERT BRUC , DR. STRANGE/STEPHEN , IRON MAN/TONY STARK, COC 1, FF 23