# netowrks
import networkx as nx
import igraph as ig

# data processing
import pandas as pd
import numpy as np
import scipy.sparse as ss

#some functions to make our lifes easier
import sys
sys.path.append("./")
from common_functions import *

# viz
import pylab as plt
import seaborn as sns
import matplotlib as mpl
%matplotlib inline

#Change the default options of visualization (improving the defaults)
custom_params = {"axes.spines.right": False, "axes.spines.top": False, "axes.spines.left": False, "axes.spines.bottom":
False,"lines.linewidth": 2, "grid.color": "lightgray", "legend.frameon": False, "xtick.labelcolor": "#484848", "ytick.labelcolor":
"#484848", "xtick.color": "#484848", "ytick.color": "#484848","text.color": "#484848", "axes.labelcolor": "#484848",
"axes.titlecolor":"#484848","figure.figsize": [5,3],
"axes.titlelocation":"left","xaxis.labellocation":"left","yaxis.labellocation":"bottom"}
palette = ["#3d348b","#e6af2e","#191716","#e0e2db"] #use your favourite colours
sns.set_theme(context='paper', style='white', palette=palette, font='Verdana', font_scale=1.3, color_codes=True,
rc=custom_params)

from IPython.display import display, HTML
display(HTML("<style>.container { width:90% !important; }</style>"))

# Small directed network to understand matrix multiplication
G_dir = nx.from_edgelist([
    ("Alice", "Bob"),
        ("John", "Alice"),
    ("Bob", "John"),
    ("Amy", "John"),
    ("Mike", "John"),
    ("Rose", "Alice"),
    ("Mike", "Rose")
], create_using=nx.DiGraph())

plot_network_adj(G_dir)

# Small undirected network
G_undir = nx.from_edgelist([
    ("Alice", "Bob"),
    ("John", "Alice"),
    ("Bob", "John"),
    ("Amy", "John"),
    ("Mike", "John"),
    ("Rose", "Alice"),
    ("Mike", "Rose")
], create_using=nx.Graph())


plot_network_adj(G_undir)

# Create some metadata
df = pd.DataFrame([["Alice",10],
                  ["Bob",5],
                  ["John",5],
                  ["Amy",1],
                  ["Mike",10],
                  ["Rose",100]], columns=["Person","Income"])

df

#Example to sparse arrays
A = nx.to_scipy_sparse_array(G_dir, nodelist=list(G_dir.nodes()), weight=1)
A

plt.spy(A)

# Convert to graph to sparse array
A = nx.to_scipy_sparse_array(G_dir, nodelist=list(G_dir.nodes()), weight=1)

# Create network
G = nx.from_scipy_sparse_array(A, create_using=nx.DiGraph())
# Rename nodes (they would be integers otherwise, since no labels are kept in the sparse array)
d_names = {i: node for i,node in enumerate(G_dir.nodes())}
print(d_names)
G = nx.relabel_nodes(G, d_names) #add back labels (lost during the conversion)


plot_network_adj(G)

#I packed this in G = adj_to_net(A, d_names)

# Original network adding the income as a color/size
plot_network_adj(G, values = df["Income"]/10)

# adjacency array
A = nx.to_scipy_sparse_array(G_undir)

# Calculate sum of neighbors income
sum_income = ...

# Divide by number of neighbors to get an average
avg_income = ...

print(sum_income)
plot_network_adj(G_undir, values=avg_income/10)

# Number of paths to go from node i to node j in x steps

#x = 1
print("One step away")
plot_network_adj(G_dir)
A = nx.to_scipy_sparse_array(G_dir)

#x = 2
print("Two steps away")
G2 = adj_to_net(...) 
plot_network_adj(G2)

#x = 3
print("Three steps away. Triangles!")
G3 = adj_to_net(...) 
plot_network_adj(G3)

# Number of nodes reached in 3 steps
M = ... # all nodes should be counted only once (e.g. doesn't matter that you can reach Rose in two different ways)
# Set the diagonal to zero (do not count youtself)
...

# Sum the neighbors reached
M.todense().sum(1)

display((A @ A).todense())
display(A.todense())

