"""DHDL NBFC Loan Default — v6 solution. v5 pipeline + label-free v6 features (schedule position, pricing-vintage age, cohort gap); v5 features\n(payments implied by interest_receive via amortisation inversion, wide-window and per-grade/term age lag).\nExpects train.csv and test.csv; writes submission_v5.csv."""
import os

import numpy as np
import pandas as pd

CATS = ["home_ownership", "income_verification_status", "loan_purpose",
        "state_code", "application_type"]


def load():
    tr = pd.read_csv("train.csv")
    te = pd.read_csv("test.csv")
    return tr, te


def build(df):
    d = pd.DataFrame(index=df.index)
    for c in ["loan_amnt", "interest_rate", "annual_income", "debt_to_income",
              "delinq_2yrs", "public_records", "revolving_balance", "total_acc",
              "interest_receive", "last_week_pay", "total_current_balance",
              "total_revolving_limit"]:
        d[c] = df[c].astype(float)
    d["term"] = df["loan_term"].str[0].astype(float)
    d["grade"] = df["loan_grade"].map({g: i for i, g in enumerate("ABCDEFG")})
    d["subgrade"] = d["grade"] * 5 + df["loan_subgrade"].str[1].astype(float)
    d["job_exp"] = df["job_experience"].map({"<5 Years": 0, "6-10 years": 1, "10+ years": 2})
    for c in CATS:
        d[c] = df[c].astype("category")

    # loan economics
    n = d["term"] * 12
    r = d["interest_rate"] / 1200
    emi = d["loan_amnt"] * r / (1 - (1 + r) ** (-n))
    d["emi"] = emi
    d["total_interest"] = emi * n - d["loan_amnt"]
    d["emi_income"] = emi * 12 / d["annual_income"]
    d["loan_income"] = d["loan_amnt"] / d["annual_income"]
    d["int_rec_frac_total"] = d["interest_receive"] / d["total_interest"]
    d["int_rec_per_loan"] = d["interest_receive"] / d["loan_amnt"]
    d["weeks_frac"] = d["last_week_pay"] / (d["term"] * 52)
    d["int_per_week"] = d["interest_receive"] / d["last_week_pay"].replace(0, np.nan)
    # expected interest after k months of amortisation (treat last_week_pay as weeks)
    k = (d["last_week_pay"] / 52 * 12).clip(upper=n)
    bal_k = d["loan_amnt"] * (1 + r) ** k - emi * ((1 + r) ** k - 1) / r
    exp_int = emi * k - (d["loan_amnt"] - bal_k)
    d["exp_int"] = exp_int
    d["int_gap"] = d["interest_receive"] - exp_int
    d["int_ratio"] = d["interest_receive"] / exp_int.replace(0, np.nan)
    d["revol_util"] = d["revolving_balance"] / d["total_revolving_limit"].replace(0, np.nan)
    d["bal_income"] = d["total_current_balance"] / d["annual_income"]
    d["subgrade_vs_rate"] = d["interest_rate"] - d.groupby(df["loan_subgrade"])["interest_rate"].transform("median")
    return d


def build_all(tr, te, use_id=True):
    al = pd.concat([tr.drop(columns="default"), te], ignore_index=True)
    X = build(al)
    # subgrade-relative rate on full data
    X["subgrade_vs_rate"] = X["interest_rate"] - X.groupby(al["loan_subgrade"])["interest_rate"].transform("median")
    X["rate_rank_in_sub"] = X.groupby(al["loan_subgrade"])["interest_rate"].rank(pct=True)
    if use_id:
        X["ID"] = al["ID"].astype(float)
        order = al["ID"].argsort().values
        lwp = al["last_week_pay"].iloc[order].reset_index(drop=True)
        for w in (51, 201, 801):
            for q in (0.5, 0.9):
                s = lwp.rolling(w, center=True, min_periods=5).quantile(q)
                v = np.empty(len(al)); v[order] = s.values
                X[f"age_w{w}_q{int(q*100)}"] = v
            X[f"behind_w{w}"] = X[f"age_w{w}_q90"] - X["last_week_pay"]
            X[f"behind_frac_w{w}"] = X[f"behind_w{w}"] / X[f"age_w{w}_q90"].replace(0, np.nan)
        age = X["age_w201_q90"]
        k = (age / 52 * 12).clip(upper=X["term"] * 12)
        r = X["interest_rate"] / 1200
        bal = X["loan_amnt"] * (1 + r) ** k - X["emi"] * ((1 + r) ** k - 1) / r
        X["exp_int_age"] = X["emi"] * k - (X["loan_amnt"] - bal)
        X["int_vs_age"] = X["interest_receive"] / X["exp_int_age"].replace(0, np.nan)
    n = len(tr)
    return X.iloc[:n].reset_index(drop=True), X.iloc[n:].reset_index(drop=True)



