"""Single-object reversible deletion must never remove sibling targets or sources."""
import io
import json
from urllib.error import HTTPError
from urllib.request import Request,urlopen
from zipfile import ZipFile

import pytest

from test_pose_review import dataset,navigation_app,http_app
from pallet.cluster_targets import digest
from pallet.pose_review import PoseApplication


def payload(app,key,revision=0):
    detail=app.detail(key)
    return dict(binding=app.binding,expected_revision=revision,polygon=detail['initial_polygon'],
                sensor=detail['sensor'],reviewer='delete test')


def operation(app,key,revision=0,**extra):
    return dict(binding=app.binding,expected_revision=revision,confirm_target=key,
                reviewer='delete test',reason='不符合托盘面标注要求',**extra)


def confirmed(app,key):
    data=payload(app,key);data['sensor']['axes_confirmed']=True
    geometry=app.compute(key,data);c=geometry['candidates'][0]
    data.update(geometry_token=geometry['token'],selected_faces=[c['id']],exclusions=[],
        ruler=dict(origin=c['center'],basis=c['basis'],w=0,d=0,angle=0,half_width=c['half_width']),
        mask_status='confirmed',pose_status='confirmed')
    return app.save(key,data)


def test_delete_one_object_keeps_same_image_sibling_and_all_source_files(navigation_app):
    app=navigation_app;key,sibling,other=app.keys
    before={str(p):digest(p) for p in app.dataset.rglob('*') if p.is_file()}
    saved=app.save(sibling,payload(app,sibling));sibling_history=app.store.history(sibling)
    app.object_presence(key,operation(app,key))
    assert app.store.get(key)['state']=='deleted'
    assert app.store.get(sibling)==saved and app.store.history(sibling)==sibling_history
    assert app.store.get(other) is None
    assert app.rows[key]['frame_id']==app.rows[sibling]['frame_id']
    assert len(app.keys)==3 and key in app.rows and sibling in app.rows
    assert app.queue({})['keys']==[sibling,other]
    assert app.queue({'state':['all']})['keys']==[sibling,other]
    assert app.queue({'state':['pending']})['keys']==[sibling,other]
    assert app.queue({'state':['deleted']})['keys']==[key]
    assert app.queue({'state':['deleted'],'split':['val']})['keys']==[]
    assert before=={str(p):digest(p) for p in app.dataset.rglob('*') if p.is_file()}
    assert app.stats()==dict(total=3,saved=2,mask_confirmed=0,pose_confirmed=0,complete=0,
                             draft=1,deferred=0,deleted=1,negative_frames_unchanged=0)
    objects=app.detail(sibling)['frame_objects']
    assert {o['target_key'] for o in objects}=={key,sibling}
    assert {o['target_key']:o['deleted'] for o in objects}=={key:True,sibling:False}


def test_delete_confirmed_retains_audit_and_restore_is_unconfirmed_draft(navigation_app):
    app=navigation_app;key=app.keys[0];original=confirmed(app,key)
    assert app.stats()['complete']==1
    deleted=app.object_presence(key,operation(app,key,1))
    assert deleted['state']=='deleted' and deleted['pose'] is None and deleted['ruler'] is None
    assert not deleted['selected_faces'] and deleted['geometry_token'] is None and deleted['artifact'] is None
    assert deleted['retained_annotation']['pose']==original['pose']
    assert deleted['retained_annotation']['artifact']==original['artifact']
    assert app.stats()['complete']==app.stats()['mask_confirmed']==app.stats()['pose_confirmed']==0
    restored=app.object_presence(key,operation(app,key,2),restore=True)
    assert restored['state']=='draft' and restored['object_status']=='active'
    assert restored['pose']==original['pose'] and restored['ruler']==original['ruler']
    assert restored['geometry_token']==original['geometry_token'] and restored['artifact']==original['artifact']
    assert restored['mask_status']==restored['pose_status']=='pending'
    assert not restored['human_mask_confirmed'] and not restored['human_pose_confirmed']
    assert not restored['metric_pose_confirmed'] and not restored['automatic_training_eligible']
    assert not restored['robot_command_eligible']
    assert app.stats()['saved']==1 and app.stats()['complete']==0 and app.stats()['deleted']==0
    history=app.store.history(key)
    assert [r['state'] for r in history]==['draft','deleted','complete'] and history[-1]==original
    app.save(key,payload(app,key,3))


def test_deleted_targets_do_not_export_as_labelme_masks_or_pose(navigation_app):
    app=navigation_app;key,sibling,_=app.keys
    original=confirmed(app,key);saved=confirmed(app,sibling)
    artifact=app.directory/'artifacts'/(original['artifact']+'.npz');before=digest(artifact)
    app.object_presence(key,operation(app,key,1))
    with ZipFile(io.BytesIO(app.export_zip())) as z:
        for folder in ('labelme','masks','rle','point_indices'):
            assert not any(n.startswith(folder+'/'+key) for n in z.namelist())
            assert any(n.startswith(folder+'/'+sibling) for n in z.namelist())
        effective=[json.loads(s) for s in z.read('effective_annotations.jsonl').splitlines()]
        assert [r['target_key'] for r in effective]==[sibling]
        assert effective[0]==saved
        deleted=[json.loads(s) for s in z.read('deleted_targets.jsonl').splitlines()]
        assert [r['target_key'] for r in deleted]==[key] and deleted[0]['state']=='deleted'
        assert deleted[0]['pose'] is None
        assert json.loads(z.read('manifest.json'))['deletion_scope']=='single_target_not_frame'
        assert json.loads(z.read('manifest.json'))['original_target_denominator']==3
        text=z.read('poses.csv').decode('utf-8-sig')
        assert 'deletion_reason' in text and '不符合托盘面标注要求' in text
    assert digest(artifact)==before


