!pip install --upgrade colorcet dash gensim datashader "holoviews[recommended]" jupyter_bokeh bokeh python-louvain -q

# Import libraries
import pandas as pd
import collections
import networkx as nx
import colorcet as cc
import plotly.graph_objects as go
from dash import Dash, dcc, html, Input, Output
import random
from IPython.display import IFrame, display, Image
from holoviews.operation.datashader import (datashade, aggregate, dynspread, bundle_graph, split_dataframe,  regrid)
from holoviews.element.graphs import layout_nodes
from datashader.layout import forceatlas2_layout, random_layout, circular_layout
import holoviews as hv
import datashader as ds
import datashader.transfer_functions as tf
from datashader.bundling import connect_edges, hammer_bundle
hv.extension("bokeh")
import numpy as np
#from google.colab import drive
#drive.mount('/content/drive')
import time
from holoviews import opts
import math
from scipy.interpolate import splprep, splev
from itertools import combinations
import string
translator = str.maketrans('', '', string.punctuation)
import community as louvain_community
from bokeh.io import output_notebook
output_notebook()
from matplotlib.colors import ListedColormap
import panel as pn
pn.extension()
import colorsys
import matplotlib.colors as mcolors
from typing import List
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from PIL import Image as PILImage
import gc
import io
from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets

# Functions to work with datashader
cvsopts = dict(plot_height = 800, plot_width = 800)

def nodesplot(nodes, name = None, canvas = None, cat = None):

    if canvas is None:

        eps = 1e-6
        xr = (float(nodes.x.min()) - eps, float(nodes.x.max()) + eps)
        yr = (float(nodes.y.min()) - eps, float(nodes.y.max()) + eps)
        canvas = ds.Canvas(x_range = xr, y_range = yr, **cvsopts)

    # Strip cats before mapping
    if cat:

        nodes[cat] = nodes[cat].cat.remove_unused_categories()

    aggregator = None if cat is None else ds.count_cat(cat)
    agg = canvas.points(nodes,'x','y',aggregator)

    if cat:

        cats = list(nodes[cat].cat.categories)
        color_key = dict(zip(cats, make_hex_palette(len(cats))))

        return tf.dynspread(tf.shade(agg, color_key = color_key, name = name))

    return tf.dynspread(tf.shade(agg, cmap = ["#FF3333"], name = name))

def edgesplot(edges, name = None, canvas = None):

    if canvas is None:

        eps = 1e-6
        xr = (float(edges.x.min()) - eps, float(edges.x.max()) + eps)
        yr = (float(edges.y.min()) - eps, float(edges.y.max()) + eps)
        canvas = ds.Canvas(x_range = xr, y_range = yr, **cvsopts)

    return tf.shade(canvas.line(edges, 'x','y', agg = ds.count()), name = name)

def graphplot(nodes, edges, name = "", canvas = None, cat = None, pad = 0.025):

    if canvas is None:

        xmin, xmax = nodes.x.min(), nodes.x.max()
        ymin, ymax = nodes.y.min(), nodes.y.max()

        xpad = (xmax - xmin) * pad
        ypad = (ymax - ymin) * pad

        eps = 1e-6
        xr = (float(xmin - xpad) - eps, float(xmax + xpad) + eps)
        yr = (float(ymin - ypad) - eps, float(ymax + ypad) + eps)

        canvas = ds.Canvas(x_range = xr, y_range = yr, **cvsopts)

    nodeplot = nodesplot(nodes, name + " nodes", canvas, cat)
    edgeplot = edgesplot(edges, name + " edges", canvas)

    return tf.stack(edgeplot, nodeplot, how = "over", name = name)

# Function to create a colormap
def make_hex_palette(n):

    """High-contrast palette optimised for dark backgrounds."""
    result = []

    for i in range(n):

        h = i / n

        # lightness=0.65, saturation=0.95 — bright, vivid, dark-bg friendly
        r, g, b = colorsys.hls_to_rgb(h, 0.65, 0.95)
        result.append('#{:02x}{:02x}{:02x}'.format(int(r * 255), int(g * 255), int(b * 255)))

    return result

# Function to visualize colormap
def plot_colortable(hex_colors: List[str]):

    """Creates a colorbar using custom hex colors."""
    cmap = mcolors.ListedColormap(hex_colors)

    plt.figure(figsize = (8, 2), dpi = 150)
    plt.imshow([list(range(len(hex_colors)))], cmap = cmap, aspect = 'auto')
    plt.axis('off')
    plt.show()

