"""Scoped source axes, immutable evidence, compatible drafts and workplane exports."""
import copy
import csv
import io
import json
from pathlib import Path

import numpy as np
import pytest

from test_pose_review import dataset
from test_pose_review_units import raw_record
from pallet.cluster_targets import digest
from pallet.data.pcd import read_pcd
from pallet.pose_review import PoseApplication
from pallet.pose_review_axes import AxesPolicy
from pallet.pose_review_geometry import pose_value


def policy(source):
    return AxesPolicy(dict(policy_id='camera_axes_test_v1',source_policy_id=source['sensor_policy']['policy_id'],
        source_size=source['size'],axes=dict(forward_axis=2,forward_sign=1,up_axis=1,up_sign=1),
        evidence='test projection sign audit, not factory calibration'))


@pytest.fixture
def camera(dataset,tmp_path):
    root,source,_=dataset
    path=Path(source['source_paths']['pcd']);header,p=read_pcd(path);p=p.copy();p[:,:3]=p[:,[1,2,0]]
    w,h=source['size'];path.write_bytes((f'FIELDS x y z intensity\nSIZE 4 4 4 4\nTYPE F F F F\nCOUNT 1 1 1 1\nWIDTH {w}\nHEIGHT {h}\nPOINTS {w*h}\nDATA binary\n').encode()+p.astype('<f4').tobytes())
    source['source_anchor_hash']=digest(path);(root/'frames.jsonl').write_text(json.dumps(source)+'\n')
    old=PoseApplication(root,tmp_path/'reviews',protect=False);key=old.keys[0];record=raw_record(old,key)
    axes=policy(source);app=PoseApplication(root,tmp_path/'reviews',protect=False,axes_policy=axes)
    return root,source,old,app,key,record


def test_scope_requires_both_policy_id_and_size(camera):
    _,source,_,app,key,_=camera;p=app.axes
    assert p.applies(source)
    other=copy.deepcopy(source);other['sensor_policy']['policy_id']='other'
    assert not p.applies(other)
    other=copy.deepcopy(source);other['size']=[240,96]
    assert not p.applies(other)
    assert app.sensor(key)['forward_axis']==2 and app.sensor(key)['up_axis']==1
    assert not app.sensor(key)['axes_confirmed']


def test_rebase_preserves_full_xyz_selected_points_exclusions_and_history(camera):
    _,_,old,app,key,record=camera
    # Exclusions stay as source-space prisms, NOT reinterpreted as new W/D.
    record=copy.deepcopy(record);record['exclusions']=[dict(origin=record['ruler']['origin'],basis=record['ruler']['basis'],plane='wh',bounds=[-.04,-10,.04,10])]
    before=copy.deepcopy(record);old_selected=old.engine.selected(old.engine.load(record['geometry_token'],key),record['selected_faces'],record['exclusions'])
    converted=app.effective_review(record);assert record==before
    meta=app.engine.load(converted['geometry_token'],key)
    for ext in ('.npz','.bin'):
        assert digest(old.engine.cache/(record['geometry_token']+ext))==digest(app.engine.cache/(converted['geometry_token']+ext))
    new_selected=app.engine.selected(meta,converted['selected_faces'],converted['exclusions'])
    np.testing.assert_array_equal(old_selected['selected'],new_selected['selected'])
    np.testing.assert_array_equal(old_selected['source_indices'],new_selected['source_indices'])
    np.testing.assert_array_equal(old_selected['xyz'],new_selected['xyz'])
    assert converted['polygon']==record['polygon'] and converted['selected_faces']==record['selected_faces']
    assert converted['exclusions']==record['exclusions']
    assert converted['mask_status']=='confirmed' and converted['human_mask_confirmed']
    assert converted['pose_status']=='pending' and not converted['human_pose_confirmed']
    assert not converted['robot_command_eligible'] and not converted['sensor']['axes_confirmed']
    assert app.store.history(key)==old.store.history(key)


def test_ruler_preserves_source_center_but_reinitializes_bad_width_and_angle(camera):
    _,_,_,app,key,record=camera;value=app.detail(key)['review']
    b=np.asarray(record['ruler']['basis']);r=record['ruler'];center=np.asarray(r['origin'])+r['w']*b[:,0]+r['d']*b[:,1]
    np.testing.assert_allclose(value['ruler']['origin'],center)
    assert value['ruler']['w']==value['ruler']['d']==value['ruler']['angle']==0
    assert value['ruler']['half_width']>.4
    assert value['axes_interpretation']['legacy_ruler']==record['ruler']
    assert value['axes_interpretation']['legacy_view']==record['view']
    assert value['pose']['source_position'][1] is None
    assert value['pose']['x'] is None and value['pose']['y'] is None and value['pose']['z'] is None
    assert value['pose']['workplane_position']==pytest.approx([center[2],-center[0]])
    assert value['pose']['workplane_theta_degrees']==pytest.approx(0,abs=1e-9)
    assert value['state']=='draft'
    assert app.effective_review(value)==value


