# -*- coding: utf-8 -*-
"""
best_blend.py — harness MONOLITHIC (1 file) chay CAU HINH TOT NHAT tu thi nghiem cu:
  XGBoost REGRESSOR + XGBoost CLASSIFIER P(y<event), tron (blend) san:

      raw     = XGBRegressor(champion) fit voi sample_weight vung diem thap (8,3)
      p       = XGBClassifier P(y<event) fit voi scale_pos_weight (can bang lop)
      mean_low= mean diem <event cua TRAIN
      blended = p * mean_low + (1 - p) * raw       # keo ve diem thap khi rui ro cao

  Canh bao mon: warn = blended < event  (diem van hanh TU NHIEN, KHONG tune nguong).

Vi sao cau hinh nay:
  - Qua autoresearch: reg + 1 classifier P(y<event) cho FRONTIER tot nhat (AP ~0.40),
    hon ca champion raw_weighted va hon risk_head 2-classifier (dau y<2 lam hai y<event).
  - Reg CO weight (8,3) cho AP nhinh hon no-weight; classifier la tin hieu doc lap nen
    blend moi them gia tri (khac self-blend thuan regressor).

INPUT: data/splits/<strategy>/fold_<n>/<faculty>_{train,test}.csv  (MOT khoa).
OUTPUT: ACC / PRECISION / RECALL / F1 cho y<event cua BLENDED, va danh gia rieng
        CLASSIFICATION HEAD P(y<event). Metric per-fold + POOLED (micro-average).

Phu thuoc: numpy, pandas, xgboost (keo theo scikit-learn).

CACH DUNG:
  python best_blend.py --faculty khoa_cong_nghe_thong_tin --folds 6,7
  python best_blend.py --faculty khoa_quan_tri_kinh_doanh_va_du_lich --folds all
  python best_blend.py --list
  python best_blend.py --faculty ... --splits_dir /duong/dan/toi/data/splits/expanding
"""
import argparse
import random
import sys
from pathlib import Path

import numpy as np
import pandas as pd
import xgboost as xgb
import torch
from sklearn.metrics import average_precision_score, roc_auc_score

SEED = 42


def seed_everything(seed=SEED):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False


# Cot KHONG phai feature (dong bo src/ml_platform/modeling/__main__.py).
EXCLUDE_COLS = {
    "dataset_split", "student_faculty_key", "student_faculty_name", "IDSV",
    "target_NHHK", "target_semester_ordinal", "IDKQDK", "IDToHoc", "IDMH",
    "target_IDCongDiem", "target_grade10", "target_grade4", "target_status",
    "base_row_id", "course_cluster_label",
}
TARGET = "target_grade10"

# ---- Sieu tham so (sua o day) ----
# Champion XGBoost (val_ratio=0 path trong trainer.py).
XGB_PARAMS = dict(n_estimators=150, learning_rate=0.05, max_depth=8,
                  subsample=0.8, colsample_bytree=1, random_state=SEED, n_jobs=-1)
# Sample-weight vung diem thap cho REGRESSOR: y<5 -> W_LOW ; [5,6) -> W_MID ; else 1.
USE_REG_WEIGHT = True
W_LOW = 8.0
W_MID = 3.0
CLS_THRESHOLD = 0.5     # nguong quyet dinh cho classification head (p >= CLS_THRESHOLD)


def low_grade_weights(y, event):
    """Trong so mau theo vung diem (tai hien trainer._low_grade_weights, w2=w5)."""
    return np.where(y < event, W_LOW, np.where(y < event + 1.0, W_MID, 1.0))


