from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import pandas as pd

# 1. Prepare features
features = ['income', 'age', 'spending_score']
X = df[features]

# 2. Always scale first!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Fit K-Means
kmeans = KMeans(
    n_clusters=4,
    random_state=42,
    n_init=10
)
clusters = kmeans.fit_predict(X_scaled)

# 4. Add to dataframe
df['cluster'] = clusters
print(df['cluster'].value_counts())

from sklearn.metrics import silhouette_score

scores = []
for k in range(2, 11):
    km = KMeans(n_clusters=k, random_state=42)
    labels = km.fit_predict(X_scaled)
    score = silhouette_score(X_scaled, labels)
    scores.append(score)
    print(f"K={k}: Silhouette = {score:.3f}")

# Pick K with highest silhouette score
best_k = range(2, 11)[scores.index(max(scores))]
print(f"\nBest K = {best_k}")

# Interpretation guide:
# > 0.7  Strong structure
# 0.5-0.7  Reasonable structure
# 0.25-0.5 Weak, may be artificial
# < 0.25  No substantial structure

# Cluster profiles
profile = df.groupby('cluster').agg({
    'income': 'mean',
    'age': 'mean',
    'spending_score': 'mean',
    'customer_id': 'count'
}).round(1)

profile.columns = [
    'Avg Income', 'Avg Age',
    'Avg Spending', 'Count'
]
print(profile)

# Name clusters based on patterns
cluster_names = {
    0: 'High-Value Loyalists',
    1: 'Budget-Conscious Shoppers',
    2: 'Young Big Spenders',
    3: 'Inactive Customers'
}
df['segment'] = df['cluster'].map(
    cluster_names
)

from sklearn.decomposition import PCA

# Reduce to 2D
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# Plot
plt.figure(figsize=(10, 7))
scatter = plt.scatter(
    X_pca[:, 0], X_pca[:, 1],
    c=df['cluster'], cmap='viridis',
    alpha=0.6, s=50
)

# Plot centroids
centers_pca = pca.transform(
    kmeans.cluster_centers_
)
plt.scatter(
    centers_pca[:, 0], centers_pca[:, 1],
    marker='X', s=200, c='red',
    edgecolors='black', linewidths=1.5,
    label='Centroids'
)
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%})')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%})')
plt.legend()

from sklearn.cluster import (
    AgglomerativeClustering
)
from scipy.cluster.hierarchy import (
    dendrogram, linkage
)

# 1. Dendrogram (visual exploration)
Z = linkage(X_scaled, method='ward')

plt.figure(figsize=(12, 6))
dendrogram(Z, truncate_mode='level', p=5)
plt.xlabel('Sample Index')
plt.ylabel('Distance')
plt.title('Ward Linkage Dendrogram')

# 2. Fit with chosen K
hc = AgglomerativeClustering(
    n_clusters=4,
    linkage='ward'
)
df['hc_cluster'] = hc.fit_predict(X_scaled)

# Build RFM features from transactions
from datetime import datetime
today = datetime.now()

rfm = transactions.groupby('user_id').agg({
    'txn_date': lambda x: (today - x.max()).days,
    'txn_id': 'count',
    'amount': 'sum'
}).rename(columns={
    'txn_date': 'recency',
    'txn_id': 'frequency',
    'amount': 'monetary'
})

# Scale and cluster
scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(rfm)

kmeans = KMeans(n_clusters=4, random_state=42)
rfm['segment'] = kmeans.fit_predict(rfm_scaled)

# Profile
rfm.groupby('segment').mean().round(1)

from sklearn.cluster import DBSCAN

# Fit DBSCAN
dbscan = DBSCAN(eps=0.5, min_samples=5)
labels = dbscan.fit_predict(X_scaled)

# Analyze results
n_clusters = len(set(labels)) - (
    1 if -1 in labels else 0
)
n_noise = list(labels).count(-1)

print(f"Clusters found: {n_clusters}")
print(f"Noise points:   {n_noise}")
print(f"Noise ratio:    {n_noise/len(labels):.1%}")

# K-distance plot to find optimal eps
from sklearn.neighbors import NearestNeighbors

nn = NearestNeighbors(n_neighbors=5)
nn.fit(X_scaled)
distances, _ = nn.kneighbors(X_scaled)
distances = np.sort(distances[:, -1])

plt.plot(distances)
plt.ylabel('5-NN Distance')
plt.title('K-Distance Plot')
# Look for the "elbow" = optimal eps