def show_ds_images(images, titles, ncols = 2, fig_width = 18, cell_px = 800, bg = 'black', title_color = 'white', title_size = 11):

    """
    Display a list of datashader images with styled titles and background.

    Parameters
    ----------
    images : list of datashader Image objects
    titles : list of str
    ncols  : number of columns in the grid
    fig_width : total figure width in inches
    cell_px : resolution to render each image (square)
    bg     : hex background colour applied to each image AND the figure
    """

    nrows = -(-len(images) // ncols)
    cell_in = fig_width / ncols
    fig, axes = plt.subplots(nrows, ncols, figsize = (fig_width, cell_in * nrows), facecolor = bg, dpi = 150)
    axes = list(np.atleast_1d(axes).flat)

    for ax, img, title in zip(axes, images, titles):

        # Apply background colour, then upscale with Lanczos for sharpness
        styled = tf.set_background(img, bg)
        pil_img = styled.to_pil()
        pil_img = pil_img.resize((cell_px, cell_px), PILImage.LANCZOS)
        ax.imshow(pil_img, interpolation = 'lanczos')
        ax.set_title(title, color = title_color, fontsize = title_size, fontweight = 'bold', pad = 12, loc = 'center')
        ax.set_facecolor(bg)
        ax.axis('off')

    # Hide any unused axes
    for ax in list(axes)[len(images):]:

        ax.set_visible(False)

    plt.subplots_adjust(wspace = 0.04, hspace = 0.12)
    buf = io.BytesIO()
    plt.savefig(buf, format = 'png', bbox_inches = 'tight', facecolor = bg)
    plt.close()
    buf.seek(0)
    display(Image(data = buf.read()))
    buf.close()

def normalise_layout(df, margin = 0.05):

    """Rescale x, y to [margin, 1-margin] regardless of FA2 coordinate explosion."""
    df['x'] = (df['x'] - df['x'].min()) / (df['x'].max() - df['x'].min())
    df['y'] = (df['y'] - df['y'].min()) / (df['y'].max() - df['y'].min())
    df['x'] = df['x'] * (1 - 2*margin) + margin
    df['y'] = df['y'] * (1 - 2*margin) + margin

    return df

# Functions to map ego networks
def get_ego_network(G, name, radius = 1):

    """Extract the ego network of `name` up to `radius` hops."""
    if name not in G:

        raise ValueError(f'{name!r} not found in graph')

    ego_nodes = nx.ego_graph(G, name, radius = radius).nodes()

    return G.subgraph(ego_nodes).copy()

def ego_stats(G, ego_name):

    """Print summary statistics for an ego network."""
    ego = get_ego_network(G, ego_name)
    n   = ego.number_of_nodes()
    e   = ego.number_of_edges()
    alters = n - 1
    max_edges = alters * (alters - 1) / 2 if alters > 1 else 1
    alter_density = e / max_edges if max_edges > 0 else 0

    cc = nx.clustering(ego, ego_name)

    print(f'  Ego:             {ego_name}')
    print(f'  Alters (degree): {alters}')
    print(f'  Ego-net edges:   {e}')
    print(f'  Alter density:   {alter_density:.4f}')
    print(f'  Local clustering:{cc:.4f}')

    return ego

def plot_ego_network(G, ego_name, ax, title = None, node_size = 80):

    """Draw ego network on a given matplotlib axis."""
    ego = get_ego_network(G, ego_name)
    pos = nx.spring_layout(ego, seed = 100, k = 0.7)

    node_colors = ['#E50914' if n == ego_name else '#888888' for n in ego.nodes()]
    node_sizes  = [node_size * 4 if n == ego_name else node_size for n in ego.nodes()]

    edge_weights = [ego[u][v].get('weight', 1) for u, v in ego.edges()]
    max_w = max(edge_weights) if edge_weights else 1
    edge_widths = [0.5 + 2.0 * (w / max_w) for w in edge_weights]

    nx.draw_networkx_edges(ego, pos, ax=ax, edge_color='#cccccc', width = edge_widths, alpha = 0.7)
    nx.draw_networkx_nodes(ego, pos, ax=ax, node_color=node_colors, node_size = node_sizes, linewidths = 0.5, edgecolors = 'white')
    nx.draw_networkx_labels(ego, pos, ax=ax,labels = {ego_name: ego_name}, font_size = 8, font_color = 'white', font_weight = 'bold')

    n_alters = ego.number_of_nodes() - 1
    ax.set_title(title or f'{ego_name}\n({n_alters} direct collaborators)', fontsize = 9, fontweight = 'bold')
    ax.axis('off')

# Holoviews
kwargs = dict(width = 1000, height = 1000, xaxis = None, yaxis = None)
opts.defaults(opts.Nodes(**kwargs), opts.Graph(**kwargs))
colors = ['#000000'] + hv.Cycle('Category20').values

# Read the file using pandas
df = pd.read_csv('/Users/anon/Downloads/netflix_titles.csv')

# Split the cells to extract data
df['directors'] = df['director'].apply(lambda l: [] if pd.isna(l) else [i.strip() for i in l.split(",")])
df['categories'] = df['listed_in'].apply(lambda l: [] if pd.isna(l) else [i.strip() for i in l.split(",")])
df['actors'] = df['cast'].apply(lambda l: [] if pd.isna(l) else [i.strip() for i in l.split(",")])
df['countries'] = df['country'].apply(lambda l: [] if pd.isna(l) else [i.strip() for i in l.split(",")])

df.head()

# Filter the data for movies with directors only
df2 = df[df['directors'].map(len) > 0]
df2 = df2[df2['actors'].map(len) > 0][['title', 'directors', 'actors']]

# ── Dataset composition ──────────────────────────────────────────
print('=== Dataset Overview ===')
print(f"Total titles:       {len(df):>7,}")
print(f"  Movies:           {(df.type=='Movie').sum():>7,}")
print(f"  TV Shows:         {(df.type=='TV Show').sum():>7,}")
print()
print(f"Titles with cast:   {df['actors'].apply(len).gt(0).sum():>7,}")
print(f"Titles with dir.:   {df['directors'].apply(len).gt(0).sum():>7,}")
print(f"Titles with both:   {(df['actors'].apply(len).gt(0) & df['directors'].apply(len).gt(0)).sum():>7,}")
print()

# Cast size distribution
cast_sizes = df['actors'].apply(len)
dir_sizes  = df['directors'].apply(len)

print(f"Avg cast size (titles with cast): {cast_sizes[cast_sizes > 0].mean():.2f}")
print(f"Max cast size:                    {cast_sizes.max()}")
print(f"Avg directors per title:          {dir_sizes[dir_sizes > 0].mean():.2f}")

# Plot
fig, axes = plt.subplots(1, 2, figsize=(12, 4))

axes[0].hist(cast_sizes[cast_sizes > 0], bins = 30, color = '#E50914', edgecolor = 'black', linewidth = 0.4)
axes[0].set_title('Cast Size Distribution', fontweight='bold')
axes[0].set_xlabel('Number of credited cast members')
axes[0].set_ylabel('Number of titles')

type_counts = df['type'].value_counts()
axes[1].bar(type_counts.index, type_counts.values, color=['#E50914', '#333333'], edgecolor='black', linewidth=0.4)
axes[1].set_title('Movies vs. TV Shows', fontweight='bold')
axes[1].set_ylabel('Number of titles')
for i, v in enumerate(type_counts.values):
    axes[1].text(i, v + 20, f'{v:,}', ha='center', fontweight='bold')

plt.tight_layout()
plt.savefig('dataset_overview.png', dpi=150, bbox_inches='tight')
plt.show()

# Redesign the edges as a people network
people_edges = []

for idx, row in df2.iterrows():

    combos = [(item1, item2) for item1 in row['directors'] for item2 in row['actors'] if item1 is not None]
    pairs = list(combinations(row['actors'], 2))

    for combo in combos:

        people_edges.append(tuple(sorted(combo)))

    for pair in pairs:

        people_edges.append(tuple(sorted(pair)))

people_edges = pd.DataFrame(people_edges, columns = ['source', 'target'])

# Calculate weighred edges
weighted_people_edges = people_edges.groupby(['source', 'target']).size().reset_index(name = 'weight')
weighted_people_edges.sort_values('weight', ascending = False).head()

# Remove punctuation
weighted_people_edges['source'] = weighted_people_edges['source'].astype(str).apply(lambda x: x.translate(translator))
weighted_people_edges['target'] = weighted_people_edges['target'].apply(lambda x: x.translate(translator))

people_nodes = pd.DataFrame(pd.unique(weighted_people_edges[['source', 'target']].values.ravel('K')), columns = ['name'])

# Convert the nodes to indices for mapping
#node_to_idx = {node: i for i, node in enumerate(people_nodes['name'])}
#weighted_people_edges["source"] = weighted_people_edges["source"].map(node_to_idx)
#weighted_people_edges["target"] = weighted_people_edges["target"].map(node_to_idx)

# Filter the graph for meaningful connections
filtered_people_edges = (weighted_people_edges[weighted_people_edges.weight >= 2]).copy()

# Keep nodes that appear in filtered edges
remaining_nodes = pd.unique(filtered_people_edges[['source','target']].values.ravel())

filtered_people_nodes = people_nodes[people_nodes.name.isin(remaining_nodes)].copy()

print('Filtering graph based on edge weights..\n')
print(f"Initial Configuration: \nNodes- {people_nodes.shape[0]}\nEdges- {weighted_people_edges.shape[0]}\n")
print(f"Filtered Result: \nNodes- {filtered_people_nodes.shape[0]}\nEdges- {filtered_people_edges.shape[0]}\n")

# Build the most expansive graph
graph = nx.from_pandas_edgelist(weighted_people_edges, source = "source", target = "target", edge_attr = "weight")
filtered_graph = nx.from_pandas_edgelist(filtered_people_edges, source = "source", target = "target", edge_attr = "weight")

# Provide a summary
print('Outlook of Unabridged Network-\n')
print("Number of nodes:", graph.number_of_nodes())
print("Number of edges:", graph.number_of_edges())
print("Network density:", round(nx.density(graph), 5))
print("Connected components:", nx.number_connected_components(graph))
print("Largest component size:", len(max(nx.connected_components(graph), key = len)))
print("Average clustering:", round(nx.average_clustering(graph), 5))
print("Average degree:", round(sum(dict(graph.degree()).values()) / graph.number_of_nodes(), 5))

# Provide a summary
print('\nOutlook of Filtered Network-\n')
print("Number of nodes:", filtered_graph.number_of_nodes())
print("Number of edges:", filtered_graph.number_of_edges())
print("Network density:", round(nx.density(filtered_graph), 5))
print("Connected components:", nx.number_connected_components(filtered_graph))
print("Largest component size:", len(max(nx.connected_components(filtered_graph), key = len)))
print("Average clustering:", round(nx.average_clustering(filtered_graph), 5))
print("Average degree:", round(sum(dict(filtered_graph.degree()).values()) / filtered_graph.number_of_nodes(), 5))

print("Computing centrality metrics...")

start = time.time()

# Get items
nodes = list(filtered_graph.nodes())

# Compute
degree = dict(filtered_graph.degree())
degree_centrality = nx.degree_centrality(filtered_graph)
betweenness = nx.betweenness_centrality(filtered_graph, k = 500, seed = 100)
closeness = nx.closeness_centrality(filtered_graph)

# Compile
metrics = pd.DataFrame({"actor": [n for n in nodes],
                        "degree": [degree[n] for n in nodes],
                        "degree_centrality": [degree_centrality[n] for n in nodes],
                        "betweenness": [betweenness[n] for n in nodes],
                        "closeness": [closeness[n] for n in nodes]})

end = time.time()

print(f"Code Execution: {round(end - start)} seconds elapsed")

metrics.head()

# Component size distribution
component_sizes = sorted([len(c) for c in nx.connected_components(filtered_graph)], reverse = True)

fig, axes = plt.subplots(1, 2, figsize=(13, 4))

# Left: top 20 components
top20 = component_sizes[:20]
axes[0].bar(range(1, len(top20)+1), top20, color='#E50914', edgecolor='black', linewidth=0.4)
axes[0].set_title('Top 20 Component Sizes', fontweight='bold')
axes[0].set_xlabel('Component rank')
axes[0].set_ylabel('Number of nodes')
axes[0].spines[['top', 'right']].set_visible(False)
for i, v in enumerate(top20[:5]):
    axes[0].text(i+1, v+10, str(v), ha='center', fontsize=8, fontweight='bold')

# Right: histogram of all component sizes (log scale)
axes[1].hist(component_sizes, bins=40, color='#333333', edgecolor='white', linewidth=0.3)
axes[1].set_yscale('log')
axes[1].set_title('Component Size Histogram (log scale)', fontweight='bold')
axes[1].set_xlabel('Component size (nodes)')
axes[1].set_ylabel('Count (log scale)')
axes[1].spines[['top', 'right']].set_visible(False)

plt.suptitle(f'Filtered graph: {len(component_sizes)} components  •  '
             f'Largest = {component_sizes[0]:,} nodes  •  '
             f'Median = {int(np.median(component_sizes))} nodes',
             fontsize=10, y=1.02)
plt.tight_layout()
plt.savefig('component_sizes.png', dpi=150, bbox_inches='tight')
plt.show()

# ── Top 20 by degree centrality ──────────────────────────────────
top_degree = metrics.sort_values('degree_centrality', ascending = False).head(20)

fig, ax = plt.subplots(figsize=(11, 6))
colors_bar = ['#E50914' if i < 5 else '#B0B0B0' for i in range(len(top_degree))]
bars = ax.barh(top_degree['actor'][::-1], top_degree['degree_centrality'][::-1], color = colors_bar[::-1], edgecolor = 'white', linewidth = 0.4)

for bar, deg in zip(bars, top_degree['degree'][::-1]):

    ax.text(bar.get_width() + 0.00005, bar.get_y() + bar.get_height()/2, f'  {int(deg)} connections', va = 'center', fontsize = 8, color = '#333333')

ax.set_xlabel('Degree Centrality', fontsize=10)
ax.set_title('Top 20 Nodes by Degree Centrality\n'
             '(normalised: share of all possible connections)', fontsize = 12, fontweight = 'bold')
ax.spines[['top', 'right']].set_visible(False)
ax.set_xlim(0, top_degree['degree_centrality'].max() * 1.35)
plt.tight_layout()
plt.savefig('degree_centrality.png', dpi=150, bbox_inches='tight')
plt.show()

# ── Top 20 by betweenness centrality ────────────────────────────
top_between = metrics.sort_values('betweenness', ascending = False).head(20)

fig, ax = plt.subplots(figsize=(11, 6))
colors_bar = ['#E50914' if i < 5 else '#B0B0B0' for i in range(len(top_between))]
ax.barh(top_between['actor'][::-1], top_between['betweenness'][::-1], color = colors_bar[::-1], edgecolor='white', linewidth=0.4)

ax.set_xlabel('Betweenness Centrality', fontsize=10)
ax.set_title('Top 20 Nodes by Betweenness Centrality\n'
             '(fraction of shortest paths passing through this node)', fontsize=12, fontweight='bold')
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.savefig('betweenness_centrality.png', dpi=150, bbox_inches='tight')
plt.show()

# ── Top 20 by closeness centrality ─────────────────────────────
top_close = metrics.sort_values('closeness', ascending=False).head(20)

fig, ax = plt.subplots(figsize=(11, 6))
colors_bar = ['#E50914' if i < 5 else '#B0B0B0' for i in range(len(top_close))]
ax.barh(top_close['actor'][::-1], top_close['closeness'][::-1], color = colors_bar[::-1], edgecolor = 'white', linewidth = 0.4)

ax.set_xlabel('Closeness Centrality', fontsize=10)
ax.set_title('Top 20 Nodes by Closeness Centrality\n'
             '(inverse average distance to all other nodes)', fontsize = 12, fontweight = 'bold')
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.savefig('closeness_centrality.png', dpi=150, bbox_inches='tight')
plt.show()

# ── Betweenness vs Degree scatter ───────────────────────────────
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Scatter: betweenness vs degree_centrality
sc = axes[0].scatter(
    metrics['degree_centrality'],
    metrics['betweenness'],
    c = metrics['closeness'], cmap = 'RdYlGn',
    alpha = 0.4, s = 8, linewidths = 0)
plt.colorbar(sc, ax=axes[0], label='Closeness centrality')

# Label top-5 betweenness nodes
top5_b = metrics.nlargest(5, 'betweenness')

for _, row in top5_b.iterrows():

    axes[0].annotate(row['actor'],
                     (row['degree_centrality'], row['betweenness']),
                     fontsize=7, xytext=(4, 4), textcoords='offset points', color='#E50914')

axes[0].set_xlabel('Degree Centrality')
axes[0].set_ylabel('Betweenness Centrality')
axes[0].set_title('Betweenness vs. Degree\n(colour = closeness)', fontweight='bold')
axes[0].spines[['top', 'right']].set_visible(False)

# Scatter: closeness vs degree_centrality
sc2 = axes[1].scatter(
    metrics['degree_centrality'],
    metrics['closeness'],
    c=metrics['betweenness'], cmap='plasma',
    alpha=0.4, s=8, linewidths=0)
plt.colorbar(sc2, ax=axes[1], label='Betweenness centrality')

top5_c = metrics.nlargest(5, 'closeness')

for _, row in top5_c.iterrows():

    axes[1].annotate(row['actor'],
                     (row['degree_centrality'], row['closeness']),
                     fontsize=7, xytext=(4, 4), textcoords='offset points', color='#0070e0')

axes[1].set_xlabel('Degree Centrality')
axes[1].set_ylabel('Closeness Centrality')
axes[1].set_title('Closeness vs. Degree\n(colour = betweenness)', fontweight='bold')
axes[1].spines[['top', 'right']].set_visible(False)

plt.suptitle('Centrality Correlation Analysis — Filtered Graph', fontsize=13, fontweight='bold', y=1.02)
plt.tight_layout()
plt.savefig('centrality_scatter.png', dpi=150, bbox_inches='tight')
plt.show()

print('\nPearson correlations between centrality measures:')
print(metrics[['degree_centrality', 'betweenness', 'closeness']].corr().round(4))

# Compute metrics
metrics['rank_degree']    = metrics['degree_centrality'].rank(ascending = False)
metrics['rank_between']   = metrics['betweenness'].rank(ascending = False)
metrics['rank_close']     = metrics['closeness'].rank(ascending = False)
metrics['composite_rank'] = (metrics['rank_degree'] + metrics['rank_between'] + metrics['rank_close']) / 3

# Create a leaderboard of composite scores to determine aggregate ranking
leaderboard = (metrics.sort_values('composite_rank').head(15)[['actor', 'degree', 'degree_centrality', 'betweenness', 'closeness', 'composite_rank']].reset_index(drop = True))
leaderboard.index += 1
leaderboard.columns = ['Name', 'Degree', 'Degree Centrality', 'Betweenness', 'Closeness', 'Composite Rank']

leaderboard['Degree Centrality'] = leaderboard['Degree Centrality'].round(5)
leaderboard['Betweenness']       = leaderboard['Betweenness'].round(5)
leaderboard['Closeness']         = leaderboard['Closeness'].round(5)
leaderboard['Composite Rank']    = leaderboard['Composite Rank'].round(1)

print('Top 15 Individuals Based on Composite Rank')
leaderboard.sort_values('Composite Rank', ascending = False)

# Louvain requires a connected graph, so we work on the GCC
gcc_nodes = max(nx.connected_components(filtered_graph), key = len)
gcc = filtered_graph.subgraph(gcc_nodes).copy()

print(f'Largest Connected Component: {gcc.number_of_nodes():,} nodes, {gcc.number_of_edges():,} edges')
print('Running Louvain community detection...')

start = time.time()
partition = louvain_community.best_partition(gcc, weight = 'weight', random_state = 100)
modularity = louvain_community.modularity(partition, gcc, weight='weight')
n_communities = len(set(partition.values()))
end = time.time()

print(f'\nCode Execution Completed in {round(end-start)} seconds')
print(f'Number of communities detected: {n_communities}')
print(f'Modularity score:               {modularity:.4f}')

# Get the size of each community
comm_sizes = collections.Counter(partition.values())
size_series = pd.Series(comm_sizes).sort_values(ascending=False)

print(f'Total communities:    {n_communities}')
print(f'Largest community:    {size_series.iloc[0]:,} nodes')
print(f'Median size:          {int(size_series.median())} nodes')
print(f'Communities with 1 node: {(size_series == 1).sum()}')
print(f'Communities with >50 nodes: {(size_series > 50).sum()}')

# Visalize
fig, axes = plt.subplots(1, 2, figsize=(13, 4))

# Top 30 community sizes
top_comms = size_series.head(30)
palette = make_hex_palette(len(top_comms))
axes[0].bar(range(1, len(top_comms)+1), top_comms.values,
            color=palette, edgecolor='white', linewidth=0.3)
axes[0].set_title('Top 30 Community Sizes', fontweight='bold')
axes[0].set_xlabel('Community rank')
axes[0].set_ylabel('Number of nodes')
axes[0].spines[['top', 'right']].set_visible(False)
for i, v in enumerate(top_comms.values[:5]):
    axes[0].text(i+1, v+5, str(v), ha='center', fontsize=8, fontweight='bold')

# Histogram of all sizes
axes[1].hist(size_series.values, bins=40, color='#E50914', edgecolor='white', linewidth=0.3)
axes[1].set_yscale('log')
axes[1].set_title('Community Size Histogram (log scale)', fontweight='bold')
axes[1].set_xlabel('Community size (nodes)')
axes[1].set_ylabel('Count (log)')
axes[1].spines[['top', 'right']].set_visible(False)

plt.tight_layout()
plt.savefig('community_sizes.png', dpi=150, bbox_inches='tight')
plt.show()

# Add community labels to metrics DataFrame (GCC nodes only)
metrics['community'] = metrics['actor'].map(partition).fillna(-1).astype(int)

# Work only with GCC members
metrics_gcc = metrics[metrics['community'] >= 0].copy()

# Top community IDs by size
top_comm_ids = size_series.head(10).index.tolist()

print(f'Top 10 Communities — Central Members (by degree)\n')

for rank, cid in enumerate(top_comm_ids, start=1):

    members = metrics_gcc[metrics_gcc['community'] == cid].nlargest(5, 'degree')
    names   = ', '.join(members['actor'].tolist())
    size    = size_series[cid]
    avg_deg = metrics_gcc[metrics_gcc['community'] == cid]['degree'].mean()
    print(f'  Community {rank} (id={cid}) | size={size} | avg_degree={avg_deg:.2f}')
    print(f'    Top members: {names}\n')

# Visalize the top 15 communities
top_k_ids  = set(size_series.head(15).index.tolist())
comm_label = {node: (cid if cid in top_k_ids else 15) for node, cid in partition.items()}

# Build node/edge DataFrames for the GCC
gcc_node_list = list(gcc.nodes())
gcc_edge_list = list(gcc.edges())

node_idx  = {n: i for i, n in enumerate(gcc_node_list)}
gcc_nodes_df = pd.DataFrame({'name': gcc_node_list})
gcc_nodes_df['community_label'] = gcc_nodes_df['name'].map(comm_label).fillna(15).astype(int)

gcc_edges_df = pd.DataFrame([(node_idx[u], node_idx[v]) for u, v in gcc_edge_list if u in node_idx and v in node_idx], columns = ['source', 'target'])

print(f'Running ForceAtlas2 layout on {len(gcc_node_list):,} nodes...')
start = time.time()
layout_df = forceatlas2_layout(gcc_nodes_df, gcc_edges_df, iterations = 200, seed = 100)
layout_df = normalise_layout(layout_df)
gcc_nodes_df['x'] = layout_df['x'].values
gcc_nodes_df['y'] = layout_df['y'].values
end = time.time()
print(f'Layout computed in {round(end-start)} seconds')

# Build edge line segments DataFrame for datashader
node_pos = gcc_nodes_df.set_index('name')[['x', 'y']].to_dict(orient = 'index')

edge_segs_x, edge_segs_y = [], []

# Iterate
for u, v in gcc_edge_list:

    if u in node_pos and v in node_pos:

        edge_segs_x += [node_pos[u]['x'], node_pos[v]['x'], np.nan]
        edge_segs_y += [node_pos[u]['y'], node_pos[v]['y'], np.nan]

edge_lines = pd.DataFrame({'x': edge_segs_x, 'y': edge_segs_y})

# Colour palette: one colour per top-K community + grey for 'other'
palette = make_hex_palette(15) + ['#444444']
gcc_nodes_df['community_str'] = gcc_nodes_df['community_label'].astype(str).astype('category')

eps = 1e-6
xr  = (float(gcc_nodes_df.x.min())-eps, float(gcc_nodes_df.x.max())+eps)
yr  = (float(gcc_nodes_df.y.min())-eps, float(gcc_nodes_df.y.max())+eps)

# Compile data for visualization input
canvas = ds.Canvas(x_range=xr, y_range=yr, **cvsopts)

img_edges = tf.shade(canvas.line(edge_lines, 'x', 'y', agg=ds.count()), cmap = ['#1a1a2e', '#444477'], name = 'edges')
img_nodes = nodesplot(gcc_nodes_df, name = 'communities', canvas = canvas, cat = 'community_str')
img_final = tf.stack(img_edges, img_nodes, how = 'over', name = 'Community Graph')

# Display
show_ds_images([img_final], [f'Netflix Collaboration Networks — Top 15 Largest Communities Coloured'], ncols = 1, fig_width = 14, cell_px = 1000)

# ── Intra vs inter community edge count ─────────────────────────
intra, inter = 0, 0
for u, v in gcc.edges():

    if partition.get(u) == partition.get(v):

        intra += 1

    else:

        inter += 1

total = intra + inter
print(f'Intra-community edges: {intra:,}  ({100*intra/total:.1f}%)')
print(f'Inter-community edges: {inter:,}  ({100*inter/total:.1f}%)')
print(f'Modularity:            {modularity:.4f}')

fig, ax = plt.subplots(figsize=(5, 5))
wedges, texts, autotexts = ax.pie(
    [intra, inter],
    labels=['Intra-community', 'Inter-community'],
    autopct='%1.1f%%',
    colors=['#E50914', '#888888'],
    startangle=90,
    wedgeprops={'edgecolor': 'white', 'linewidth': 2})
for t in autotexts:
    t.set_fontsize(12)
    t.set_fontweight('bold')
ax.set_title(f'Edge Distribution — Modularity = {modularity:.3f}', fontweight='bold', fontsize=12)
plt.tight_layout()
plt.savefig('community_edges_pie.png', dpi=150, bbox_inches='tight')
plt.show()

# ── Degree distribution ─────────────────────────────────────────
degrees_all      = sorted([d for _, d in graph.degree()], reverse=True)
degrees_filtered = sorted([d for _, d in filtered_graph.degree()], reverse=True)

fig, axes = plt.subplots(1, 2, figsize=(13, 5))

for ax, degs, label, color in [
        (axes[0], degrees_all,      'Full graph (≥1)',     '#E50914'),
        (axes[1], degrees_filtered, 'Filtered graph (≥2)', '#333333')]:

    counts = collections.Counter(degs)
    ks  = np.array(sorted(counts.keys()))
    pks = np.array([counts[k] for k in ks])

    ax.loglog(ks, pks, 'o', markersize=3, alpha=0.6, color=color, label='Empirical')

    # Fit line through log-log for power-law appearance check
    log_k  = np.log10(ks[ks > 0])
    log_pk = np.log10(pks[ks > 0])
    coeffs = np.polyfit(log_k, log_pk, 1)
    fit_y  = np.polyval(coeffs, log_k)
    ax.loglog(10**log_k, 10**fit_y, '--', color='black', linewidth=1.2,
              label=f'Power-law fit  γ≈{-coeffs[0]:.2f}')

    ax.set_title(f'Degree Distribution — {label}', fontweight='bold')
    ax.set_xlabel('Degree k  (log)')
    ax.set_ylabel('P(k)  (log)')
    ax.legend(fontsize=9)
    ax.spines[['top', 'right']].set_visible(False)

plt.tight_layout()
plt.savefig('degree_distribution.png', dpi=150, bbox_inches='tight')
plt.show()

print(f'Full graph   — max degree: {max(degrees_all)},   mean: {np.mean(degrees_all):.2f},   median: {int(np.median(degrees_all))}')
print(f'Filtered     — max degree: {max(degrees_filtered)}, mean: {np.mean(degrees_filtered):.2f}, median: {int(np.median(degrees_filtered))}')

# ── Edge weight distribution ─────────────────────────────────────
all_weights      = weighted_people_edges['weight'].values
filtered_weights = filtered_people_edges['weight'].values

fig, axes = plt.subplots(1, 2, figsize=(13, 4))

# All edges
axes[0].hist(all_weights, bins=range(1, 25), color='#E50914', edgecolor='white', linewidth=0.4, align='left')
axes[0].set_yscale('log')
axes[0].set_title('Edge Weight Distribution — All Edges', fontweight='bold')
axes[0].set_xlabel('Collaboration count (shared titles)')
axes[0].set_ylabel('Number of pairs (log)')
axes[0].spines[['top', 'right']].set_visible(False)

# Filtered edges (weight ≥ 2)
axes[1].hist(filtered_weights, bins=range(2, int(filtered_weights.max())+2),
             color='#333333', edgecolor='white', linewidth=0.4, align='left')
axes[1].set_yscale('log')
axes[1].set_title('Edge Weight Distribution — Filtered Edges (≥2)', fontweight='bold')
axes[1].set_xlabel('Collaboration count (shared titles)')
axes[1].set_ylabel('Number of pairs (log)')
axes[1].spines[['top', 'right']].set_visible(False)

plt.tight_layout()
plt.savefig('edge_weight_dist.png', dpi=150, bbox_inches='tight')
plt.show()

print(f'Weight stats (all edges):      max={all_weights.max()},  mean={all_weights.mean():.3f},  median={np.median(all_weights)}')
print(f'Weight stats (filtered edges): max={filtered_weights.max()}, mean={filtered_weights.mean():.3f}, median={np.median(filtered_weights)}')

# ── Most frequent collaborating pairs ───────────────────────────
top_pairs = (weighted_people_edges
             .sort_values('weight', ascending=False)
             .head(25)
             .reset_index(drop=True))
top_pairs.index += 1
top_pairs['pair'] = top_pairs['source'] + '  ↔  ' + top_pairs['target']

fig, ax = plt.subplots(figsize=(11, 7))
bars = ax.barh(top_pairs['pair'][::-1], top_pairs['weight'][::-1], color = ['#E50914' if w >= 10 else '#B0B0B0' for w in top_pairs['weight'][::-1]], edgecolor = 'white', linewidth = 0.4)

for bar, w in zip(bars, top_pairs['weight'][::-1]):

    ax.text(bar.get_width() + 0.05, bar.get_y() + bar.get_height()/2, f'  {w} titles', va = 'center', fontsize = 8)

ax.set_xlabel('Number of shared titles')
ax.set_title('Top 25 Most Frequent Collaborations', fontsize=12, fontweight='bold')
ax.spines[['top', 'right']].set_visible(False)
ax.set_xlim(0, top_pairs['weight'].max() * 1.25)
plt.tight_layout()
plt.savefig('top_collaborations.png', dpi=150, bbox_inches='tight')
plt.show()

# ── Clustering coefficient distribution ─────────────────────────
clustering_coeffs = nx.clustering(filtered_graph)
cc_values = list(clustering_coeffs.values())

fig, axes = plt.subplots(1, 2, figsize=(13, 4))

# Histogram
axes[0].hist(cc_values, bins=30, color='#E50914', edgecolor='white', linewidth=0.3)
axes[0].set_title('Clustering Coefficient Distribution', fontweight='bold')
axes[0].set_xlabel('Local clustering coefficient')
axes[0].set_ylabel('Number of nodes')
axes[0].axvline(np.mean(cc_values), color='black', linestyle='--', linewidth=1.5,
                label=f'Mean = {np.mean(cc_values):.3f}')
axes[0].legend()
axes[0].spines[['top', 'right']].set_visible(False)

# Clustering vs Degree scatter
degrees_dict = dict(filtered_graph.degree())
cc_df = pd.DataFrame({'degree': [degrees_dict[n] for n in clustering_coeffs],
                       'cc':     [clustering_coeffs[n] for n in clustering_coeffs]})
# Bin by degree for a cleaner trend line
cc_df['deg_bin'] = pd.cut(cc_df['degree'], bins=20)
binned = cc_df.groupby('deg_bin')['cc'].mean().reset_index()
bin_mids = [iv.mid for iv in binned['deg_bin']]

axes[1].scatter(cc_df['degree'], cc_df['cc'], alpha=0.15, s=6, color='#888888')
axes[1].plot(bin_mids, binned['cc'], color='#E50914', linewidth=2, label='Binned mean')
axes[1].set_title('Clustering vs. Degree', fontweight='bold')
axes[1].set_xlabel('Node degree')
axes[1].set_ylabel('Clustering coefficient')
axes[1].legend()
axes[1].spines[['top', 'right']].set_visible(False)

plt.tight_layout()
plt.savefig('clustering_dist.png', dpi=150, bbox_inches='tight')
plt.show()

print(f'Mean clustering coefficient:   {np.mean(cc_values):.4f}')
print(f'Fraction of isolates (cc=0):   {sum(1 for v in cc_values if v == 0) / len(cc_values):.3f}')
print(f'Fraction with cc=1.0:          {sum(1 for v in cc_values if v == 1.0) / len(cc_values):.3f}')

# Get values for analysis
ego_subjects = {'Top Degree': metrics.sort_values('degree', ascending = False).iloc[0]['actor'],
                'Top Betweenness': metrics.sort_values('betweenness', ascending = False).iloc[0]['actor'],
                'Top Closeness': metrics.sort_values('closeness', ascending = False).iloc[0]['actor'],
                '2nd Betweenness': metrics.sort_values('betweenness', ascending = False).iloc[1]['actor'],}

# Show subjects for analysis
print('Selected ego subjects:')
for role, name in ego_subjects.items():

    row = metrics[metrics['actor'] == name].iloc[0]
    print(f'  {role:<20} {name:<30}  degree = {int(row.degree)}',  f'betweenness = {row.betweenness:.5f},  closeness = {row.closeness:.5f}')