def load_fold(faculty, fold, splits_dir):
    """Nap 1 fold: bo null target, ep so, impute mean TRAIN (giong fold_data.py)."""
    tr_path = splits_dir / f"fold_{fold}" / f"{faculty}_train.csv"
    te_path = splits_dir / f"fold_{fold}" / f"{faculty}_test.csv"
    if not tr_path.exists() or not te_path.exists():
        return None

    tr = pd.read_csv(tr_path, low_memory=False)
    te = pd.read_csv(te_path, low_memory=False)
    tr[TARGET] = pd.to_numeric(tr[TARGET], errors="coerce")
    te[TARGET] = pd.to_numeric(te[TARGET], errors="coerce")
    tr = tr.dropna(subset=[TARGET]).reset_index(drop=True)
    te = te.dropna(subset=[TARGET]).reset_index(drop=True)
    if len(tr) < 50 or len(te) == 0:
        return None

    feats = [c for c in tr.columns if c not in EXCLUDE_COLS and c in te.columns]
    Xtr = tr[feats].apply(pd.to_numeric, errors="coerce")
    Xte = te[feats].apply(pd.to_numeric, errors="coerce")
    means = Xtr.mean()
    Xtr = Xtr.fillna(means).fillna(0.0)      # cot toan-null train -> 0
    Xte = Xte.fillna(means).fillna(0.0)

    ytr = tr[TARGET].to_numpy(dtype=float)
    yte = te[TARGET].to_numpy(dtype=float)
    return Xtr, Xte, ytr, yte


def fit_fold(Xtr, ytr, Xte, event):
    """Train regressor (weighted) + classifier P(y<event); tra ve (raw, p, blended, mean_low)."""
    sw = low_grade_weights(ytr, event) if USE_REG_WEIGHT else None
    reg = xgb.XGBRegressor(**XGB_PARAMS)
    reg.fit(Xtr, ytr, sample_weight=sw, verbose=False)
    raw = reg.predict(Xte)

    yb = (ytr < event).astype(int)
    n_pos = int(yb.sum())
    n_neg = len(yb) - n_pos
    clf = xgb.XGBClassifier(**XGB_PARAMS, objective="binary:logistic",
                            eval_metric="logloss",
                            scale_pos_weight=float(n_neg / max(n_pos, 1)))
    clf.fit(Xtr, yb, verbose=False)
    p = clf.predict_proba(Xte)[:, 1]

    mean_low = float(ytr[ytr < event].mean()) if n_pos else event / 2.0
    blended = p * mean_low + (1.0 - p) * raw
    return raw, p, blended, mean_low


def prf(y_bin, warn):
    """acc / precision / recall / f1 / flag_rate cho canh bao nhi phan."""
    t = np.asarray(y_bin, bool); w = np.asarray(warn, bool)
    tp = int((t & w).sum()); fp = int((~t & w).sum())
    fn = int((t & ~w).sum()); tn = int((~t & ~w).sum())
    n = tp + fp + fn + tn
    acc = (tp + tn) / n if n else float("nan")
    pr = tp / (tp + fp) if (tp + fp) else float("nan")
    rc = tp / (tp + fn) if (tp + fn) else float("nan")
    f1 = 2 * pr * rc / (pr + rc) if (pr and rc and pr + rc) else 0.0
    return dict(acc=acc, prec=pr, rec=rc, f1=f1, flag=(tp + fp) / n if n else 0.0,
                tn=tn, fp=fp, fn=fn, tp=tp)


def rank_metrics(y_bin, risk):
    """AP / AUC (risk cao = kha nang y<event cao); khong phu thuoc nguong."""
    y = np.asarray(y_bin, int)
    if y.sum() == 0 or y.sum() == len(y):
        return float("nan"), float("nan")
    return average_precision_score(y, risk), roc_auc_score(y, risk)


def list_faculties(splits_dir):
    facs = set()
    for f in sorted(splits_dir.glob("fold_*")):
        for p in f.glob("*_train.csv"):
            facs.add(p.name[:-len("_train.csv")])
    return sorted(facs)


def _parse_folds(spec, splits_dir):
    if spec.strip().lower() == "all":
        return sorted(int(p.name.split("_")[1]) for p in splits_dir.glob("fold_*"))
    return [int(x) for x in spec.split(",") if x.strip()]


