"""Tree test: HistGradientBoosting (absolute error, metric weights) on 427 features (lp45 + causal context) versus +18 regime features.
5-fold CV (seed 0, same folds and inner-validation people as the other experiments) and the public split with seed 42. CPU only."""
import argparse, json, os, sys, time, warnings
import numpy as np, pandas as pd
from sklearn.ensemble import HistGradientBoostingRegressor
HERE = os.path.dirname(os.path.abspath(__file__)); ROOT = os.path.dirname(os.path.dirname(HERE))
sys.path.insert(0, os.path.join(ROOT, "experiments/tree_committee"))
import regime_features as G
import run_tree_committee as T
warnings.filterwarnings("ignore")
R, log = G.R, G.R.log
if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--public-seed", type=int, default=42); ap.add_argument("--smoke", action="store_true")
    args = ap.parse_args()
    X, names, win, rec, new = G.load()
    C, cn = R.core_matrix(X, names); ctx = R.build_context(C, win)
    base = np.concatenate([X, ctx], 1).astype(np.float32)
    sets = {"base427": base, "base427+regime18": np.concatenate([base, new], 1).astype(np.float32)}
    y = win.y.to_numpy(); wrec = win.rec.to_numpy()
    w = R.metric_weights(y, wrec); w = w * len(y) / w.sum()
    idx = win.groupby("rec").indices; rows = lambda rs: np.concatenate([idx[r] for r in rs])
    res = os.path.join(HERE, "results_smoke" if args.smoke else "results", "hgb"); os.makedirs(res, exist_ok=True)
    out, per_rec = [], []
    max_iter = 20 if args.smoke else 300

    def evaluate(tag, fold_id, train_recs, groups, seed):
        tr, va = R.inner_split(train_recs, rec, np.random.default_rng(1000 + seed + 17 * fold_id))
        rtr, rva = rows(tr), rows(va)
        for name, F in sets.items():
            t0 = time.time()
            h = HistGradientBoostingRegressor(loss="absolute_error", learning_rate=0.05, max_depth=6, min_samples_leaf=40,
                                              max_features=0.5, early_stopping=False, max_iter=max_iter, random_state=seed)
            h.fit(F[rtr], y[rtr], sample_weight=w[rtr])
            best, bs = 5, 1e9
            for it, p in enumerate(h.staged_predict(F[rva]), 1):
                if it % 5: continue
                sc = T.wbmae_of(y[rva], p, wrec[rva])[0]
                if sc < bs: best, bs = it, sc
            m = T.HGBAt(h, best); msg = []
            for g, grecs in groups.items():
                rte = rows(grecs); sc, per, bins = T.wbmae_of(y[rte], m.predict(F[rte]), wrec[rte])
                out.append(dict(split=tag, fold=fold_id, seed=seed, group=g, model=name, wbmae=sc, n_iter=best, **bins))
                per_rec.extend(dict(split=tag, fold=fold_id, seed=seed, group=g, model=name, rec=r, wbmae=v) for r, v in per.items())
                msg.append(f"{g} {sc:.1f}")
            log(f"{tag} fold {fold_id} seed {seed} {name:18s} iter {best:3d} inner-val {bs:.1f}  " + "  ".join(msg) + f"  ({time.time() - t0:.0f} s)")
        pd.DataFrame(out).to_csv(os.path.join(res, "scores_by_fold.csv"), index=False)
        pd.DataFrame(per_rec).to_csv(os.path.join(res, "scores_by_recording.csv"), index=False)

    for k, fd in enumerate(R.make_folds(rec, 2 if args.smoke else 5, seed=0)):
        evaluate("cv", k, fd["train"], {"seen": fd["seen"], "unseen": fd["unseen"]}, 0)
    evaluate("public", 0, list(rec.index[rec.split == "train"]), {"test40": list(rec.index[rec.split == "test"])}, args.public_seed)
    d = pd.DataFrame(out); pr = pd.DataFrame(per_rec)
    L = ["# Feature theo giai đoạn trên HistGradientBoosting", "", f"Tạo lúc {time.strftime('%Y-%m-%d %H:%M')}. CPU, loss sai số tuyệt đối, "
         "trọng số metric, số vòng chọn trên tập kiểm tra nội bộ. 5 fold (seed 0) và test công khai (seed 42).", "",
         "| Feature | Seen | Unseen | **Macro (mean ± SD fold)** | 0-40 s | 40-90 s | 90-300 s | 300-600 s | Test công khai (seed 42) |", "|---|---|---|---|---|---|---|---|---|"]
    for name in sets:
        g = d[(d.split == "cv") & (d.model == name)]; t = g.pivot_table(index="fold", columns="group", values="wbmae"); mc = t.mean(1)
        pub = d[(d.split == "public") & (d.model == name)].wbmae.iloc[0]
        L.append(f"| {name} | {t['seen'].mean():.1f} | {t['unseen'].mean():.1f} | **{mc.mean():.1f} ± {mc.std():.1f}** | " +
                 " | ".join(f"{g[c].mean():.1f}" for c in ("mae_0_40", "mae_40_90", "mae_90_300", "mae_300_600")) + f" | {pub:.1f} |")
    q = pr[pr.split == "cv"].pivot_table(index=["fold", "group", "rec"], columns="model", values="wbmae")
    dd = (q["base427+regime18"] - q["base427"]).dropna()
    L += ["", f"So cặp trên từng bản ghi: +regime18 − base427 = {dd.mean():+.2f} ± {dd.std() / np.sqrt(len(dd)):.2f} s "
          f"(n = {len(dd)}, tốt hơn ở {100 * (dd < 0).mean():.0f}% bản ghi)."]
    open(os.path.join(res, "summary.md"), "w").write("\n".join(L) + "\n"); print("\n".join(L))