def add_v5(X, al):
    """v5 additions (all label-free): payments implied by interest_receive, wide-window age, group-wise lag."""
    P = X['loan_amnt'].values; r = X['interest_rate'].values / 1200; N = X['term'].values * 12; E = X['emi'].values
    I = X['interest_receive'].values
    cum = lambda k: E * k - (P - (P * (1 + r) ** k - E * ((1 + r) ** k - 1) / r))
    lo = np.zeros(len(P)); hi = N.copy()
    for _ in range(40):  # bisection: months of schedule whose cumulative interest equals interest_receive
        mid = (lo + hi) / 2; big = cum(mid) > I; hi = np.where(big, mid, hi); lo = np.where(big, lo, mid)
    k = (lo + hi) / 2
    X['n_implied'] = k; X['n_impl_vs_lwp'] = k - X['last_week_pay'] / 4.345
    X['n_impl_vs_age'] = k - X['age_w201_q90'] / 4.345; X['n_impl_frac'] = k - np.floor(k)
    lwp = al['last_week_pay'].values.astype(float); ids = al['ID'].values
    def roll(vals, w, q, group=None):
        out = np.full(len(al), np.nan)
        for g in ([None] if group is None else al[group].unique()):
            idx = np.arange(len(al)) if g is None else np.where(al[group].values == g)[0]
            o = idx[np.argsort(ids[idx])]
            out[o] = pd.Series(vals[o]).rolling(w, center=True, min_periods=5).quantile(q).values
        return out
    X['behind_w3201'] = roll(lwp, 3201, 0.9) - lwp
    ir = X['int_vs_age'].values; X['int_vs_age_nb'] = ir - roll(ir, 201, 0.5)
    X['id_gap'] = al['ID'].rank(pct=True).values
    for g in ('loan_term', 'loan_grade'):
        q90 = roll(lwp, 201, 0.9, g); X[f'behind_{g}'] = q90 - lwp
        X[f'behind_frac_{g}'] = X[f'behind_{g}'] / np.where(q90 == 0, np.nan, q90)
    return X


def build_all_v5(tr, te):
    X, Xt = build_all(tr, te)
    al = pd.concat([tr.drop(columns='default'), te], ignore_index=True)
    XA = add_v5(pd.concat([X, Xt], ignore_index=True), al)
    n = len(tr)
    return XA.iloc[:n].reset_index(drop=True), XA.iloc[n:].reset_index(drop=True)



def add_v6(XA, al):
    """v6 additions (label-free): schedule position (balance left, months left, near-maturity), pricing-vintage age from
    (subgrade, rate) pairs, implied-payment age from neighbours, and cohort-relative payment gap."""
    ids = al['ID'].values
    def roll(vals, w, q, group=None):
        out = np.full(len(al), np.nan)
        for g in ([None] if group is None else al[group].unique()):
            idx = np.arange(len(al)) if g is None else np.where(al[group].values == g)[0]
            o = idx[np.argsort(ids[idx])]
            out[o] = pd.Series(vals[o]).rolling(w, center=True, min_periods=5).quantile(q).values
        return out
    k = XA['n_implied'].values; N = XA['term'].values * 12; lwp = al['last_week_pay'].values.astype(float)
    P = XA['loan_amnt'].values; r = XA['interest_rate'].values / 1200; E = XA['emi'].values
    bal = P * (1 + r) ** k - E * ((1 + r) ** k - 1) / r
    XA['bal_left_frac'] = bal / P; XA['months_left'] = N - k; XA['near_done'] = (k >= N - 1).astype(float)
    XA['impl_weeks_gap'] = k * 4.345 - lwp; XA['impl_frac_term'] = k / N
    sub = al['loan_subgrade'].values; rate = al['interest_rate'].values.astype(float)
    XA['rate_vs_sub_roll'] = rate - roll(rate, 3001, 0.5, 'loan_subgrade')
    key = pd.Series(sub).astype(str) + '_' + pd.Series(rate).round(2).astype(str)
    idr = pd.Series(ids).rank(pct=True); g = idr.groupby(key)
    XA['pair_id_med'] = g.transform('median').values; XA['pair_id_span'] = (g.transform('max') - g.transform('min')).values
    XA['pair_cnt'] = g.transform('size').values
    XA['pair_age'] = pd.Series(lwp).groupby(key).transform(lambda v: v.quantile(.9)).values
    XA['pair_behind'] = XA['pair_age'] - lwp; XA['n_impl_vs_pair'] = k - XA['pair_age'] / 4.345
    XA['age_impl'] = roll(k, 201, 0.9); XA['n_impl_vs_age2'] = k - XA['age_impl']; XA['n_impl_vs_age2_w801'] = k - roll(k, 801, 0.9)
    d = XA['n_impl_vs_age'].values
    for c in ('loan_grade', 'loan_term'):
        XA[f'impl_gap_vs_{c}'] = d - roll(d, 401, 0.5, c)
    XA['impl_gap_pct'] = pd.Series(d).groupby([al['loan_grade'], pd.qcut(XA['age_w201_q90'], 20, duplicates='drop')]).rank(pct=True).values
    return XA


