import sys
sys.path.insert(0, "..")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.model_selection import StratifiedKFold, cross_validate
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier

from common.datasets import pelanggan_kotor, penjualan_flat, transaksi_ritel, churn_pelanggan

df = pelanggan_kotor()
print("Sebelum:", df.shape, "| duplikat:", df.duplicated().sum(), "| NaN:", df.isna().sum().sum())

d = df.drop_duplicates().copy()
d["kota"] = d["kota"].str.strip().str.title()
d["gender"] = d["gender"].map({"l": "L", "L": "L", "Laki-laki": "L", "p": "P", "P": "P", "Perempuan": "P"})
d.loc[~d["umur"].between(17, 100), "umur"] = np.nan
for c in d.select_dtypes("number").columns:
    d[c] = d[c].fillna(d[c].median())
d["kota"] = d["kota"].fillna(d["kota"].mode()[0])
print("Sesudah:", d.shape, "| NaN:", d.isna().sum().sum())
d.describe().round(1)

# Normalisasi min-max & z-score
num = ["umur", "pendapatan", "total_belanja"]
mm = (d[num] - d[num].min()) / (d[num].max() - d[num].min())
z = (d[num] - d[num].mean()) / d[num].std()
pd.concat({"min-max": mm.describe().loc[["min", "max"]], "z-score": z.describe().loc[["mean", "std"]]}, axis=1).round(2)

jual = penjualan_flat()
jual["kuartal"] = jual["tanggal"].dt.quarter
kubus = jual.pivot_table(index=["wilayah", "kota"], columns="kategori", values="total", aggfunc="sum")
(kubus / 1e6).round(1)   # juta rupiah

# roll-up: kota -> wilayah ; slice: kuartal 4 ; dice: Elektronik & Fashion di wilayah Barat
rollup = jual.groupby("wilayah")["total"].sum() / 1e6
slice_q4 = jual[jual["kuartal"] == 4].groupby("kategori")["total"].sum() / 1e6
dice = jual[(jual["wilayah"] == "Barat") & jual["kategori"].isin(["Elektronik", "Fashion"])]
print("Roll-up:\n", rollup.round(1), "\n\nSlice Q4:\n", slice_q4.round(1), "\n\nDice baris:", len(dice))

trans = transaksi_ritel()
onehot = pd.DataFrame([{i: True for i in t} for t in trans]).fillna(False).astype(bool)
sup1 = onehot.mean().sort_values(ascending=False)
print("Support item teratas:\n", sup1.head(6).round(3))

from itertools import combinations
MIN_SUP = 0.08
sering = [i for i in sup1.index if sup1[i] >= MIN_SUP]
aturan = []
for a, b in combinations(sering, 2):
    s_ab = (onehot[a] & onehot[b]).mean()
    if s_ab < MIN_SUP:
        continue
    for x, y in [(a, b), (b, a)]:
        conf = s_ab / sup1[x]
        aturan.append({"aturan": f"{x} -> {y}", "support": s_ab, "confidence": conf, "lift": conf / sup1[y]})
pd.DataFrame(aturan).sort_values("lift", ascending=False).head(8).round(3)

churn = churn_pelanggan()
X = pd.get_dummies(churn.drop(columns="churn"), dtype=float)
y = churn["churn"]

pohon = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X, y)
print(export_text(pohon, feature_names=list(X.columns)))

cv = StratifiedKFold(5, shuffle=True, random_state=0)
model = {
    "DecisionTree(depth=4)": DecisionTreeClassifier(max_depth=4, random_state=0),
    "GaussianNB": GaussianNB(),
    "KNN(k=15)+zscore": make_pipeline(StandardScaler(), KNeighborsClassifier(15)),
}
rows = []
for nama, mdl in model.items():
    r = cross_validate(mdl, X, y, cv=cv, scoring=["accuracy", "precision", "recall", "f1", "roc_auc"])
    rows.append({"model": nama, **{k[5:]: v.mean() for k, v in r.items() if k.startswith("test_")}})
hasil = pd.DataFrame(rows).set_index("model").round(3)
hasil

hasil[["precision", "recall", "f1", "roc_auc"]].plot.bar(figsize=(9, 3.5), rot=0, title="Perbandingan model (5-fold CV)")
plt.ylim(0, 1); plt.show()

# 1.

# 2.

# 4.