"""Recheck a retained GENCO experiment and export all campaign metrics.

The numerical pass uses the frozen formulation and a separately instantiated
verifier. The aggregation below independently reconstructs waiting endpoints
and failure counts from the raw case files. No optimization is rerun.
"""
from __future__ import annotations
import argparse
from collections import Counter
import csv
import hashlib
import json
from pathlib import Path
import statistics
import sys
import time


def write(path, value):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(value, indent=2, allow_nan=False)+'\n')


def main():
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument('--run-root', type=Path, required=True)
    p.add_argument('--output', type=Path, required=True)
    p.add_argument('--metrics-only', action='store_true')
    args=p.parse_args();root=args.run_root.resolve();out=args.output.resolve()
    if out.is_relative_to(root):raise ValueError('Write rechecks outside the frozen experiment')
    out.mkdir(parents=True, exist_ok=True)
    sys.path.insert(0, str(root/'source_snapshot/src'))
    import yaml
    from genco_resilience.final_check_design import verify_freeze, accepted, quality, reference_choice
    suite=yaml.safe_load((root/'input_suite.yaml').read_text());freeze=verify_freeze(root)
    saved=json.loads((root/'FINAL_CHECK_SUMMARY.json').read_text())
    print('Frozen files verified:',len(freeze['files']),flush=True)
    rows=[];failures=[];audits=[];hardware=[];aggregate=Counter();started=time.perf_counter()
    for spec in suite['grids']:
        name=spec['name'];folder=root/'study'/name;summary=json.loads((folder/'grid_summary.json').read_text())
        cases=json.loads((root/'inputs'/(name+'_cases.json')).read_text());n=len(cases)
        references={s['id']:{} for s in cases}
        for seed in ('pf','preventive'):
            for path in (folder/'reference_cases'/seed).glob('*.json'):
                r=json.loads(path.read_text());references[r['id']][seed]=r['result']
        selections={sid:reference_choice(v,suite['quality_tolerance_mwh']) for sid,v in references.items()}
        assert selections==summary['reference_choices']
        refs={sid:v[selections[sid]] if selections[sid] is not None else None for sid,v in references.items()}
        hardware.append({'grid':name,'environment':summary['environment'],'cpu_affinity':summary['cpu_affinity'],
                         'startup':summary['startup'],'model_qualification':summary['model_qualification'],
                         'online_started_utc':summary['online_started_utc'],'online_finished_utc':summary['online_finished_utc'],
                         'total_grid_worker_s':summary['total_s']})
        for c in summary['campaigns']:
            location=folder/'campaigns'/f'repeat{c["repeat"]:02d}'/c['policy']
            assert json.loads((location/'campaign.json').read_text())==c
            credit=0.;econ_credit=0.;counts=Counter();costgaps=[];servicegaps=[];retries=0;individual_times=[]
            for entry in c['completions']:
                record=json.loads((location/'cases'/(entry['id']+'.json')).read_text());result=record['result']
                assert entry['id']==record['id']
                q=quality(result,refs[entry['id']],suite['quality_tolerance_mwh'],suite['economic_relative_tolerance'],suite['economic_absolute_tolerance'])
                ok=accepted(result);counts['accepted']+=ok;counts['service_matched']+=q['service_match'];counts['economic_qualified']+=q['economic_noninferior']
                retries+=bool(result.get('fallback_used'))
                individual_times.append(entry['completed_s']-entry['submitted_s'])
                if q['service_match']:credit+=max(0.,c['max_budget_s']-entry['completed_s'])
                if q['economic_noninferior']:econ_credit+=max(0.,c['max_budget_s']-entry['completed_s'])
                if q['operating_objective_gap'] is not None:costgaps.append(q['operating_objective_gap'])
                if q['critical_gap_mwh'] is not None:servicegaps.append(max(abs(q['critical_gap_mwh']),abs(q['noncritical_gap_mwh'])))
                if not q['economic_noninferior']:
                    failures.append({'grid':name,'policy':c['policy'],'repeat':c['repeat'],'scenario':entry['id'],
                        'category':'unresolved' if not ok else 'service_gap' if not q['service_match'] else 'economic_gap',
                        'status':result.get('status'),'critical_gap_mwh':q['critical_gap_mwh'],
                        'noncritical_gap_mwh':q['noncritical_gap_mwh'],'operating_objective_gap':q['operating_objective_gap'],
                        'economic_allowance':q['economic_allowance'],'fallback_used':bool(result.get('fallback_used')),
                        'attempt_stage_statuses':json.dumps([[s.get('solver_status') for s in a.get('stages',[])] for a in result.get('attempts',[result])]),
                        'completed_s':entry['completed_s']})
            service_wait=c['max_budget_s']-credit/n;economic_wait=c['max_budget_s']-econ_credit/n
            assert abs(service_wait-c['service_mean_wait_s'])<1e-10
            assert abs(economic_wait-c['economic_mean_wait_s'])<1e-10
            assert len(c['completions'])+c['not_submitted']==n
            rows.append({'grid':name,'policy':c['policy'],'repeat':c['repeat'],'scenarios':n,
                'executed':len(c['completions']),'accepted':counts['accepted'],'service_matched':counts['service_matched'],
                'economic_qualified':counts['economic_qualified'],'not_submitted':c['not_submitted'],'retries':retries,
                'service_mean_wait_s':service_wait,'economic_mean_wait_s':economic_wait,'campaign_s':c['elapsed_s'],
                'max_budget_s':c['max_budget_s'],'neural_seeds':len(c['neural_seed_actual_ids']),
                'inferences':len(c['prediction_chunks']),'producer_tail_s':max((x['completed_s'] for x in c['prediction_chunks']),default=0),
                'solver_worker_cpu_s':c.get('resource_accounting',{}).get('solver_worker_cpu_s'),
                'parent_cpu_s':c.get('resource_accounting',{}).get('parent_cpu_s'),
                'minimum_cost_gap':min(costgaps,default=None),'maximum_cost_gap':max(costgaps,default=None),
                'maximum_service_gap_mwh':max(servicegaps,default=None),
                'median_individual_elapsed_s':statistics.median(individual_times)})
            aggregate.update({'online_evaluations':len(c['completions']),'accepted_online':counts['accepted'],
                              'service_matched_online':counts['service_matched'],'economic_qualified_online':counts['economic_qualified'],
                              'not_submitted':c['not_submitted'],'retries':retries})
        if not args.metrics_only:
            from genco_resilience.final_check_audit import audit_grid
            print('Rechecking AC physics, all attempts and DataKit:',name,flush=True)
            audit=audit_grid(root,suite,spec,summary);audits.append(audit);write(out/(name+'_numerical_recheck.json'),audit)
            assert audit['passed'],audit
        print(name,'complete; elapsed seconds',round(time.perf_counter()-started,2),flush=True)
    for filename,values in [('campaign_metrics.csv',rows),('failure_diagnostics.csv',failures)]:
        if values:
            with (out/filename).open('w',newline='') as f:
                writer=csv.DictWriter(f,fieldnames=list(values[0]));writer.writeheader();writer.writerows(values)
    write(out/'hardware_and_qualification.json',hardware)
    result={'passed':True,'frozen_files_verified':len(freeze['files']),'campaigns_reaggregated':len(rows),
            **aggregate,'failure_categories':dict(Counter(f['category'] for f in failures)),
            'numerical_audits':audits,'physics_recheck_run':not args.metrics_only,
            'numerical_verification_uses_frozen_verifier_implementation':True,
            'aggregation_recomputed_from_raw_records':True,'elapsed_s':time.perf_counter()-started,
            'original_recorded_audit_passed':saved['audit_passed'],'original_speedup_flags':sum(c['descriptive_speedup_supported'] for c in saved['comparisons'])}
    write(out/'RECHECK.json',result);print(json.dumps(result,indent=2),flush=True)


if __name__=='__main__':main()