HDR = (f"{'fold':>6} {'test':>7} {'base%':>6} | {'AP':>6} {'AUC':>6} | "
       f"{'ACC':>6} {'PREC':>6} {'REC':>6} {'F1':>6} {'flag%':>6}")


def _row(tag, y_bin, warn, risk):
    m = prf(y_bin, warn); ap, auc = rank_metrics(y_bin, risk)
    n = len(y_bin); base = float(np.mean(y_bin))
    print(f"{tag:>6} {n:>7} {base*100:5.1f}% | {ap:6.3f} {auc:6.3f} | "
          f"{m['acc']:6.3f} {m['prec']:6.3f} {m['rec']:6.3f} {m['f1']:6.3f} {m['flag']*100:5.1f}%")


# Confusion matrix 2x2 co nhan (positive = warn = y<event).
def _cm_matrix(tag, event, y_bin, warn):
    m = prf(y_bin, warn)
    print(f"[{tag}]  confusion matrix (positive = y<{event})")
    print(f"  {'':>16} {'pred WARN':>10} {'pred OK':>10} | {'total':>8}")
    print(f"  {'actual <'+str(event)+' (pos)':>16} {m['tp']:>10} {m['fn']:>10} | {m['tp'] + m['fn']:>8}")
    print(f"  {'actual >='+str(event)+' (neg)':>16} {m['fp']:>10} {m['tn']:>10} | {m['fp'] + m['tn']:>8}")
    print(f"  {'total':>16} {m['tp'] + m['fp']:>10} {m['fn'] + m['tn']:>10} |")


def report(title, per_fold, event, warn_fn, risk_fn):
    """In per-fold + POOLED. warn_fn(rec)->mask canh bao; risk_fn(rec)->diem xep hang."""
    print(f"\n### {title}")
    print(HDR)
    ys, warns, risks = [], [], []
    for fold, rec in per_fold:
        y_bin = rec["y"] < event
        warn = warn_fn(rec); risk = risk_fn(rec)
        _row(str(fold), y_bin, warn, risk)
        ys.append(y_bin); warns.append(warn); risks.append(risk)
    y_all = np.concatenate(ys); warn_all = np.concatenate(warns); risk_all = np.concatenate(risks)
    print("-" * len(HDR))
    _row("POOL", y_all, warn_all, risk_all)

    # Confusion matrix rieng: 2x2 co nhan, tung fold + POOL.
    print()
    for (fold, _), y_bin, warn in zip(per_fold, ys, warns):
        _cm_matrix(f"fold {fold}", event, y_bin, warn)
        print()
    _cm_matrix("POOL", event, y_all, warn_all)


def run_folds(faculty, folds, splits_dir, event):
    """Train+predict tung fold (walk-forward). Tra list (fold, dict(y,raw,p,blended))."""
    per_fold = []
    for fold in folds:
        data = load_fold(faculty, fold, splits_dir)
        if data is None:
            print(f"  fold {fold}: skip (thieu file / <50 mau train / test rong)")
            continue
        Xtr, Xte, ytr, yte = data
        raw, p, blended, mean_low = fit_fold(Xtr, ytr, Xte, event)
        print(f"  fold {fold}: n_train={len(ytr)} n_test={len(yte)} mean_low={mean_low:.2f}")
        per_fold.append((fold, dict(y=yte, raw=raw, p=p, blended=blended)))
    return per_fold


def report_both(prefix, per_fold, event):
    """In ca 2 dau tai diem van hanh tu nhien: BLENDED (<event) va CLF head (p>=0.5)."""
    report(f"{prefix}BLENDED  (warn = blended < event)", per_fold, event,
           lambda r: r["blended"] < event, lambda r: -r["blended"])
    report(f"{prefix}CLASSIFICATION HEAD  (warn = P(y<{event}) >= {CLS_THRESHOLD})", per_fold, event,
           lambda r: r["p"] >= CLS_THRESHOLD, lambda r: r["p"])


