from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
import json
from pathlib import Path
import shutil

from omegaconf import OmegaConf
from rich import print
from tqdm import tqdm

from refined_v4.data import load_rows,write_rows,atomic_json,signature
from hinted_rl.teacher_programs import canonical
from . import ROOT,TASKS
from .audit import authentic
from .data import annotate,gold_passes
from .envs import Pool


@dataclass
class Config:
    root: str=str(ROOT/'variants/joint-train-rl-v1')
    source: str=str(ROOT/'variants/clear-full-practice-rl-v1')
    workers: int=8


def build(config: Config):
    source,root=Path(config.source),Path(config.root)
    if (root/'dataset.json').exists():raise ValueError('Joint training environment already frozen')
    report=json.loads((source/'dataset.json').read_text())
    report.update(revision='joint-benchmark-train-rl-v1',source=str(source),
        training_overlap='SFT and RL deliberately share original benchmark TRAINING problems. Calibration/development/test remain held out and byte-identical.',
        rl_policy='Uniform missing length 1..16, then uniform origin: original RL benchmark, SFT-training benchmark, or independently tested fresh practice. Then sample an eligible source.')
    for task in TASKS:
        shutil.copytree(source/'data'/task,root/'data'/task,dirs_exist_ok=True)
        base=load_rows(source,task,'rl')
        groups={row['group'] for row in base}
        demos=base[0]['demonstrations']
        demo_groups={row['group'] for row in demos}
        heldout=[row for split in ('calibration','dev','test') for row in load_rows(source,task,split)]
        blocked={canonical(r['reference']) for r in heldout}
        blocked_groups={r['group'] for r in heldout}
        candidates=[]
        for row in load_rows(source,task,'sft'):
            if not authentic(row) or row['group'] in groups|demo_groups|blocked_groups or canonical(row['reference']) in blocked:continue
            try:
                candidates.append(annotate(dict(row,demonstrations=demos,sampling_origin='sft_benchmark')))
            except ValueError:continue
        with ThreadPoolExecutor(max_workers=config.workers) as pool:
            valid=list(tqdm(pool.map(gold_passes,candidates),total=len(candidates),
                            desc=task+' training benchmark reward checks',colour='green',mininterval=5))
        admitted=[row for row,ok in zip(candidates,valid,strict=True) if ok]
        if len(admitted)<20:raise ValueError('Too few additional benchmark training problems')
        rows=base+admitted
        assert not {r['group'] for r in rows}&blocked_groups
        Pool(rows)
        target=root/'data'/task/'rl.jsonl.gz';write_rows(target,rows)
        report['tasks'][task]['rows']['rl']=len(rows)
        report['tasks'][task]['sft_benchmark_practice']=len(admitted)
        report['tasks'][task]['assets'][str(target.relative_to(root))]=signature(target)
        for split in ('sft','calibration','dev','test'):
            assert signature(root/'data'/task/(split+'.jsonl.gz'))==signature(source/'data'/task/(split+'.jsonl.gz'))
    (root/'sft').symlink_to(source/'sft',target_is_directory=True)
    atomic_json(root/'dataset.json',report)
    print('[green]Complete benchmark TRAIN pool assembled for RL; held-out data unchanged[/green]',flush=True)


if __name__=='__main__':
    build(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config),OmegaConf.from_cli())))