"""Exact Chinese-comma description edits, atomic and no-op aware.

Frozen overwrite/attribute APIs remain unchanged. Existing text is preserved
byte-for-byte if no requested item is added/removed; changed text is serialized
with trimmed, nonempty items, preserving existing order and duplicates.
"""
import base64
from contextlib import closing
from copy import deepcopy
from datetime import datetime,timezone
import hmac
import json
import time

from .mask_gallery_review import ReviewError
from .mask_model_training_data import sha
from .pallet_description_batch import payload as base_payload,current_values,signature,FIELDS,batch_body
from .pallet_description_simple import ROOT,initial_description
from .pose_review_geometry import canonical

RELEASE=ROOT/'round5_terms_v1'
OPERATION_VERSION='exact_chinese_comma_terms_v1'


def terms(text):
    return [part.strip() for part in text.split('，') if part.strip()]


def operation_terms(text):
    if not isinstance(text,str) or len(text)>2000:raise ReviewError(400,'操作描述须为不超过2000字的文本')
    result=list(dict.fromkeys(terms(text)))
    if not result:raise ReviewError(400,'请填写至少一个非空描述项，以中文逗号“，”分隔')
    return result


def transform(text,items,operation):
    if operation not in ('add','delete'):raise ReviewError(400,'无效描述项操作')
    original=terms(text);wanted=set(items)
    if operation=='add':
        extra=[item for item in items if item not in set(original)]
        result='，'.join(original+extra) if extra else text
    else:
        result='，'.join(item for item in original if item not in wanted) if any(item in wanted for item in original) else text
    if len(result)>2000:raise ReviewError(400,'增加后的结构描述超过2000字；整批未保存')
    return result


def payload(ed,data):
    if not isinstance(data,dict) or data.get('operation') not in ('add','delete') or 'terms_text' not in data:raise ReviewError(400,'缺少有效增加／删除操作及描述项')
    keys={'binding','source_key','source_binding','batch_id','items','scope','operation','terms_text'}
    if set(data)-{'preview_token','reviewer'}!=keys:raise ReviewError(400,'批量字段不完整或包含范围之外的修改')
    items=operation_terms(data['terms_text'])
    # Reuse the frozen strict target/scope/reviewer validation, not its mutation.
    request=base_payload(ed,{**{k:v for k,v in data.items() if k not in ('operation','terms_text')},'text':data['terms_text']})
    request.pop('text')
    return dict(request,operation=data['operation'],terms=items,operation_version=OPERATION_VERSION)


def plan(ed,request,values):
    result=[]
    for key,expected in request['items']:
        value=values[key];before=(value['description'] if value else initial_description(ed.proposal(key)))['text']
        after=transform(before,request['terms'],request['operation'])
        result.append(dict(target_key=key,previous_revision=expected,text_before=before,text=after,changed=after!=before,cleared=after!=before and after==''))
    return result


def counts(rows):
    changed=sum(row['changed'] for row in rows)
    return dict(count=len(rows),changed_count=changed,unchanged_count=len(rows)-changed,cleared_count=sum(row['cleared'] for row in rows))


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');rows=plan(ed,request,current_values(ed,db,request))
    if not ed.source_guard.current():raise ReviewError(409,'预览期间来源发生变化')
    token=dict(request_sha256=sha(request),plan_sha256=sha(rows),expires=int(time.time())+600)
    encoded=base64.urlsafe_b64encode(canonical(token)).decode().rstrip('=')
    return dict(batch_id=request['batch_id'],operation=request['operation'],terms=request['terms'],scope=request['scope'],
        **counts(rows),items=rows,preview_token=encoded+'.'+signature(ed,token),text_only=True,geometry_completion=False)


def apply(ed,data):
    request=payload(ed,data)
    try:
        encoded,mac=data.get('preview_token','').split('.')
        token=json.loads(base64.urlsafe_b64decode(encoded+'='*(-len(encoded)%4)))
        if (set(token)!={'request_sha256','plan_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);rows=plan(ed,request,values)
            if sha(rows)!=token['plan_sha256']:raise ReviewError(409,'服务器描述与预览不一致；整批未保存')
            result={};now=datetime.now(timezone.utc).isoformat(timespec='milliseconds')
            for row in rows:
                key=row['target_key'];expected=row['previous_revision'];before=values[key];value=before
                if row['changed']:
                    p=ed.proposal(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']=row['text']
                    value.update(revision=expected+1,reviewer=request['reviewer'],updated_at=now,
                        event_kind='human_batch_structure_terms_'+request['operation'],human_review_scope=['structure_text'],joint_completion_performed=False,
                        structure_description_status='batch_confirmed',structure_batch=dict(batch_id=request['batch_id'],operation=request['operation'],terms=request['terms'],
                            source_key=request['source_key'],size=len(rows),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))
                summary={k:value.get(k) for k in (*FIELDS,'structure_attributes_status')} if value else None
                result[key]=dict(revision=expected+int(row['changed']),changed=row['changed'],text=row['text'],summary=summary)
                if key==request['source_key']:current=value
            response=dict(batch_id=request['batch_id'],operation=request['operation'],terms=request['terms'],**counts(rows),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


class TermsHandlerMixin:
    def review_route(self,path):
        if path in ('/api/review/structure-terms-batch/preview','/api/review/structure-terms-batch/apply') and self.command=='POST':
            if not self.authenticated():raise ReviewError(401,'请先登录后批量修改描述项')
            if not getattr(self.server.gallery,'structure_terms_batch_enabled',False):raise ReviewError(409,'当前展示版本尚未启用描述项批量功能，请刷新入口')
            data=batch_body(self)
            return self.json((preview if path.endswith('preview') else apply)(self.server.gallery.editor,data))
        return super().review_route(path)