# Method 1: DBSCAN noise detection
dbscan = DBSCAN(eps=0.5, min_samples=10)
labels = dbscan.fit_predict(X_scaled)
anomalies_db = df[labels == -1]
print(f"DBSCAN anomalies: {len(anomalies_db)}")

# Method 2: Centroid distance threshold
kmeans = KMeans(n_clusters=5, random_state=42)
kmeans.fit(X_scaled)
distances = kmeans.transform(X_scaled).min(axis=1)

# Flag top 5% as anomalies
threshold = np.percentile(distances, 95)
anomalies_km = df[distances > threshold]
print(f"K-Means anomalies: {len(anomalies_km)}")

# Method 3: Isolation Forest
from sklearn.ensemble import IsolationForest
iso = IsolationForest(contamination=0.05)
pred = iso.fit_predict(X_scaled)
anomalies_if = df[pred == -1]  # -1 = anomaly

from mlxtend.frequent_patterns import (
    apriori, association_rules
)
from mlxtend.preprocessing import (
    TransactionEncoder
)

# 1. Encode transactions
transactions = [
    ['rice', 'eggs', 'milk'],
    ['rice', 'eggs'],
    ['bread', 'butter', 'coffee'],
    ['rice', 'milk', 'coffee'],
    ['eggs', 'milk', 'bread'],
]

te = TransactionEncoder()
te_arr = te.fit_transform(transactions)
basket = pd.DataFrame(te_arr, columns=te.columns_)

# 2. Find frequent itemsets
freq = apriori(basket, min_support=0.3,
               use_colnames=True)

# 3. Generate rules (mlxtend >= 0.23)
rules = association_rules(
    freq, num_itemsets=len(basket),
    metric='lift', min_threshold=1.0
)
print(rules[['antecedents', 'consequents',
             'support', 'confidence', 'lift']])

# Load sari-sari store transactions
baskets = pd.read_csv('ph_sarisari_txns.csv')

# One-hot encode
encoded = baskets.groupby(
    ['txn_id', 'product']
)['qty'].sum().unstack().fillna(0)
encoded = (encoded > 0).astype(int)

# Find associations
freq = apriori(encoded, min_support=0.02,
               use_colnames=True)
rules = association_rules(
    freq, num_itemsets=len(encoded),
    metric='lift', min_threshold=1.5
)

# Top actionable rules
top = rules[
    (rules['confidence'] > 0.5) &
    (rules['lift'] > 2)
].sort_values('lift', ascending=False)
print(top.head(10))

from datetime import timedelta

# 1. Calculate RFM
snapshot = df['order_date'].max() + timedelta(1)

rfm = df.groupby('customer_id').agg({
    'order_date': lambda x: (snapshot - x.max()).days,
    'order_id': 'nunique',
    'amount': 'sum'
}).rename(columns={
    'order_date': 'recency',
    'order_id': 'frequency',
    'amount': 'monetary'
})

# 2. Quintile scores (1-5)
rfm['R'] = pd.qcut(
    rfm['recency'], 5, labels=[5,4,3,2,1]
)
rfm['F'] = pd.qcut(
    rfm['frequency'].rank(method='first'),
    5, labels=[1,2,3,4,5]
)
rfm['M'] = pd.qcut(
    rfm['monetary'], 5, labels=[1,2,3,4,5]
)

# 3. Combined score
rfm['RFM'] = (rfm['R'].astype(str) +
               rfm['F'].astype(str) +
               rfm['M'].astype(str))

# Use K-Means on RFM features
rfm_features = rfm[['recency', 'frequency',
                     'monetary']].copy()

# Log-transform skewed monetary column
rfm_features['monetary'] = np.log1p(
    rfm_features['monetary'])

scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(rfm_features)

# Find optimal K
from sklearn.metrics import silhouette_score
for k in range(2, 8):
    km = KMeans(n_clusters=k, random_state=42)
    labels = km.fit_predict(rfm_scaled)
    sil = silhouette_score(rfm_scaled, labels)
    print(f"K={k}: Silhouette={sil:.3f}")

# Fit best K (from silhouette loop above)
best_k = max(range(2, 8), key=lambda k:
    silhouette_score(rfm_scaled,
    KMeans(n_clusters=k, random_state=42)
    .fit_predict(rfm_scaled)))
best_km = KMeans(n_clusters=best_k, random_state=42)
rfm['cluster'] = best_km.fit_predict(rfm_scaled)

# Profile and name clusters
profile = rfm.groupby('cluster').agg({
    'recency': 'mean',
    'frequency': 'mean',
    'monetary': ['mean', 'count']
}).round(1)
print(profile)