from contextlib import closing
from copy import deepcopy
from concurrent.futures import ThreadPoolExecutor
import sqlite3

import pytest

from pallet.mask_gallery_review import ReviewError
from pallet.pallet_description_replace import transform,payload,preview,apply,engine
from pallet.pallet_description_terms import preview as terms_preview,apply as terms_apply
from pallet.pallet_description_batch import preview as overwrite_preview,apply as overwrite_apply
from test_pallet_description_terms import batch
from test_pallet_description import editor,item,body


@pytest.fixture
def replacement(batch):
    ed,p,g,data=batch;data.update(operation='replace',terms_text='木质',replacement_text='金属')
    return ed,p,g,data


def confirmed(ed,data):return dict(data,preview_token=preview(ed,data)['preview_token'])


@pytest.mark.parametrize('text,old,new,result',[
    ('木质，三支腿',['木质'],['金属'],'金属，三支腿'),
    (' 木质 ，，三支腿 ',['木质'],['木质'],' 木质 ，，三支腿 '),
    ('左侧遮挡，木质',['遮挡'],['出视野'],'左侧遮挡，木质'),
    ('木质,横梁',['木质'],['金属'],'木质,横梁'),
    ('木质，三支腿，金属',['木质'],['金属'],'三支腿，金属'),
    ('金属，木质，三支腿',['木质'],['金属'],'金属，三支腿'),
    ('木质，木质，三支腿',['木质'],['金属'],'金属，三支腿'),
    ('左遮挡，A，右遮挡，A',['左遮挡','右遮挡'],['遮挡','侧视'],'遮挡，侧视，A，A'),
    ('木质，木质',['木质'],[],''),
    ('  ， ',['木质'],['金属'],'  ， '),
    ('Wood，wood',['Wood'],['Metal'],'Metal，wood'),
    ('a，b，c',['a','b'],['b','d'],'b，d，c'),
])
def test_exact_replace_semantics(text,old,new,result):assert transform(text,old,new)==result


def test_preview_counts_no_write_and_atomic_per_image(replacement):
    ed,p,g,data=replacement;r=preview(ed,data)
    assert r['changed_count']==3 and r['unchanged_count']==1 and r['replacement_terms']==['金属']
    assert not ed.store.summary()
    result=apply(ed,dict(data,preview_token=r['preview_token']))
    assert result['reviews']['c'*24]['revision']==0 and ed.store.get('c'*24) is None
    assert result['reviews']['d'*24]['text']=='金属'
    assert result['current_review']['structure_batch']['replacement_terms']==['金属']
    assert result['current_review']['event_kind']=='human_batch_structure_terms_replace'


@pytest.mark.parametrize('action',['correct','draft','defer'])
def test_only_text_and_provenance_change(replacement,action):
    ed,p,_,data=replacement;b=body(ed,p);b.update(action=action,note='保留备注',description=deepcopy(p['description']))
    old=ed.save(p['target_key'],b);data['items'][0][1]=1;new=apply(ed,confirmed(ed,data))['current_review']
    mutable={'description','revision','reviewer','updated_at','event_kind','human_review_scope','joint_completion_performed','structure_batch','structure_description_status'}
    assert {k:v for k,v in old.items() if k not in mutable}=={k:v for k,v in new.items() if k not in mutable}
    assert {k:v for k,v in old['description'].items() if k!='text'}=={k:v for k,v in new['description'].items() if k!='text'}
    assert ed.store.history(p['target_key'])[1]==old
    b.update(expected_revision=2,description=new['description']);single=ed.save(p['target_key'],b)
    assert single['structure_batch']==new['structure_batch']


def test_empty_new_clears_and_noop_idempotent(replacement):
    ed,p,_,data=replacement;data.update(terms_text='木质，三支腿，左侧遮挡，横梁，金属',replacement_text=' ， ')
    r=preview(ed,data);assert r['cleared_count']==4
    request=dict(data,preview_token=r['preview_token']);first=apply(ed,request)
    assert all(v['text']=='' for v in first['reviews'].values()) and apply(ed,request)==dict(first,replayed=True)