def test_geometry_compute_reuses_adapter_and_confirmation_keeps_indices(camera):
    _,_,_,app,key,_=camera;value=app.detail(key)['review']
    meta=app.compute(key,dict(polygon=value['polygon'],sensor=value['sensor'],geometry_token=value['geometry_token']))
    assert meta['token']==value['geometry_token']
    confirmed=app.compute(key,dict(polygon=value['polygon'],sensor=dict(value['sensor'],axes_confirmed=True),geometry_token=value['geometry_token']))
    assert confirmed['sensor']['axes_confirmed']
    assert digest(app.engine.cache/(meta['token']+'.npz'))==digest(app.engine.cache/(confirmed['token']+'.npz'))


def test_old_clients_and_old_axes_cannot_save(camera):
    _,_,_,app,key,record=camera;value=app.detail(key)['review']
    payload=dict(value,expected_revision=record['revision'])
    with pytest.raises(Exception,match='坐标轴已修正'):app.save(key,payload)
    payload.update(axes_policy_id=app.axes.id,sensor=record['sensor'])
    with pytest.raises(Exception,match='须先转换'):app.save(key,payload)
    assert app.store.get(key)==record


def test_new_save_uses_explicit_workplane_and_csv_not_false_xy(camera):
    _,_,_,app,key,record=camera;value=app.detail(key)['review']
    saved=app.save(key,dict(value,expected_revision=record['revision'],axes_policy_id=app.axes.id))
    assert saved['axes_policy']['id']==app.axes.id
    row=next(csv.DictReader(io.StringIO(app.csv([saved]).decode('utf-8-sig'))))
    assert row['x']==row['y']==row['theta_degrees']==''
    assert float(row['workplane_forward'])==pytest.approx(saved['pose']['workplane_position'][0])
    assert float(row['workplane_width'])==pytest.approx(saved['pose']['workplane_position'][1])
    assert row['forward_axis']=='2' and row['up_axis']=='1'


def test_automatic_revisions_allow_only_compatible_local_draft(camera):
    _,_,_,app,key,record=camera
    value=app.effective_review(record);value['event_kind']='axes_normalization'
    app.store.save(key,record['revision'],value)
    assert app.store.latest([key])==key
    assert app.draft_revisions(key)==[2,1]
    draft=dict(expected_revision=1,edit=dict(polygon=record['polygon'],sensor=record['sensor'],geometry_token=record['geometry_token'],
        faces=record['selected_faces'],exclusions=record['exclusions'],ruler=record['ruler']),view=record['view'],
        maskConfirmed=True,poseConfirmed=True,note='local edits retained',reviewer='local reviewer')
    original=copy.deepcopy(draft)
    result=app.adapt_draft(key,dict(binding=app.binding,axes_policy_id=app.axes.id,draft=draft))
    assert result['axes_converted'] and result['database_writes']==0
    assert result['draft']['edit']['sensor']['up_axis']==1 and not result['draft']['poseConfirmed']
    assert result['draft']['maskConfirmed'] and result['draft']['note']=='local edits retained'
    assert draft==original and app.store.get(key)['revision']==2
    # A genuinely new human save ends automatic draft compatibility.
    app.store.save(key,2,dict(value,event_kind=None))
    with pytest.raises(Exception,match='冲突'):app.adapt_draft(key,dict(binding=app.binding,axes_policy_id=app.axes.id,draft=draft))


def test_deleted_records_remain_deleted_and_restore_with_correct_axes(camera):
    _,_,old,app,key,record=camera
    tombstone=old.object_presence(key,dict(binding=old.binding,expected_revision=1,confirm_target=key,reason='test deletion',reviewer='test'))
    converted=app.effective_review(tombstone)
    assert converted['state']=='deleted' and converted['pose'] is None
    assert converted['retained_annotation']==tombstone['retained_annotation']
    app.store.save(key,2,dict(converted,event_kind='axes_normalization'),allow_deleted=True)
    restored=app.object_presence(key,dict(binding=app.binding,expected_revision=3,confirm_target=key,reason='test restore',reviewer='test',axes_policy_id=app.axes.id),restore=True)
    assert restored['state']=='draft' and restored['sensor']['up_axis']==1 and not restored['human_pose_confirmed']
    assert restored['ruler']['half_width']>.4


def test_machine_overlays_are_not_reused_with_new_workplane(camera):
    _,_,_,app,key,_=camera
    app.machine_suggestion=lambda key:dict(pose_estimate=dict(source_scale_to_m=1.))
    assert app.detail(key)['machine_reference'] is None


def test_unaffected_source_sensor_and_review_are_byte_equivalent(dataset,tmp_path):
    root,source,_=dataset;app=PoseApplication(root,tmp_path/'other',protect=False,axes_policy=policy(dict(source,sensor_policy=dict(source['sensor_policy'],policy_id='different'))))
    key=app.keys[0];saved=raw_record(app,key)
    assert app.detail(key)['review']==saved and app.axes_info(key) is None
    assert app.detail(key)['sensor']['forward_axis']==0 and app.detail(key)['sensor']['up_axis']==2
