"""Create small canonical/Suite12 fixtures. These are software tests, not AQ results."""
from __future__ import annotations

import argparse
from pathlib import Path
import joblib
import numpy as np
import pandas as pd

STATIC = ['SoTinChi', 'SoTietMH', 'SoTietTuan', 'SiSoMax', 'SiSoMin', 'KhgTinhDTB',
          'IsMHTN', 'IsMonKT', 'IsMHKN', 'IsMHDacThu', 'IsGDTiengAnh', 'IsMonNgoaiNgu']


def generate(out_dir, students=32, folds=(1, 2), seed=19):
    root = Path(out_dir)
    if root.exists() and any(root.iterdir()):
        raise FileExistsError(f'Synthetic output must be empty: {root}')
    cache = root / 'results' / 'cross_faculty_residual_moe' / 'cache'
    structured = root / 'results' / 'suite12_structured_cache'
    cache.mkdir(parents=True)
    structured.mkdir(parents=True)
    rng = np.random.default_rng(seed)
    for faculty in ['IT', 'BUS']:
        records, features, labels, meta = [], [], [], []
        ability = rng.normal(size=students)
        previous = [[] for _ in range(students)]
        course_grades = [[] for _ in range(7)]
        for semester in range(8 + max(folds)):
            additions = [[] for _ in range(7)]
            for s in range(students):
                c = (semester + s) % 6 if semester < 8 else (semester + s) % 7
                recent = np.mean(previous[s][-3:]) if previous[s] else .5
                x = rng.normal(size=6)
                risk = 1 / (1 + np.exp(-(0.55 * x[0] - .45 * ability[s] + 1.8 * (recent - .45) + .25 * (c % 2))))
                y = int(rng.random() < risk)
                grade = rng.uniform(.5, 4.8) if y else rng.uniform(5.1, 9.8)
                year, term = 2020 + semester // 3, semester % 3 + 1
                row = dict(IDSV=f'{faculty}_s{s:04d}', IDMH=f'c{c}', target_NHHK=year * 10 + term,
                           target_grade10=grade, SoTinChi=3., SoTietMH=45., SoTietTuan=3.,
                           SiSoMax=50., SiSoMin=10., KhgTinhDTB=0., IsMHTN=0., IsMonKT=float(c % 2),
                           IsMHKN=0., IsMHDacThu=0., IsGDTiengAnh=0., IsMonNgoaiNgu=0.)
                prior = np.asarray(course_grades[c])
                stats = [len(prior), prior.mean() if len(prior) else np.nan,
                         prior.std(ddof=1) if len(prior) > 1 else np.nan,
                         np.mean(prior < 5) if len(prior) else np.nan,
                         np.mean(prior >= 5) if len(prior) else np.nan]
                records.append(row)
                # Current state never contains the event's outcome or grade.
                features.append([*x[:4], len(previous[s]), float(c % 2)])
                labels.append(y)
                meta.append([row[k] for k in STATIC] + stats)
                previous[s].append(y)
                additions[c].append(grade)
            for c in range(7):
                course_grades[c].extend(additions[c])
        frame = pd.DataFrame(records)
        x, y, course_meta = np.asarray(features, np.float32), np.asarray(labels, np.int8), np.asarray(meta, np.float32)
        event_semester = np.repeat(np.arange(8 + max(folds)), students)
        for fold in folds:
            target_semester = 6 + int(fold)
            tr, te = np.flatnonzero(event_semester < target_semester), np.flatnonzero(event_semester == target_semester)
            covered = event_semester[tr] >= 2
            cf = np.full((len(tr), 3), np.nan)
            baseline = 1 / (1 + np.exp(-.55 * x[:, 0]))
            cf[covered] = baseline[tr[covered], None]
            data = dict(feature_names=['current_a', 'current_b', 'current_c', 'current_d', 'prior_count', 'course_kind'],
                        Xtr=x[tr], Xte=x[te], ytr=y[tr], yte=y[te],
                        train_frame=frame.iloc[tr].reset_index(drop=True), test_frame=frame.iloc[te].reset_index(drop=True),
                        cf_covered_mask=covered, cf_probabilities=cf, cf_block_ids=event_semester[tr], qte=baseline[te])
            # Include missing historical grades to exercise the 1-y fallback.
            data['train_frame'].loc[data['train_frame'].index % 17 == 0, 'target_grade10'] = np.nan
            selected = np.flatnonzero(covered)
            sc = dict(train_row_index=selected, train={'course_target': course_meta[tr[selected]]},
                      target={'course_target': course_meta[te]})
            joblib.dump(data, cache / f'{faculty}_fold_{fold}.joblib')
            joblib.dump(sc, structured / f'{faculty}_fold_{fold}.joblib')
    print(f'Synthetic fixtures written to {root}; no real AQ records or performance claims.', flush=True)
    return root


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--out-dir', required=True)
    parser.add_argument('--students', type=int, default=32)
    parser.add_argument('--folds', nargs='+', type=int, default=[1, 2])
    parser.add_argument('--seed', type=int, default=19)
    args = parser.parse_args()
    if args.students < 4 or min(args.folds) < 1:
        parser.error('Use at least 4 students and positive folds.')
    generate(args.out_dir, args.students, args.folds, args.seed)