def test_noop_null_current_receipt_survives_later_save(replacement):
    ed,p,_,data=replacement;data['terms_text']='不存在';request=confirmed(ed,data);first=apply(ed,request)
    assert first['current_review'] is None and first['changed_count']==0 and not ed.store.summary()
    ed.save(p['target_key'],body(ed,p));assert apply(ed,request)==dict(first,replayed=True)


@pytest.mark.parametrize('change',[{'terms_text':' ， '},{'replacement_text':None},{'replacement_text':'a'*2001},{'operation':'add'},{'text':'extra'},{'attributes':{}},{'terms_text':3}])
def test_invalid_or_extra_input(replacement,change):
    ed,p,g,data=replacement
    with pytest.raises(ReviewError):preview(ed,dict(data,**change))
    assert not ed.store.summary()


@pytest.mark.parametrize('change',[{'replacement_text':'塑料'},{'terms_text':'横梁'},{'items':[]},{'reviewer':'Other'}])
def test_signed_preview_binds_both_inputs(replacement,change):
    ed,p,g,data=replacement;request=confirmed(ed,data)
    with pytest.raises(ReviewError):apply(ed,dict(request,**change))
    assert not ed.store.summary()


def test_conflict_on_noop_target_aborts_all(replacement):
    ed,p,g,data=replacement;request=confirmed(ed,data);q=ed.proposals['c'*24];ed.save(q['target_key'],body(ed,q))
    with pytest.raises(ReviewError) as err:apply(ed,request)
    assert err.value.status==409 and ed.store.get(p['target_key']) is None


def test_overlength_any_target_aborts_preview(replacement):
    ed,p,g,data=replacement;ed.proposals['b'*24]['description']['text']='木质，'+'a'*1997
    data['replacement_text']='长'*10
    with pytest.raises(ReviewError):preview(ed,data)
    assert not ed.store.summary()


def test_source_change_and_sql_failure_roll_back(replacement):
    ed,p,g,data=replacement;request=confirmed(ed,data);answers=iter([True,False]);g.current=lambda:next(answers)
    with pytest.raises(ReviewError):apply(ed,request)
    assert not ed.store.summary();g.current=lambda:True
    with closing(ed.store.connect()) as db:db.execute("CREATE TRIGGER fail_replace BEFORE INSERT ON events WHEN NEW.target_key='"+'d'*24+"' BEGIN SELECT RAISE(ABORT,'failure'); END")
    with pytest.raises(sqlite3.IntegrityError):apply(ed,request)
    assert not ed.store.summary()


def test_expiry_and_concurrent_replay(replacement,monkeypatch):
    ed,p,g,data=replacement;request=confirmed(ed,data);now=engine.time.time();monkeypatch.setattr(engine.time,'time',lambda:now+1000)
    with pytest.raises(ReviewError):apply(ed,request)
    monkeypatch.setattr(engine.time,'time',lambda:now)
    with ThreadPoolExecutor(max_workers=2) as pool:results=list(pool.map(lambda _:apply(ed,request),range(2)))
    assert sorted(r['replayed'] for r in results)==[False,True]
    monkeypatch.setattr(engine.time,'time',lambda:now+1000);assert apply(ed,request)['replayed']
    assert len(ed.store.history(p['target_key']))==1


@pytest.mark.parametrize('kind',['add','delete','overwrite'])
def test_cross_operation_batch_id_collision(replacement,kind):
    ed,p,g,data=replacement;request=confirmed(ed,data)
    other={k:v for k,v in data.items() if k!='replacement_text'}
    if kind=='overwrite':
        other.pop('operation');other['text']=other.pop('terms_text');pv,ap=overwrite_preview,overwrite_apply
    else:other['operation']=kind;pv,ap=terms_preview,terms_apply
    old=dict(other,preview_token=pv(ed,other)['preview_token']);apply(ed,request)
    with pytest.raises(ReviewError) as err:ap(ed,old)
    assert err.value.status==409


def test_frozen_terms_module_not_monkeypatched(replacement):
    from pallet import pallet_description_terms as base
    assert base.payload is not payload and base.plan is not engine.plan
    ed,p,g,data=replacement;legacy={k:v for k,v in data.items() if k!='replacement_text'};legacy['operation']='add'
    assert base.preview(ed,legacy)['operation']=='add'
