#!/usr/bin/env python3
"""Sequential/restartable STQD v1 experiment suite; one complete console log.

No external-set labels are used for fitting or model selection. AASD/Carta results are
reported as diagnostics only. All training is executed on the user's server.
"""
from __future__ import annotations
import argparse
import csv
import datetime as dt
import json
import os
from pathlib import Path
import subprocess
import sys
import time

HERE = Path(__file__).resolve().parent
BASE = HERE.parent / 'decoder_lodo'
ROOT = HERE.parent.parent
PY = sys.executable
DEFAULT_VARIANTS = ['stqd_full', 'stqd_joint_stem', 'stqd_env', 'stqd_env_onset',
                    'stqd_env_dom', 'stqd_no_time_bias', 'stqd_global_query', 'stqd_cosine']
DEC_BASE = 'vlaai_ws__eaP_n5_t60_aug_cluster_onset_dom_xFUG_ptSPK'


def parse_items(s):
    return [k.strip() for k in s.split(',') if k.strip()]


def decoder_names(n):
    return [DEC_BASE + (f'_s{seed}' if seed else '') for seed in range(n)]


def clf_name(v, seed, prep='eaP_n5_t60', run_tag=''):
    return f'direct_clf__{prep}_huyle_{v}{run_tag}_s{seed}'


def run_cmd(cmd, env, title, logfile, dry_run=False):
    line = ' '.join(map(str, cmd))
    mark = f'\n[{dt.datetime.now().isoformat(timespec="seconds")}] {title}\n$ {line}\n'
    print(mark, flush=True)
    with open(logfile, 'a', buffering=1) as f:
        f.write(mark)
        if dry_run:
            return
        proc = subprocess.Popen([str(x) for x in cmd], cwd=HERE, env=env,
                                stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                                text=True, bufsize=1)
        for ln in proc.stdout:
            print(ln, end='', flush=True)
            f.write(ln)
        code = proc.wait()
        if code:
            f.write(f'FAILED rc={code}: {title}\n')
            raise RuntimeError(f'{title} failed (code {code}); see {logfile}')
        f.write(f'COMPLETED {title}\n')


def missing_inputs(variants, seeds, pretrain, external, nd):
    problems=[]
    expected=[ROOT / 'reports/eda_full/scripts/common.py',
              ROOT / 'baselines/python/SuperHugeAAD',
              BASE / 'cache/eaP_n5_t60',
              HERE.parent / 'external_data/Fuglsang2020/cache/eaP_n5_t60',
              BASE / 'cache/glimpseonorm',
              HERE.parent / 'external_data/Fuglsang2020/cache/glimpseonorm']
    if pretrain:
        expected.append(HERE.parent / 'external_data/SparrKULee/cache/mat_reac')
        expected.append(HERE.parent / 'external_data/SparrKULee/cache/glimpseonorm')
    if external:
        for ds in ('AASD','Carta2026'):
            expected += [HERE.parent/'external_data'/ds/'cache/eaP_n5_t60',
                         HERE.parent/'external_data'/ds/'cache/index.csv']
    for path in expected:
        if not path.exists():
            problems.append(f'Missing {path}')
    for d in decoder_names(nd):
        for held in ('AVGC','DTU','KUL','UHD','USTC'):
            if not (BASE/'folds'/d/f'{held}.pkl').exists() and not (HERE/'folds'/d/f'{held}.pkl').exists():
                problems.append(f'Missing reconstruction fold {d}/{held}; train the original decoder first')
    return problems


def snapshot_results(variants, seeds, outpath, run_tag=""):
    """Summarize completed model-level results; full per-dataset details remain in JSON."""
    rows=[]
    for v in variants:
        for seed in seeds:
            name=clf_name(v,seed,run_tag=run_tag)
            file=HERE/'results'/f'{name}.json'
            if not file.exists():
                continue
            data=json.loads(file.read_text())
            mean=data['causal']['mean']
            row=dict(variant=v,seed=seed,experiment=name,H=mean.get('H'),
                     Acc=mean.get('Acc'),SDT=mean.get('SDT'),L=mean.get('L'))
            for d in ('AVGC','DTU','KUL','UHD','USTC'):
                row[f'H_{d}']=data['causal']['per_dataset'][d]['H']
            rows.append(row)
    if rows:
        with open(outpath,'w',newline='') as fh:
            w=csv.DictWriter(fh,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)
    return rows


def fusion_exists(filename, name, expected_rows):
    from csv import DictReader
    path=HERE/'results'/'research'/filename
    if not path.exists():return False
    with open(path,newline='') as fh:
        rows=[r for r in DictReader(fh) if r.get('name')==name]
    return len(rows)>=expected_rows