# Count number of triangles in the directed network
plot_network_adj(G_dir)
A = nx.to_scipy_sparse_array(G_dir)
path_3 = A**3


# For undirected newtorks there are two directions
display(list(zip(G_dir.nodes(), path_3.diagonal() )))

# Number of triangles = trace / 3 (each  triangle count in 3 nodes)
...

# Count number of triangles in the undirected network
plot_network_adj(G_undir)
A = nx.to_scipy_sparse_array(G_undir)
path_3 = A**3


# For undirected newtorks there are two directions
display(list(zip(G_undir.nodes(), path_3.diagonal() / 2)))

# Number of triangles = trace / 6 (each  triangle count in 3 nodes, each triangle counted in two directions)
...

#Local clustering = number of triangles / number of potential links
print(nx.clustering(G_undir)) #standard nx function

# Number of triangles
path_3 = (A**3).diagonal()/2 # divided by two because there are two directions

# Number of potential links between neighbors
degree = A.sum(1)
potential_links = ... # Number of potential links between neighbors (N)(N-1)

list(zip(G_undir.nodes(), path_3, potential_links, path_3/potential_links))

# Degree centrality
cent = nx.degree_centrality(G) 
cent = cent.values()

plot_network_distribution(G, cent)

# Betweeness centrality
...

plot_network_distribution(G, cent)

# Closeness centrality
...

plot_network_distribution(G, cent)

# Harmonic centrality
...

plot_network_distribution(G, cent)

# Eigenvector centrality
...

plot_network_distribution(G, cent)

# Pagerank centrality
...

plot_network_distribution(G, cent)

# Use the function extract_top_10
...


df = pd.concat([cc,bc,ac,ec], axis=1)
df.columns = ["closeness","betweeness","authorities","eigenvalue"]
df

# Who are the most important nodes?

# Bonus: Can you label them in the network in a different color?
# create figure and plot
plt.figure(figsize=(20,16))

# create layout (once so we can reuse it if needed)
node_color = ["tomato" if _ == "PiratePeel" else "gray" for _ in Gt]
node_size = [100 if _ == "PiratePeel" else 10 for _ in Gt]

pos = nx.spring_layout(Gt, seed = 1, iterations=10)
nx.draw(Gt, pos = pos, with_labels = False, node_size=node_size,
        edge_color = "whitesmoke", node_color = node_color)

# Eigenvector centrality, manually
N = len(G_dir)
A = nx.to_numpy_array(G_undir)

# Start with everybody having 1 unit of influence
weight = np.ones(N)
for i in range(100):
    # spread influence to neighbors 
    weight = weight @ A

    # normalize uwing the geometrical mean
    weight = weight / np.sqrt(np.sum(weight**2))
    
    if i < 5:
        print(G_undir.nodes())
        print(weight)

        plot_network(G_undir, None, values = weight)
        plt.show()

# Compare with the results of networkx
print(list(zip(G_undir.nodes(), weight)))
nx.eigenvector_centrality(G_undir)

# PAgerank centrality, manually
N = len(G_dir)
A = nx.to_numpy_array(G_dir)

## Calculate transition matrix (Row normalize matrix)
# construct diagonal inverse degree matrix
degree = A.sum(1)
D = np.diag(1./degree, 0)
A_hat = (D @ A)

# random walkers are spread out evenly
weight = np.ones(N)/N

for i in range(1000):
    # calculate where random walkers go next
    weight = weight @ (0.85*A_hat + 0.15/N)

# Compare results with networkx
print(list(zip(G_dir.nodes(), weight)))
nx.pagerank(G_dir)

N = len(G_undir)
A = nx.to_numpy_array(G_undir)

## construct transition matrix (row normalised adjacency matrix)
# construct diagonal inverse degree matrix
degree = A.sum(1)
D = np.diag(1./degree, 0)
A_hat = (D @ A)

# it does not matter where the walker starts
weight = np.ones(N)/N

for i in range(1000):
    # calculate power
    weight = weight @ (A_hat)
    
    
# Compare to networkx
norm = max(nx.degree_centrality(G_undir).values())/max(weight)
print(list(zip(G_undir.nodes(), weight*norm)))
nx.degree_centrality(G_undir)