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

import pytest

from pallet.mask_gallery_review import ReviewError
from pallet.mask_model_training_data import sha
from pallet.pallet_description_batch import preview as overwrite_preview,apply as overwrite_apply
from pallet.pallet_description_terms import terms,operation_terms,transform,preview,apply
from test_pallet_description import editor,item,body


@pytest.fixture
def batch(editor):
    ed,p,guard=editor
    p['description']['text']='木质，三支腿，左侧遮挡'
    for char,text in (('b','木质，横梁'),('c','金属，三支腿'),('d','  木质 ，，木质  ')):
        q=deepcopy(p);q['target_key']=char*24;q['description']['text']=text;ed.proposals[q['target_key']]=q
    data=dict(binding=ed.binding,source_key=p['target_key'],source_binding=sha(p),batch_id='1'*32,
        items=[[key,0] for key in ed.proposals],operation='add',terms_text=' 木质，，右侧遮挡，木质 ',reviewer='SYNTHETIC terms',scope=dict(class_filter='',state_filter='all'))
    return ed,p,guard,data


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


@pytest.mark.parametrize('text,items,op,expected',[
    (' 木质 ，，三支腿 ',['木质'],'add',' 木质 ，，三支腿 '),
    (' 木质 ，，三支腿 ',['横梁','木质'],'add','木质，三支腿，横梁'),
    ('左侧遮挡，遮挡，遮挡，木质',['遮挡'],'delete','左侧遮挡，木质'),
    ('木质，木质',['木质'],'delete',''),
    ('木质,横梁',['木质'],'delete','木质,横梁'),
    ('木质,横梁',['木质'],'add','木质,横梁，木质'),
    ('左侧遮挡',['遮挡'],'delete','左侧遮挡'),
    ('Wood，wood',['wood'],'delete','Wood'),
    ('， ，', ['木质'],'add','木质'),
    ('', ['木质'],'delete',''),
])
def test_exact_terms(text,items,op,expected):assert transform(text,items,op)==expected


def test_parse_only_chinese_comma_trim_and_unique():
    assert terms(' 甲 ，，乙,丙，甲 ')==['甲','乙,丙','甲']
    assert operation_terms(' 甲 ，，乙,丙，甲 ')==['甲','乙,丙']


@pytest.mark.parametrize('value',['','， ，',None,3,'x'*2001])
def test_bad_operation_terms(value):
    with pytest.raises(ReviewError):operation_terms(value)


def test_preview_read_only_full_per_target_counts(batch):
    ed,p,_,data=batch;r=preview(ed,data)
    assert (r['count'],r['changed_count'],r['unchanged_count'],r['cleared_count'])==(4,4,0,0)
    assert r['terms']==['木质','右侧遮挡'] and r['items'][2]['text']=='金属，三支腿，木质，右侧遮挡'
    with closing(ed.store.connect()) as db:assert not db.execute("SELECT name FROM sqlite_master WHERE name='structure_batches'").fetchone()
    assert not ed.store.summary()


def test_changes_only_and_unsaved_noop_keeps_revision_zero(batch):
    ed,p,_,data=batch;data['terms_text']='木质';r=apply(ed,confirmed(ed,data))
    assert r['changed_count']==1 and r['unchanged_count']==3 and r['current_review'] is None
    for key,v in r['reviews'].items():
        assert v['revision']==int(key=='c'*24)
        assert (ed.store.get(key) is None)==(key!='c'*24)
    assert r['reviews']['d'*24]['text']=='  木质 ，，木质  '


@pytest.mark.parametrize('action',['correct','draft','defer'])
def test_all_nontarget_fields_and_history_preserved(batch,action):
    ed,p,_,data=batch;b=body(ed,p);b['description']=deepcopy(p['description']);b['action']=action;b['note']='SYNTHETIC note';before=ed.save(p['target_key'],b)
    data['items'][0][1]=1;r=apply(ed,confirmed(ed,data));after=r['current_review']
    changed={'revision','reviewer','updated_at','event_kind','human_review_scope','joint_completion_performed','structure_description_status','structure_batch','description'}
    assert {k:v for k,v in before.items() if k not in changed}=={k:v for k,v in after.items() if k not in changed}
    assert {k:v for k,v in before['description'].items() if k!='text'}=={k:v for k,v in after['description'].items() if k!='text'}
    assert ed.store.history(p['target_key'])[1]==before and after['action']==action
    # A later single save preserves item batch provenance when text is unchanged.
    b.update(expected_revision=2,description=after['description']);single=ed.save(p['target_key'],b)
    assert single['structure_batch']==after['structure_batch']


def test_delete_clears_exact_duplicate_items_but_not_substrings(batch):
    ed,p,_,data=batch;data.update(operation='delete',terms_text='木质，三支腿')
    r=preview(ed,data);assert r['cleared_count']==1 and r['items'][0]['text']=='左侧遮挡'
    saved=apply(ed,dict(data,preview_token=r['preview_token']));assert saved['reviews']['d'*24]['text']==''