def build_all_v6(tr, te):
    X, Xt = build_all_v5(tr, te)
    al = pd.concat([tr.drop(columns='default'), te], ignore_index=True)
    XA = add_v6(pd.concat([X, Xt], ignore_index=True), al)
    n = len(tr)
    return XA.iloc[:n].reset_index(drop=True), XA.iloc[n:].reset_index(drop=True)

import numpy as np, pandas as pd, warnings, json; warnings.filterwarnings('ignore')
import lightgbm as lgb, xgboost as xgb
from catboost import CatBoostClassifier
from sklearn.model_selection import StratifiedKFold

import sys
SEED = int(os.environ.get('SEED', 2026)); ONLY = sys.argv[1:]
tr, te = load(); X, Xt = build_all_v6(tr, te); y = tr.default.values
skf = list(StratifiedKFold(5, shuffle=True, random_state=SEED).split(X, y))
res = {}

def run(name, fit_pred):
    oof = np.zeros(len(X)); tp = np.zeros(len(Xt))
    for a, b in skf:
        ob, ot = fit_pred(X.iloc[a], y[a], X.iloc[b], y[b])
        oof[b] = ob; tp += ot / len(skf); print(name,'fold',flush=True)
    res[name] = (oof, tp); print(name, 'acc@.5', round(((oof > .5) == y).mean(), 5), flush=True)

def lgb_fp(seed):
    def f(Xa, ya, Xb, yb):
        m = lgb.LGBMClassifier(n_estimators=5000, learning_rate=0.02, num_leaves=63, min_child_samples=30,
                               subsample=0.8, subsample_freq=1, colsample_bytree=0.6, reg_lambda=1,
                               random_state=seed, verbose=-1, n_jobs=1)
        m.fit(Xa, ya, eval_set=[(Xb, yb)], callbacks=[lgb.early_stopping(250, verbose=False)])
        return m.predict_proba(Xb)[:, 1], m.predict_proba(Xt)[:, 1]
    return f

def xgb_fp(Xa, ya, Xb, yb):
    m = xgb.XGBClassifier(n_estimators=5000, learning_rate=0.02, max_depth=7, min_child_weight=3,
                          subsample=0.8, colsample_bytree=0.6, tree_method='hist', enable_categorical=True,
                          early_stopping_rounds=250, eval_metric='logloss', n_jobs=1)
    m.fit(Xa, ya, eval_set=[(Xb, yb)], verbose=False)
    return m.predict_proba(Xb)[:, 1], m.predict_proba(Xt)[:, 1]

def cat_fp(Xa, ya, Xb, yb):
    conv = lambda d: d.assign(**{c: d[c].astype(str) for c in CATS})
    m = CatBoostClassifier(iterations=4000, learning_rate=0.05, depth=7, l2_leaf_reg=3, thread_count=1,
                           od_type='Iter', od_wait=250, verbose=False, cat_features=CATS)
    m.fit(conv(Xa), ya, eval_set=(conv(Xb), yb), use_best_model=True)
    return m.predict_proba(conv(Xb))[:, 1], m.predict_proba(conv(Xt))[:, 1]

JOBS = {'lgb_s1': lambda: lgb_fp(1), 'lgb_s2': lambda: lgb_fp(2), 'xgb': lambda: xgb_fp, 'cat': lambda: cat_fp}
if ONLY:  # worker mode: train one model, save its predictions, stop
    for k in ONLY: run(k, JOBS[k]()); np.save(f'pred_{k}_{SEED}.npy', np.r_[res[k][0], res[k][1]])
    raise SystemExit
for k in JOBS:
    f = f'pred_{k}_{SEED}.npy'
    if os.path.exists(f): a = np.load(f); res[k] = (a[:len(X)], a[len(X):])
    else: run(k, JOBS[k]())

# blend: grid search weights on OOF, then tune threshold
lg = (res['lgb_s1'][0] + res['lgb_s2'][0]) / 2; lgt = (res['lgb_s1'][1] + res['lgb_s2'][1]) / 2
O = {'lgb': (lg, lgt), 'xgb': res['xgb'], 'cat': res['cat']}
best = (0, None, None)
for wl in np.arange(0, 1.01, .1):
    for wx in np.arange(0, 1.01 - wl, .1):
        wc = 1 - wl - wx
        p = wl * O['lgb'][0] + wx * O['xgb'][0] + wc * O['cat'][0]
        for t in np.arange(.40, .61, .01):
            acc = ((p > t) == y).mean()
            if acc > best[0]: best = (acc, (wl, wx, wc), t)
acc, w, t = best
print('BLEND acc', round(acc, 5), 'weights', w, 'thr', round(t, 2))
pt = w[0] * O['lgb'][1] + w[1] * O['xgb'][1] + w[2] * O['cat'][1]
sub = pd.DataFrame({'ID': te.ID, 'default': (pt > t).astype(int)})
sub.to_csv('submission_v6.csv', index=False)
json.dump({'cv_acc': acc, 'weights': w, 'threshold': t,
           'single': {k: ((v[0] > .5) == y).mean() for k, v in O.items()}}, open(f'summary_v6_{SEED}.json', 'w'), indent=1)
print(sub.shape, sub.default.mean())
