"""Append source-scoped axis corrections; no destructive update or resegmentation."""
from collections import Counter
from contextlib import closing
import argparse
import hashlib
import json
from pathlib import Path
import sqlite3
import sys

import numpy as np

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.cluster_targets import digest
from pallet.pose_review import PoseApplication
from pallet.pose_review_geometry import canonical
from pallet.pose_refinement import atomic_json,now
from pallet.structure_review import ReviewError


def main():
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--apply',action='store_true')
    parser.add_argument('--output',type=Path,default=PROJECT/'outputs/pallet_pose_review_validation_v13')
    args=parser.parse_args();out=args.output;out.mkdir(parents=True,exist_ok=True)
    path=out/('axes_migration.json' if args.apply else 'axes_migration_plan.json')
    if path.exists():raise ValueError('Do not overwrite migration evidence')
    if args.apply and not (out/'before_deployment.json').exists():raise ValueError('Live backup required before application')
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    app=PoseApplication(formal,PROJECT/'outputs/pallet_pose_human_review_v1');assert app.axes
    assert digest(PROJECT/app.axes.config['audit'])==app.axes.config['audit_sha256']
    before=app.store.all();latest=app.store.latest(app.queue({})['keys']);records=[]
    for key,initial in sorted(before.items()):
        if not app.axes_info(key):continue
        old=app.store.get(key)
        if (old.get('axes_policy') or {}).get('id')==app.axes.id:continue
        value=app.effective_review(old)
        info=value.setdefault('axes_interpretation',dict(policy_id=app.axes.id,source_revision=old['revision'],
            original_record_sha256=hashlib.sha256(canonical(old)).hexdigest(),historical_record_unchanged=True))
        item=dict(target_key=key,before_revision=old['revision'],before_sha256=hashlib.sha256(canonical(old)).hexdigest(),
            frame_id=old['source']['frame_id'],old_geometry_token=old.get('geometry_token'),new_geometry_token=value.get('geometry_token'))
        if args.apply:
            value.update(event_kind='axes_normalization',axes_conversion_operator='system_appending_user_authorized_axes_revision',
                source_last_human_updated_at=old['updated_at'])
            try:
                new=app.store.save(key,old['revision'],value,allow_deleted=True)
                item.update(state='converted',after_revision=new['revision'])
            except ReviewError as exc:
                if exc.status!=409:raise
                item['state']='concurrent_human_update_preserved'
        else:item['state']='planned'
        records.append(item)
    checked=0
    # Independently verify committed old/new evidence; historical payloads are
    # queried read-only, not inferred from in-memory adapter output.
    with closing(sqlite3.connect(app.store.path.resolve().as_uri()+'?mode=ro',uri=True)) as db:
        for item in records:
            if item['state']!='converted':continue
            raw=db.execute('SELECT payload FROM events WHERE target_key=? AND revision=?',(item['target_key'],item['before_revision'])).fetchone()[0]
            assert hashlib.sha256(raw.encode()).hexdigest()==item['before_sha256']
            old=json.loads(raw)
            new=json.loads(db.execute('SELECT payload FROM events WHERE target_key=? AND revision=?',(item['target_key'],item['after_revision'])).fetchone()[0])
            assert new['polygon']==old['polygon'] and new['selected_faces']==old['selected_faces'] and new['exclusions']==old['exclusions']
            assert new['note']==old['note'] and new['reviewer']==old['reviewer']
            assert not new['human_pose_confirmed'] and not new['robot_command_eligible']
            if old['state']=='deleted':assert new['state']=='deleted'
            if old.get('geometry_token'):
                for ext in ('.npz','.bin'):
                    assert digest(app.engine.cache/(old['geometry_token']+ext))==digest(app.engine.cache/(new['geometry_token']+ext))
                a=app.engine.selected(app.engine.load(old['geometry_token'],item['target_key']),old['selected_faces'],old['exclusions'])
                b=app.engine.selected(app.engine.load(new['geometry_token'],item['target_key']),new['selected_faces'],new['exclusions'])
                for field in ('xyz','source_indices','face_ids','uv','selected'):np.testing.assert_array_equal(a[field],b[field])
            if old.get('ruler'):
                r=old['ruler'];basis=np.asarray(r['basis']);center=np.asarray(r['origin'])+r['w']*basis[:,0]+r['d']*basis[:,1]
                np.testing.assert_allclose(new['ruler']['origin'],center,atol=1e-12)
                assert new['pose']['source_position'][1] is None
            source=app.source(item['target_key']);assert digest(source['source_paths']['pcd'])==source['source_anchor_hash']
            checked+=1
    after=app.store.all();remaining=[k for k,v in after.items() if app.axes_info(k) and (v.get('axes_policy') or {}).get('id')!=app.axes.id]
    atomic_json(path,dict(state='passed' if not args.apply or not remaining else 'needs_followup',created_at=now(),apply=args.apply,
        axes_policy=app.axes.info(),before_stats=app.stats(before),after_stats=app.stats(after),records=records,
        counts=dict(Counter(r['state'] for r in records)),remaining_unmigrated=remaining,
        latest_human_before=latest,latest_human_after=app.store.latest(app.queue({})['keys']),
        committed_revisions_independently_verified=checked,unrelated_targets_written=0,
        historical_events_rewritten=0,raw_XYZ_rotated=False,measurement_bytes_selected_ids_and_polygons_preserved=True,
        production_database_test_writes=0))
    print(json.dumps(dict(state='passed',apply=args.apply,targets=len(records),verified=checked,remaining=len(remaining))))


if __name__=='__main__':main()