def test_noop_receipt_idempotent_even_after_later_single_save(batch):
    ed,p,_,data=batch;data.update(operation='delete',terms_text='从不存在')
    request=confirmed(ed,data);first=apply(ed,request);assert first['changed_count']==0
    ed.save(p['target_key'],body(ed,p));retry=apply(ed,request)
    assert retry==dict(first,replayed=True) and len(ed.store.history(p['target_key']))==1


def test_concurrent_same_request_replayed_once(batch):
    ed,p,_,data=batch;request=confirmed(ed,data)
    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]
    assert all(len(ed.store.history(k))==1 for k in ed.proposals)


@pytest.mark.parametrize('field,value',[('operation','delete'),('terms_text','新项'),('scope',dict(class_filter='1',state_filter='all')),('items',None),('reviewer','Changed')])
def test_signed_request_tampering_rejected(batch,field,value):
    ed,p,_,data=batch;request=confirmed(ed,data)
    if value is None:value=list(reversed(data['items']))
    request[field]=value
    with pytest.raises(ReviewError) as e:apply(ed,request)
    assert e.value.status==409 and not ed.store.summary()


@pytest.mark.parametrize('field',['text','attributes','description','action'])
def test_extra_fields_rejected(batch,field):
    ed,p,_,data=batch
    with pytest.raises(ReviewError):preview(ed,dict(data,**{field:'oops'}))


def test_conflict_on_unchanged_target_rolls_back_whole_batch(batch):
    ed,p,_,data=batch;data['terms_text']='木质';request=confirmed(ed,data);ed.save(p['target_key'],body(ed,p))
    with pytest.raises(ReviewError) as e:apply(ed,request)
    assert e.value.status==409 and not ed.store.get('c'*24)


def test_overlength_any_result_blocks_whole_batch(batch):
    ed,p,_,data=batch;ed.proposals['c'*24]['description']['text']='x'*2000
    with pytest.raises(ReviewError) as e:preview(ed,data)
    assert e.value.status==400 and not ed.store.summary()


def test_source_change_during_transaction_rolls_back(batch):
    ed,p,guard,data=batch;request=confirmed(ed,data);answers=iter([True,False]);guard.current=lambda:next(answers)
    with pytest.raises(ReviewError) as e:apply(ed,request)
    assert e.value.status==409 and not ed.store.summary()


def test_sql_failure_rolls_back_all_rows_events_and_receipt(batch):
    ed,p,_,data=batch;request=confirmed(ed,data)
    with closing(ed.store.connect()) as db:db.execute("CREATE TRIGGER fail_terms BEFORE INSERT ON events WHEN NEW.target_key='"+'c'*24+"' BEGIN SELECT RAISE(ABORT,'SYNTHETIC failure'); END")
    with pytest.raises(sqlite3.IntegrityError):apply(ed,request)
    assert not ed.store.summary()
    with closing(ed.store.connect()) as db:assert not db.execute('SELECT * FROM events').fetchall()


@pytest.mark.parametrize('first',['terms','overwrite'])
def test_batch_id_collision_across_old_and_new_operations(batch,first):
    ed,p,_,data=batch;overwrite={k:v for k,v in data.items() if k not in ('operation','terms_text')};overwrite['text']='覆写'
    a=confirmed(ed,data);b=dict(overwrite,preview_token=overwrite_preview(ed,overwrite)['preview_token'])
    if first=='terms':apply(ed,a);call=lambda:overwrite_apply(ed,b)
    else:overwrite_apply(ed,b);call=lambda:apply(ed,a)
    with pytest.raises(ReviewError) as e:call()
    assert e.value.status==409 and all(len(ed.store.history(k))==1 for k in ed.proposals)


def test_batch_id_collision_add_vs_delete(batch):
    ed,p,_,data=batch;a=confirmed(ed,data);other=confirmed(ed,dict(data,operation='delete'));apply(ed,a)
    with pytest.raises(ReviewError) as e:apply(ed,other)
    assert e.value.status==409


def test_expired_preview_no_write_but_prior_receipt_can_replay(batch,monkeypatch):
    import pallet.pallet_description_terms as module
    ed,p,_,data=batch;request=confirmed(ed,data);now=module.time.time();monkeypatch.setattr(module.time,'time',lambda:now+1000)
    with pytest.raises(ReviewError) as e:apply(ed,request)
    assert e.value.status==409 and not ed.store.summary()
    monkeypatch.setattr(module.time,'time',lambda:now);first=apply(ed,request)
    monkeypatch.setattr(module.time,'time',lambda:now+1000);assert apply(ed,request)==dict(first,replayed=True)