def test_autosave_cannot_resurrect_deleted_object_even_at_current_revision(navigation_app):
    app=navigation_app;key=app.keys[0]
    stale=payload(app,key);deleted=app.object_presence(key,operation(app,key))
    for revision in (0,1):
        stale['expected_revision']=revision
        with pytest.raises(Exception,match='其他窗口|此对象已删除'):app.save(key,stale)
    with pytest.raises(Exception,match='此对象已删除'):
        app.store.save(key,1,dict(deleted,state='draft'))
    assert app.store.get(key)==deleted and len(app.store.history(key))==1


@pytest.mark.parametrize('changes',[dict(binding='wrong'),dict(expected_revision=-1),dict(expected_revision=True),
    dict(confirm_target='wrong-key'),dict(reviewer=''),dict(reason=''),dict(reason='x'*501),dict(reason=['invalid'])])
def test_invalid_deletion_never_writes(navigation_app,changes):
    app=navigation_app;key=app.keys[0];data=operation(app,key);data.update(changes)
    with pytest.raises(Exception):app.object_presence(key,data)
    assert not app.store.all() and not app.store.history(key)


def test_stale_revisions_duplicate_delete_restore_and_repeated_cycles(navigation_app):
    app=navigation_app;key=app.keys[0]
    with pytest.raises(Exception,match='尚未删除'):app.object_presence(key,operation(app,key),restore=True)
    app.object_presence(key,operation(app,key))
    with pytest.raises(Exception,match='其他窗口'):app.object_presence(key,operation(app,key))
    with pytest.raises(Exception,match='已删除'):app.object_presence(key,operation(app,key,1))
    with pytest.raises(Exception,match='其他窗口'):app.object_presence(key,operation(app,key),restore=True)
    revision=1
    for _ in range(8):
        app.object_presence(key,operation(app,key,revision),restore=True);revision+=1
        value=app.object_presence(key,operation(app,key,revision));revision+=1
        assert 'retained_annotation' not in value['retained_annotation']
        assert len(json.dumps(value))<15000
    assert len(app.store.history(key))==17


def test_latest_and_locate_respect_deleted_filter(navigation_app):
    app=navigation_app;key,sibling,_=app.keys
    app.save(sibling,payload(app,sibling));app.object_presence(key,operation(app,key))
    assert app.locate({'mode':['latest']})['matches'][0]['target_key']==sibling
    assert app.locate({'mode':['latest'],'state':['deleted']})['matches'][0]['target_key']==key
    assert app.locate({'mode':['position'],'value':['1']})['matches'][0]['target_key']==sibling
    with pytest.raises(Exception,match='未找到'):app.locate({'mode':['image'],'value':[key]})
    assert app.locate({'mode':['image'],'value':[key],'state':['deleted']})['matches'][0]['target_key']==key


def test_delete_restore_http_auth_csrf_scope_and_export(navigation_app):
    app=navigation_app;key=app.keys[0]
    with http_app(app) as base:
        path='/api/delete-object/'+key;raw=json.dumps(operation(app,key)).encode()
        headers={'Content-Type':'application/json','X-Review-Request':'1'}
        with pytest.raises(HTTPError) as exc:urlopen(Request(base+path,data=raw,headers=headers))
        assert exc.value.code==401
        response=urlopen(Request(base+'/api/login',data=json.dumps({'key':app.access_key}).encode(),headers=headers))
        headers['Cookie']=response.headers['Set-Cookie'].split(';')[0]
        for bad in ({k:v for k,v in headers.items() if k!='X-Review-Request'},dict(headers,Origin='https://foreign.example')):
            with pytest.raises(HTTPError) as exc:urlopen(Request(base+path,data=raw,headers=bad))
            assert exc.value.code==403
        assert not app.store.all()
        value=json.load(urlopen(Request(base+path,data=raw,headers=headers)))
        assert value['review']['state']=='deleted' and value['stats']['deleted']==1
        raw=json.dumps(operation(app,key,1)).encode()
        value=json.load(urlopen(Request(base+'/api/restore-object/'+key,data=raw,headers=headers)))
        assert value['review']['state']=='draft' and value['stats']['deleted']==0


def test_tombstone_cannot_be_a_valid_refinement_label(navigation_app):
    from pallet.pose_refinement import validate_review
    app=navigation_app;key=app.keys[0];confirmed(app,key)
    value=app.object_presence(key,operation(app,key,1))
    with pytest.raises(ValueError,match='missing_ruler_geometry_or_pose'):
        validate_review(value,app.row(key),app.directory)
