#!/usr/bin/env python
"""Verify the converted diffusers-format adapter loads with ZERO dropped keys,
then re-run the fixed 48-edit subset (12 objects x 4, 20 steps) so the shipped
file's metrics can be compared against the ckpt2000 selection run.

Reference (ckpt2000, ComfyUI-keyed file, same subset @ 20 steps):
  aIoU=0.836 LPIPS=0.087 DINO=0.756   (eval/ckpt_select/summary.json)

Usage: python verify_diffusers_lora.py --out /out/verify
Uploads summary + results to ysharma/gso-orbit-rgba/eval/diffusers_convert/.
"""
import argparse, json, os, logging, collections, sys


def self_fetch_and_import(name):
    """Ensure sibling module is importable even when only this file was fetched."""
    try:
        return __import__(name)
    except ImportError:
        pass
    from huggingface_hub import hf_hub_download
    p = hf_hub_download(repo_id='ysharma/gso-orbit-rgba', repo_type='dataset', filename=f'{name}.py')
    d = os.path.dirname(os.path.abspath(p))
    if d not in sys.path:
        sys.path.insert(0, d)
    return __import__(name)


ee = self_fetch_and_import('eval_edit')

ee.STEPS = 20

MODEL_REPO = 'ysharma/orbit-alpha-lora'
LORA_FILE = 'checkpoints/steps2000res768/orbit_alpha_lora_gate_up_split.safetensors'
DS_REPO = ee.DS_REPO
OUT_REPO_PATH = 'eval/diffusers_convert'


class WarningCollector(logging.Handler):
    def __init__(self):
        super().__init__(level=logging.WARNING)
        self.records = []
    def emit(self, record):
        self.records.append(record.getMessage())


def pick_subset(pairs, n_obj=12):
    by_obj = collections.OrderedDict()
    for p in pairs:
        by_obj.setdefault(p['object_id'], []).append(p)
    objs = list(by_obj)[:n_obj]
    sel = [p for o in objs for p in by_obj[o]]
    assert len(objs) == n_obj and all(len(by_obj[o]) == 4 for o in objs)
    return sel


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('--out', required=True)
    args = ap.parse_args()
    os.makedirs(args.out, exist_ok=True)

    pairs = pick_subset([json.loads(l) for l in open(ee.get_file('pairs_eval.jsonl'))])
    print(f'subset: {len(pairs)} edits', flush=True)

    pipe = ee.load_pipe()
    m = ee.make_metrics()

    # capture every warning emitted during adapter load
    coll = WarningCollector()
    root = logging.getLogger()
    root.addHandler(coll)
    local = ee.hf_hub_download(repo_id=MODEL_REPO, repo_type='model', filename=LORA_FILE)
    try:
        pipe.load_lora_weights(local)
    finally:
        root.removeHandler(coll)
    bad = [r for r in coll.records
           if 'unexpected keys' in r or 'missing keys' in r
           or 'not in the model' in r or 'not found in' in r]
    print(f'[load] warnings captured: {len(coll.records)}', flush=True)
    for r in coll.records:
        print(f'[load-warn] {r[:400]}', flush=True)
    print(f'[load] dropped-key warnings: {len(bad)}', flush=True)
    assert not bad, f'adapter load dropped keys: {bad}'

    rows = ee.run_pairs(pipe, m, pairs, 'instruction', os.path.join(args.out, 'diffusers48'))
    a = float(__import__('numpy').mean([r['alpha_iou'] for r in rows]))
    l = float(__import__('numpy').mean([r['lpips'] for r in rows]))
    p = float(__import__('numpy').mean([r['psnr'] for r in rows]))
    d = float(__import__('numpy').mean([r['dino_sim'] for r in rows]))
    s = float(__import__('numpy').mean([r['s_edit'] for r in rows]))
    summary = {
        'file': LORA_FILE,
        'dropped_key_warnings': bad,
        'n_warnings_at_load': len(coll.records),
        'subset': {'n': len(rows), 'alpha_iou': round(a, 4), 'lpips': round(l, 4),
                   'psnr': round(p, 2), 'dino_sim': round(d, 4), 's_edit': round(s, 2)},
        'reference_ckpt2000_comfyui_keys': {'n': 48, 'alpha_iou': 0.836,
                                            'lpips': 0.087, 'dino_sim': 0.756},
    }
    print('SUMMARY ' + json.dumps(summary), flush=True)
    with open(os.path.join(args.out, 'summary.json'), 'w') as f:
        json.dump(summary, f, indent=2)
    from huggingface_hub import HfApi
    api = HfApi()
    api.upload_file(path_or_fileobj=os.path.join(args.out, 'summary.json'),
                    path_in_repo=f'{OUT_REPO_PATH}/summary.json',
                    repo_id=DS_REPO, repo_type='dataset',
                    commit_message='diffusers-format adapter: clean load + 48-edit subset')
    api.upload_file(path_or_fileobj=os.path.join(args.out, 'diffusers48', 'results.jsonl'),
                    path_in_repo=f'{OUT_REPO_PATH}/diffusers48_results.jsonl',
                    repo_id=DS_REPO, repo_type='dataset',
                    commit_message='diffusers-format adapter: per-edit results')
    print('DONE', flush=True)


if __name__ == '__main__':
    main()