def main():
    ap = argparse.ArgumentParser(
        description="XGBoost reg+clf BLENDED -> ACC/PREC/REC/F1 y<event + danh gia classification head.")
    ap.add_argument("--faculty", default="khoa_cong_nghe_thong_tin", help="ten khoa (xem --list)")
    ap.add_argument("--folds", default="6,7", help="danh sach fold holdout, vd '6,7' hoac 'all'")
    ap.add_argument("--dev_folds", default="1,2,3,4,5",
                    help="fold dev CHI DE IN ket qua (khong tune); '' de bo qua")
    ap.add_argument("--splits_dir", default=None, help="mac dinh <file>/data/splits/<strategy>")
    ap.add_argument("--strategy", default="expanding", choices=["expanding", "sliding"])
    ap.add_argument("--event", type=float, default=5.0, help="nguong su kien y<event (mac dinh 5.0)")
    ap.add_argument("--no_reg_weight", action="store_true", help="tat sample-weight cua regressor")
    ap.add_argument("--list", action="store_true", help="liet ke khoa co san roi thoat")
    args = ap.parse_args()

    seed_everything(SEED)

    global USE_REG_WEIGHT
    if args.no_reg_weight:
        USE_REG_WEIGHT = False

    splits_dir = Path(args.splits_dir) if args.splits_dir else \
        Path(__file__).resolve().parent / "data" / "splits" / args.strategy

    if args.list:
        print(f"Splits dir: {splits_dir}")
        for f in list_faculties(splits_dir):
            print("  ", f)
        return
    if not splits_dir.exists():
        sys.exit(f"[ERR] splits_dir khong ton tai: {splits_dir}")
    avail = list_faculties(splits_dir)
    if args.faculty not in avail:
        print(f"[ERR] faculty '{args.faculty}' khong co. Co san:")
        for f in avail:
            print("  ", f)
        sys.exit(1)

    folds = _parse_folds(args.folds, splits_dir)
    dev_folds = _parse_folds(args.dev_folds, splits_dir) if args.dev_folds.strip() else []

    print("=" * len(HDR))
    print(f"FACULTY: {args.faculty} | strategy={args.strategy} | event y<{args.event}")
    print(f"MODEL: XGB regressor ({'weighted %.0f,%.0f' % (W_LOW, W_MID) if USE_REG_WEIGHT else 'no-weight'}) "
          f"+ XGB classifier P(y<{args.event}); blended = p*mean_low + (1-p)*raw")
    print(f"DEV folds (chi in)={dev_folds} | HOLDOUT folds={folds}")
    print("=" * len(HDR))

    # DEV folds: CHI train+in ket qua (khong tune, khong anh huong holdout).
    if dev_folds:
        print("\n>>> DEV folds (chi in ket qua, KHONG tune)")
        dev_pf = run_folds(args.faculty, dev_folds, splits_dir, args.event)
        if dev_pf:
            report_both("DEV — ", dev_pf, args.event)

    # HOLDOUT folds: bao cao chinh, tai diem van hanh tu nhien.
    print("\n>>> HOLDOUT folds")
    per_fold = run_folds(args.faculty, folds, splits_dir, args.event)
    if not per_fold:
        sys.exit("[ERR] khong co holdout fold hop le.")
    report_both("HOLDOUT — ", per_fold, args.event)

    print("\n" + "=" * len(HDR))
    print("Ghi chu: AP/AUC = chat luong xep hang (frontier, khong phu thuoc nguong).")
    print("ACC/PREC/REC/F1 = tai diem van hanh tu nhien o tren. POOL = micro-average (gop fold roi tinh 1 lan).")
    print("DEV folds chi de tham khao — KHONG dung de tune gi.")


if __name__ == "__main__":
    main()