def main():
    ap=argparse.ArgumentParser(description=__doc__)
    ap.add_argument('--variants',default=','.join(DEFAULT_VARIANTS))
    ap.add_argument('--seeds',default='0,1',help='For best-paper parity consider 0,1,2,3')
    ap.add_argument('--decoder-seeds',type=int,default=4)
    ap.add_argument('--prep',default='eaP_n5_t60')
    ap.add_argument('--pretrain-epochs',type=int,default=80)
    ap.add_argument('--fine-epochs',type=int,default=40)
    ap.add_argument('--pretrain-mode',choices=['all','none'],default='all')
    ap.add_argument('--run-tag',default='',help='Optional unique suffix, e.g. _scratch or _lr1e4, prevents cache collisions')
    ap.add_argument('--skip-lodo',action='store_true')
    ap.add_argument('--skip-fusion',action='store_true')
    ap.add_argument('--skip-external',action='store_true')
    ap.add_argument('--force-fusion',action='store_true',help='Append fusion results again even if the same grid was already recorded')
    ap.add_argument('--require-existing-decoder-external',dest='build_decoder_external',action='store_false',default=True,help='Fail rather than train unchanged decoder external models when absent')
    ap.add_argument('--dry-run',action='store_true')
    ap.add_argument('--no-preflight',action='store_true',help='Skip missing-input checks (for dry-run demonstration only)')
    ap.add_argument('--logfile',default='logs/huyle_run.log')
    a=ap.parse_args()
    if a.pretrain_mode=='none' and not a.run_tag:
        a.run_tag='_scratch'  # do not silently reuse pretrained folds for from-scratch controls
    if a.run_tag and (not a.run_tag.startswith('_') or not a.run_tag[1:].replace('_','').isalnum()):
        ap.error('--run-tag must start with _ and contain letters, numbers or underscores')
    if a.prep!='eaP_n5_t60':
        ap.error('v1 suite is fixed to eaP_n5_t60; explicit edits required for other preprocessing')
    variants=parse_items(a.variants)
    from stqd_model import VARIANTS
    if any(v not in VARIANTS for v in variants):
        ap.error(f'Unknown variants: {set(variants)-set(VARIANTS)}')
    seeds=[int(x) for x in parse_items(a.seeds)]
    if not seeds or len(set(seeds))!=len(seeds): ap.error('Provide unique seeds')
    if a.decoder_seeds < 1: ap.error('--decoder-seeds must be >=1')
    log=(HERE/a.logfile).resolve();log.parent.mkdir(parents=True,exist_ok=True)
    for path in ('results/research','models','folds','logs'):(HERE/path).mkdir(parents=True,exist_ok=True)
    env=dict(os.environ,PYTHONUNBUFFERED='1',OMP_NUM_THREADS='4',SCORE_JOBS='2')
    problems=[] if a.no_preflight else missing_inputs(variants,seeds,a.pretrain_mode=='all',not a.skip_external,a.decoder_seeds)
    if problems and not a.dry_run:
        raise RuntimeError('Preflight failed:\n'+'\n'.join(' - '+x for x in problems[:60]))
    if problems:
        print('Dry-run missing inputs:\n'+'\n'.join(problems[:25]))
    with open(log,'a') as fh:
        fh.write('\n'+'='*72+f'\nHUYLE RUN {dt.datetime.now().isoformat()}\n')
        fh.write(json.dumps(vars(a),indent=2)+'\n')
    decs=decoder_names(a.decoder_seeds)
    for v in variants:
        names=[clf_name(v,s,run_tag=a.run_tag) for s in seeds]
        for seed,name in zip(seeds,names):
            pre=HERE/'models'/f'pretrain_spk_direct_clf_huyle_{v}{a.run_tag}_s{seed}.pt'
            if a.pretrain_mode=='all' and not pre.exists():
                ev=dict(env,GLIMPSE_THR='onorm')
                cmd=[PY,'direct_classifier.py','--variant',v,'--window-s','10','--pretrain-spk',
                     '--tag',f'_huyle_{v}{a.run_tag}','--train-seed',str(seed),'--min-epochs','25',
                     '--max-epochs',str(a.pretrain_epochs),'--set','model_blocks=3']
                run_cmd(cmd,ev,f'PRETRAIN {v} seed={seed}',log,a.dry_run)
            if not a.skip_lodo:
                ev=dict(env,GLIMPSE_THR='onorm')
                cmd=[PY,'direct_classifier.py','--variant',v,'--prep',a.prep,'--window-s','10',
                     '--train-seed',str(seed),'--min-epochs','10','--max-epochs',str(a.fine_epochs),
                     '--p-switch','0.5','--aug-set','clf_p_switch2=0.5',
                     '--tag',f'_huyle_{v}{a.run_tag}_s{seed}','--aug-variant','cluster']
                if a.pretrain_mode=='all': cmd += ['--init-from',str(pre)]
                if not all((HERE/'folds'/name/f'{d}.pkl').exists() for d in ('AVGC','DTU','KUL','UHD','USTC')):
                    run_cmd(cmd,ev,f'LODO {v} seed={seed} (5 folds, resumable)',log,a.dry_run)
        # only source-domain performance and summary, external comes later.
        if not a.skip_fusion and (a.force_fusion or not fusion_exists('fuse_general.csv', f'huyle_{v}{a.run_tag}', 5*5*3)):
            cmd=[PY,'fuse_general.py','--dec',*decs,'--clf',*names,
                 '--a','0.0','0.3','0.5','0.7','1.0','--pstay','0.99','0.998','0.9997',
                 '--name',f'huyle_{v}{a.run_tag}']
            run_cmd(cmd,env,f'LODO FUSION {v}',log,a.dry_run)
        if not a.dry_run:
            rows=snapshot_results(variants,seeds,HERE/'results'/'huyle_summary.csv',run_tag=a.run_tag)
            with open(log,'a') as fh:fh.write(f'MODEL SUMMARY rows={len(rows)} at {dt.datetime.now().isoformat()}\n')
    if not a.skip_external:
        # Train the legacy reconstruction branch using the existing decoder training code,
        # only if its external evidence has not already been produced in decoder_lodo.
        for seed in range(a.decoder_seeds):
            ext_names=[f'aasd_c1_best_evidence_s{seed}.pkl',f'ext_c1_Carta2026_best_evidence_s{seed}.pkl']
            exists=all(any((root/'results'/'research'/n).exists() for root in (HERE,BASE)) for n in ext_names)
            n=', '.join(ext_names)
            if not exists:
                if not a.build_decoder_external and not a.dry_run:
                    raise RuntimeError(f'Missing {n}. Omit --require-existing-decoder-external to generate it.')
                cmd=[PY,'eval_external.py','--seed',str(seed),'--dataset','AASD,Carta2026',
                     '--prep',a.prep,'--targets','env,onset,dom','--extra-train','Fuglsang2020',
                     '--init-from',str(BASE/'models'/f'pretrain_spk_vlaai_ws_s{seed}.pt'),
                     '--evidence-weights','lda','--tag','_best','--ref',decs[seed]]
                run_cmd(cmd,dict(env,GLIMPSE_THR='norm'),f'ORIGINAL DECODER EXTERNAL seed={seed}',log,a.dry_run)
        for v in variants:
            names=[clf_name(v,s,run_tag=a.run_tag) for s in seeds]
            for seed,name in zip(seeds,names):
                tag=f'_huyle_{v}{a.run_tag}'
                evidence=[HERE/'results'/'research'/f'ext_clf_{ds}{tag}_evidence_s{seed}.pkl'
                          for ds in ('AASD','Carta2026')]
                if not all(p.exists() for p in evidence):
                    cmd=[PY,'eval_external_clf.py','--seed',str(seed),'--variant',v,'--window-s','10',
                         '--prep',a.prep,'--dataset','AASD,Carta2026','--tag',tag,'--ref',name,
                         '--min-epochs','10','--set',f'max_epochs={a.fine_epochs}',
                         '--p-switch','0.5','--aug-set','clf_p_switch2=0.5']
                    if a.pretrain_mode=='all':
                        cmd+=['--init-from',str(HERE/'models'/f'pretrain_spk_direct_clf_huyle_{v}{a.run_tag}_s{seed}.pt')]
                    run_cmd(cmd,dict(env,GLIMPSE_THR='onorm'),f'REAL SWITCH {v} seed={seed}',log,a.dry_run)
            if not a.skip_fusion and (a.force_fusion or not fusion_exists('fuse_external.csv', f'huyle_{v}{a.run_tag}', 2*5*4)):
                cmd=[PY,'fuse_external.py','--dec',*[f'{d}:{seed}' for seed,d in enumerate(decs)],
                     '--clf',*[f'{name}:_huyle_{v}:{seed}' for name,seed in zip(names,seeds)],
                     '--dataset','AASD,Carta2026','--dec-tag','_best',
                     '--a','0.0','0.3','0.5','0.7','1.0',
                     '--pstay','0.95','0.99','0.998','0.9997','--name',f'huyle_{v}{a.run_tag}']
                run_cmd(cmd,env,f'EXTERNAL FUSION {v}',log,a.dry_run)
    if not a.dry_run:
        snapshot_results(variants,seeds,HERE/'results'/'huyle_summary.csv',run_tag=a.run_tag)
        run_cmd([PY,'summarize_results.py'],env,'FINAL RESULTS SUMMARY',log,False)
    print(f'\nDONE. Consolidated stdout/stderr: {log}; outputs under {HERE}/results',flush=True)


if __name__=='__main__':
    main()
