"""Atomic, idempotent text-only batch confirmation; never completes joint geometry."""
import base64
from contextlib import closing
from copy import deepcopy
from datetime import datetime,timezone
import hashlib
import hmac
import json
import re
import time
from urllib.parse import urlsplit

from .mask_model_training_data import sha
from .mask_gallery_review import ReviewError
from .pose_review_geometry import canonical
from .pallet_description_simple import ROOT,initial_description
from .pallet_description_single import reviewer_name

RELEASE=ROOT/'batch_structure_v1'
FIELDS=('revision','reviewer','updated_at','action','class_id','description_status','structure_description_status')


def batch_body(handler):
    # Only this endpoint accepts >64KiB, needed for all5615 explicit target revisions.
    h=handler.headers;origin=h.get('Origin')
    if (h.get('X-Review-Request')!='1' or h.get('Sec-Fetch-Site')=='cross-site' or
        origin and (urlsplit(origin).netloc!=h.get('Host') or urlsplit(origin).scheme not in ('http','https'))):
        raise ReviewError(403,'不允许跨站批量提交')
    if h.get('Content-Type','').split(';')[0]!='application/json':raise ReviewError(415,'需要JSON请求')
    try:length=int(h.get('Content-Length','0'))
    except ValueError:raise ReviewError(400,'无效请求长度')
    if not 0<length<=1024*1024:raise ReviewError(413,'批量请求为空或超过1MiB')
    try:data=json.loads(handler.rfile.read(length))
    except (ValueError,UnicodeError):raise ReviewError(400,'无效JSON')
    if not isinstance(data,dict):raise ReviewError(400,'请求须为JSON对象')
    return data


def payload(ed,data):
    keys={'binding','source_key','source_binding','batch_id','items','text','scope'}
    if not isinstance(data,dict) or set(data)-{'preview_token','reviewer'}!=keys:raise ReviewError(400,'批量字段不完整或包含非文字修改')
    if data['binding']!=ed.binding:raise ReviewError(409,'任务版本变化；本机草稿保留')
    p=ed.proposal(data['source_key'])
    if data['source_binding']!=sha(p):raise ReviewError(409,'当前目标来源版本变化')
    if not isinstance(data['batch_id'],str) or not re.fullmatch('[0-9a-f]{32}',data['batch_id']):raise ReviewError(400,'无效批次ID')
    if not isinstance(data['text'],str) or len(data['text'])>2000:raise ReviewError(400,'结构描述须为不超过2000字的文本')
    reviewer=reviewer_name(data.get('reviewer'))
    if not isinstance(data['scope'],dict) or set(data['scope'])!={'class_filter','state_filter'} or any(not isinstance(v,str) or len(v)>100 for v in data['scope'].values()):raise ReviewError(400,'无效筛选范围')
    items=data['items']
    if not isinstance(items,list) or not 1<=len(items)<=len(ed.proposals):raise ReviewError(400,'筛选序列为空或过长')
    seen=set()
    for item in items:
        if not isinstance(item,list) or len(item)!=2 or not isinstance(item[0],str) or type(item[1])is not int or item[1]<0 or item[0] in seen:raise ReviewError(400,'筛选序列含重复目标或无效修订版本')
        ed.proposal(item[0]);seen.add(item[0])
    if data['source_key'] not in seen:raise ReviewError(400,'当前目标不在本筛选序列中')
    return {**{k:data[k] for k in keys},'text':data['text'].strip(),'reviewer':reviewer}


def current_values(ed,db,request):
    stored={k:(rev,json.loads(raw)) for k,rev,raw in db.execute('SELECT target_key,revision,payload FROM reviews')}
    result={};conflicts=[]
    for key,expected in request['items']:
        revision,value=stored.get(key,(0,None))
        if revision!=expected:conflicts.append(key)
        if value and (value['binding']!=ed.binding or value['source_binding']!=sha(ed.proposal(key))):conflicts.append(key)
        result[key]=value
    if conflicts:raise ReviewError(409,f'筛选序列有{len(set(conflicts))}项版本冲突（如{conflicts[0]}）；整批未保存，本机草稿保留，请刷新服务器版本后重新预览')
    return result


