# First, let us import what we need and silence warnings
import warnings
warnings.filterwarnings("ignore")
import numpy as np
import pandas as pd

# Data setup
# Let us use the Mall Customers dataset: shopping data for clustering.
url = "https://raw.githubusercontent.com/rithwik00/Mall-Customer-Dataset/main/Mall_Customers.csv"
df = pd.read_csv(url)
print("Shape:", df.shape)
df.head()

# Let us look at the column names and some summary statistics too.
df.columns = df.columns.str.strip()
print("Columns:", df.columns.tolist())
df.describe()

# We will focus on two columns: 'Annual Income (k$)' and 'Spending Score (1-100)'
features = df[["Annual Income (k$)", "Spending Score (1-100)"]].copy()
features.head()

# Let us try DBSCAN
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import DBSCAN

# First, scale our features so each has equal weight
scaler = StandardScaler()
X_scaled = scaler.fit_transform(features)

# Set up and fit DBSCAN
dbscan = DBSCAN(eps=0.5, min_samples=5)
labels = dbscan.fit_predict(X_scaled)
# Add cluster labels to our data
df["Cluster"] = labels
df[["Annual Income (k$)", "Spending Score (1-100)", "Cluster"]].head()

# Count how many points are in each cluster
print(df["Cluster"].value_counts())

# Let us visualize our DBSCAN clusters
import matplotlib.pyplot as plt

plt.figure(figsize=(8,6))
for cluster in sorted(df["Cluster"].unique()):
    mask = df["Cluster"] == cluster
    if cluster == -1:
        color = "gray"
        label = "Noise"
    else:
        color = None
        label = f"Cluster {cluster}"
    plt.scatter(df.loc[mask, "Annual Income (k$)"],
                df.loc[mask, "Spending Score (1-100)"],
                c=color, label=label, alpha=0.6)
plt.xlabel("Annual Income (k$)")
plt.ylabel("Spending Score (1-100)")
plt.title("DBSCAN clustering results")
plt.legend()
plt.show()

# Let us try agglomerative hierarchical clustering
from sklearn.cluster import AgglomerativeClustering
clustering = AgglomerativeClustering(n_clusters=3)
hier_labels = clustering.fit_predict(X_scaled)
df["HierCluster"] = hier_labels
df[["Annual Income (k$)", "Spending Score (1-100)", "HierCluster"]].head()

# Visualize hierarchical clustering results
plt.figure(figsize=(8,6))
for cluster in sorted(df["HierCluster"].unique()):
    mask = df["HierCluster"] == cluster
    plt.scatter(df.loc[mask, "Annual Income (k$)"],
                df.loc[mask, "Spending Score (1-100)"],
                label=f"Cluster {cluster}", alpha=0.7)
plt.xlabel("Annual Income (k$)")
plt.ylabel("Spending Score (1-100)")
plt.title("Hierarchical Clustering Results")
plt.legend()
plt.show()

# Draw a dendrogram to see how points were grouped step by step
from scipy.cluster.hierarchy import dendrogram, linkage
linked = linkage(X_scaled, method="ward")
plt.figure(figsize=(12,6))
dendrogram(linked, orientation="top", distance_sort="descending", show_leaf_counts=False)
plt.title("Dendrogram - Hierarchical Clustering")
plt.xlabel("Sample index")
plt.ylabel("Distance")
plt.show()

# Handling input: Let us ask the user to choose a method
print("Which clustering method would you like to try? Type 'dbscan' or 'hierarchical':")
method = input()
if method == 'dbscan':
    result = df["Cluster"]
    print("DBSCAN clusters selected.")
elif method == 'hierarchical':
    result = df["HierCluster"]
    print("Hierarchical clusters selected.")
else:
    print("Unknown option. Please run again and type 'dbscan' or 'hierarchical'.")
    

# Let us look at which labels the user got
if method == 'dbscan':
    print(result.value_counts())
elif method == 'hierarchical':
    print(result.value_counts())

    

# Print statistics for each cluster
choice = 0 if method == 'dbscan' else 1
clusters = ["Cluster", "HierCluster"]
for label in sorted(df[clusters[choice]].unique()):
    print(f"Stats for {clusters[choice]} {label}: ")
    print(df[df[clusters[choice]] == label][["Age", "Annual Income (k$)", "Spending Score (1-100)"]].describe())
    print()

    

# Extra tip: Remove noise or outliers from DBSCAN if needed
if "Cluster" in df and -1 in df["Cluster"].values:
    clean_df = df[df["Cluster"] != -1].copy()
    print(f"Rows after removing noise: {clean_df.shape[0]}")
else:
    clean_df = df.copy()

    

# Challenge: Try DBSCAN with different eps values using input()
eps = float(input("Type a value for eps (try 0.2, 0.4, 0.8): "))
db_alt = DBSCAN(eps=eps, min_samples=5)
labels_alt = db_alt.fit_predict(X_scaled)
print("Clusters with eps =", eps, ":", np.unique(labels_alt))

# Troubleshooting: What if you get too many or too few clusters?
# - Lower eps means fewer neighbors needed, so it makes more clusters.
# - Raise eps if you get too much noise.
# - Lower min_samples to allow smaller groups.
# Use .fit_predict again to update clusters.