"""Verify appended unit revisions and immutable measurements, read-only."""
from __future__ import annotations

from collections import Counter
from contextlib import closing
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,load_dataset
from pallet.pose_review_units import MetrePolicy
from pallet.pose_refinement import atomic_json,now


def main():
    out=PROJECT/'outputs/pallet_pose_review_validation_v12'
    migration=json.loads((out/'unit_migration.json').read_text());assert migration['state']=='passed'
    reviews=PROJECT/'outputs/pallet_pose_human_review_v1';cache=reviews/'geometry'
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset']);_,sources=load_dataset(formal)
    policy=MetrePolicy.load(PROJECT/'configs/pallet_pose_review_units_v1.json',formal);assert policy
    with closing(sqlite3.connect((reviews/'annotations.sqlite3').resolve().as_uri()+'?mode=ro',uri=True)) as db:
        assert db.execute('PRAGMA quick_check').fetchone()[0]=='ok'
        current={k:json.loads(raw) for k,raw in db.execute('SELECT target_key,payload FROM annotations')}
        events={(k,r):(raw,json.loads(raw)) for k,r,raw in db.execute('SELECT target_key,revision,payload FROM events')}
    frames=set();geometry_checks=0;converted=0
    for item in migration['records']:
        if item['state']!='converted':continue
        key=item['target_key'];raw,old=events[key,item['before_revision']];_,new=events[key,item['after_revision']]
        assert hashlib.sha256(raw.encode()).hexdigest()==item['before_sha256']
        assert new['event_kind']=='unit_normalization' and new['sensor']['scale_to_m'] is not None
        assert new['unit_policy']['id']==policy.id and not new['robot_command_eligible']
        ratio=item['length_multiplier'];assert ratio==policy.native_scale(sources[old['source']['frame_id']])
        for field in ('source','polygon','selected_faces','exclusions','note','reviewer'):
            if field=='exclusions' and ratio!=1:continue
            assert new[field]==old[field],(key,field)
        if old.get('ruler'):
            for field in ('origin','w','d','half_width'):
                np.testing.assert_allclose(np.asarray(new['ruler'][field]),np.asarray(old['ruler'][field])*ratio,rtol=1e-12,atol=1e-12)
            for field in ('angle','basis','direction_sign'):
                assert new['ruler'].get(field)==old['ruler'].get(field)
        if old.get('pose'):
            assert new['pose']['position_unit']=='m' and new['pose']['z'] is None
            for field in ('x','y'):
                if old['pose'][field] is not None:np.testing.assert_allclose(new['pose'][field],old['pose'][field]*ratio,atol=1e-10)
            np.testing.assert_allclose(new['pose']['direction_source'],old['pose']['direction_source'],atol=1e-12)
        if old['state']=='deleted':assert new['state']=='deleted' and new['retained_annotation']==old['retained_annotation']
        if old.get('geometry_token'):
            old_meta=json.loads((cache/(old['geometry_token']+'.json')).read_text())
            new_meta=json.loads((cache/(new['geometry_token']+'.json')).read_text())
            assert digest(cache/(old['geometry_token']+'.npz'))==old_meta['full_resolution_artifact_sha256']
            assert digest(cache/(new['geometry_token']+'.npz'))==new_meta['full_resolution_artifact_sha256']
            with np.load(cache/(old['geometry_token']+'.npz')) as a,np.load(cache/(new['geometry_token']+'.npz')) as b:
                for field in ('source_indices','uv','face_ids','polygon','mask'):np.testing.assert_array_equal(a[field],b[field])
                np.testing.assert_allclose(b['xyz'],a['xyz']*ratio,rtol=1e-12,atol=1e-12)
            geometry_checks+=1
        frames.add(old['source']['frame_id']);converted+=1
    for frame in frames:
        source=sources[frame]
        assert digest(source['source_paths']['pcd'])==source['source_anchor_hash']
        assert digest(formal/source['image'])==source['files'][source['image']]
    assert all(v['sensor']['scale_to_m'] is not None for v in current.values())
    assert all(v.get('pose') is None or v['pose']['position_unit']=='m' for v in current.values())
    result=dict(state='passed',created_at=now(),authorized_unit_revisions_verified=converted,
        full_resolution_geometry_revisions_verified=geometry_checks,unique_source_frames_rehashed=len(frames),
        current_saved_targets=len(current),current_unit_scales=dict(Counter(str(v['sensor']['scale_to_m']) for v in current.values())),
        current_unknown_unit_targets=0,old_events_rewritten=0,selected_source_indices_face_ids_polygons_preserved=True,
        no_robot_eligibility_added=True,verification_database_writes=0)
    atomic_json(out/'unit_migration_verification.json',result);print(json.dumps(result),flush=True)


if __name__=='__main__':main()