def signature(ed,value):return hmac.new(ed.access_key.encode(),canonical(value),hashlib.sha256).hexdigest()


def preview(ed,data):
    request=payload(ed,data)
    if not ed.source_guard.current():raise ReviewError(409,'来源已变化，批量预览被阻止')
    with closing(ed.store.connect()) as db:
        db.execute('BEGIN');values=current_values(ed,db,request)
    different=0
    for key,value in values.items():
        d=value['description'] if value else initial_description(ed.proposal(key))
        different+=int(d['text']!=request['text'])
    if not ed.source_guard.current():raise ReviewError(409,'预览期间来源发生变化')
    token=dict(request_sha256=sha(request),expires=int(time.time())+600)
    raw=base64.urlsafe_b64encode(canonical(token)).decode().rstrip('=')
    return dict(batch_id=request['batch_id'],count=len(values),different_text_count=different,text=request['text'],
        preview_token=raw+'.'+signature(ed,token),text_only=True,geometry_completion=False)


def apply(ed,data):
    request=payload(ed,data);encoded=data.get('preview_token','')
    try:
        raw,mac=encoded.split('.');token=json.loads(base64.urlsafe_b64decode(raw+'='*(-len(raw)%4)))
        if set(token)!={'request_sha256','expires'} or type(token['expires'])is not int or not hmac.compare_digest(mac,signature(ed,token)) or token['request_sha256']!=sha(request):raise ValueError()
    except (ValueError,TypeError,AttributeError,UnicodeError):raise ReviewError(409,'批量预览凭据无效，请重新预览；整批未保存')
    if not ed.source_guard.current():raise ReviewError(409,'来源已变化，整批未保存')
    with closing(ed.store.connect()) as db:
        db.execute('BEGIN IMMEDIATE')
        try:
            db.execute('CREATE TABLE IF NOT EXISTS structure_batches(batch_id TEXT PRIMARY KEY,request_sha256 TEXT NOT NULL,payload TEXT NOT NULL)')
            old=db.execute('SELECT request_sha256,payload FROM structure_batches WHERE batch_id=?',(request['batch_id'],)).fetchone()
            if old:
                if old[0]!=sha(request):raise ReviewError(409,'批次ID已用于其他内容；整批未保存')
                result=json.loads(old[1]);db.rollback();return dict(result,replayed=True)
            if token['expires']<int(time.time()):raise ReviewError(409,'批量预览已过期，请重新预览；整批未保存')
            values=current_values(ed,db,request);result={};current=None;now=datetime.now(timezone.utc).isoformat(timespec='milliseconds')
            for key,expected in request['items']:
                p=ed.proposal(key);before=values[key]
                value=deepcopy(before) if before else ed.review_value(p,p['class_id'],deepcopy(p['polygon']),initial_description(p),'draft',request['reviewer'],'',None)
                value['description']['text']=request['text']
                value.update(revision=expected+1,reviewer=request['reviewer'],updated_at=now,
                    event_kind='human_batch_structure_text_confirmation',human_review_scope=['structure_text'],joint_completion_performed=False,
                    structure_description_status='batch_confirmed',structure_batch=dict(batch_id=request['batch_id'],source_key=request['source_key'],
                        size=len(request['items']),scope=request['scope'],previous_revision=expected,previous_reviewer=before['reviewer'] if before else None))
                raw=canonical(value).decode()
                db.execute('INSERT INTO reviews VALUES (?,?,?) ON CONFLICT(target_key) DO UPDATE SET revision=excluded.revision,payload=excluded.payload',(key,expected+1,raw))
                db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)',(key,expected+1,raw))
                result[key]={k:value[k] for k in FIELDS}
                if key==request['source_key']:current=value
            response=dict(batch_id=request['batch_id'],count=len(result),text=request['text'],reviews=result,current_review=current,replayed=False,text_only=True,geometry_completion=False)
            db.execute('INSERT INTO structure_batches VALUES (?,?,?)',(request['batch_id'],sha(request),canonical(response).decode()))
            if not ed.source_guard.current():raise ReviewError(409,'提交前来源发生变化，整批已回滚；本机草稿保留')
            db.commit();return response
        except Exception:db.rollback();raise
