"""Evidence-based, bounded review selection; never manufactures completed labels."""
from collections import Counter
from contextlib import closing
from datetime import datetime,timezone
import json
import math
import re

from .mask_model_training_data import sha
from .mask_gallery_review import ReviewError
from .pallet_description_batch import batch_body
from .pallet_description_simple import ROOT
from .pose_review_geometry import canonical

RELEASE=ROOT/'round6_triage_v1'
POLICY='empirical_priority_and_50_stratified_audits_v1'
THRESHOLD=.99
AUDIT_BUDGET=50


def select_queue(proposals,training,predictions,classes,reviews,*,budget=AUDIT_BUDGET):
    """Freeze candidates once; completed audits are never replenished on refresh.

    Priority: explicit structural conflict or high confidence class disagreement
    with BOTH classes covered by the independent training branch. Model format,
    abstention, attribute mismatch and IoU alone are diagnostic signals.
    """
    if type(budget)is not int or not 0<=budget<=60:raise ValueError('Audit budget must be 0..60')
    trained={r['class_id'] for r in training if r['evaluation_branch_split']=='train'}
    index={v['fine_index']:v['class_id'] for v in classes.values() if v['train_enabled']}
    bykey={r['target_key']:r for r in training};pred={r['target_key']:r for r in predictions};entries={}
    for p in proposals:
        key=p['target_key'];reasons=p.get('review_reasons',[]);model=pred.get(key);priority=[];diagnostics=[];evidence={}
        if any('结构选项／文字／类别定义冲突' in r for r in reasons):priority.append('结构选项／文字／类别定义冲突：逐字段核对')
        if model:
            probs=model['fine_probabilities'];i=model['predicted_fine_index'];score=probs[i]
            if len(probs)!=len(index) or not math.isfinite(score) or not 0<=score<=1:raise ValueError('Invalid classifier evidence')
            candidate=index[i];covered=p['class_id'] in trained and candidate in trained
            evidence=dict(human_class=p['class_id'],model_class=candidate,model_score=score,training_covered=covered,iou=model['iou'],
                class_pair=f"Class{p['class_id']} → Class{candidate}",score_is_calibrated_probability=False)
            if candidate!=p['class_id']:
                if score>=THRESHOLD and covered:priority.append('高分分类分歧且两类训练覆盖：'+evidence['class_pair'])
                elif not covered:diagnostics.append('独立训练未覆盖相关类别，模型分歧不单独要求复核')
                else:diagnostics.append('分类分歧低于优先阈值，保留模型诊断')
        diagnostics.extend(r for r in reasons if '结构选项／文字／类别定义冲突' not in r and '分类与' not in r)
        record=bykey[key];saved=reviews.get(key)
        entries[key]=dict(target_key=key,tier='priority' if priority else 'diagnostic',priority_reasons=priority,diagnostic_reasons=diagnostics,
            evidence=evidence,class_id=p['class_id'],component=record['component'],image_sha256=p['image_sha256'],
            recently_reviewed=record.get('geometry_source')=='latest_saved_human_correct_round6',
            initial_revision=saved['revision'] if saved else 0,initial_completed=bool(saved and saved['action']=='correct'),audit_group=None)
    # Split 50 slots evenly: geometry-risk strata and broad quality/description.
    # Unique original images among sampled items; priority remains fully retained.
    selected=[];images=set();class_counts=Counter();components=Counter();bins=Counter()
    def iou_bin(e):
        x=e['evidence'].get('iou')
        return 'unknown' if x is None else '<0.5' if x<.5 else '0.5-0.7' if x<.7 else '0.7-0.8' if x<.8 else '0.8-0.85' if x<.85 else '>=0.85'
    def choose(group,limit):
        for _ in range(limit):
            options=[e for e in entries.values() if e['tier']=='diagnostic' and not e['initial_completed'] and e['image_sha256'] not in images
                and (group!='geometry' or e['evidence'].get('iou',1)<.85)]
            if not options:break
            def rank(e):return (bins[iou_bin(e)] if group=='geometry' else 0,e['recently_reviewed'],class_counts[e['class_id']],components[e['component']],sha([POLICY,group,e['target_key']]))
            entry=min(options,key=rank);entry['tier']='audit';entry['audit_group']=group;entry['audit_iou_bin']=iou_bin(entry)
            images.add(entry['image_sha256']);class_counts[entry['class_id']]+=1;components[entry['component']]+=1;bins[iou_bin(entry)]+=1;selected.append(entry['target_key'])
    choose('geometry',budget//2);choose('general',budget-len(selected))
    return dict(policy=POLICY,threshold=THRESHOLD,audit_budget=budget,actual_audit_count=len(selected),entries=entries,
        tier_counts=dict(Counter(e['tier'] for e in entries.values())),completed_at_selection=sum(e['initial_completed'] for e in entries.values()),
        priority_pending_at_selection=sum(e['tier']=='priority' and not e['initial_completed'] for e in entries.values()),
        audit_strata=dict(Counter(e['audit_group'] for e in entries.values() if e['tier']=='audit')),
        same_label_repeated_high_confidence_not_permanently_suppressed=True,unselected_are_not_completed=True)


def summary(policy,reviews):
    counts=Counter({k:0 for k in ('priority','audit','diagnostic','completed','unfinished','priority_pending','audit_pending','diagnostic_pending')})
    for key,e in policy['entries'].items():
        complete=reviews.get(key,{}).get('action')=='correct';counts[e['tier']]+=1
        counts['completed' if complete else 'unfinished']+=1
        if not complete:counts[e['tier']+'_pending']+=1
    counts['required_pending']=counts['priority_pending']+counts['audit_pending']
    return dict(counts)


def decisions(ed):
    with closing(ed.store.connect()) as db:
        if not db.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='triage_decisions'").fetchone():return {}
        return {k:json.loads(raw) for k,raw in db.execute('SELECT target_key,payload FROM triage_decisions ORDER BY id')}


def decide(ed,data,policy_hash):
    fields={'binding','source_key','source_binding','expected_revision','request_id','policy_sha256','decision','note','reviewer'}
    if not isinstance(data,dict) or set(data)!=fields:raise ReviewError(400,'结论字段不完整')
    if data['policy_sha256']!=policy_hash or data['binding']!=ed.binding:raise ReviewError(409,'筛选策略或任务版本已变化')
    p=ed.proposal(data['source_key'])
    if data['source_binding']!=sha(p):raise ReviewError(409,'目标来源已变化')
    if data['decision'] not in ('label_confirmed','model_error','definition_unclear'):raise ReviewError(400,'无效疑点结论')
    if type(data['expected_revision'])is not int or data['expected_revision']<1:raise ReviewError(400,'请先保存当前标注，再记录结论')
    if not isinstance(data['note'],str) or len(data['note'])>1000 or not isinstance(data['request_id'],str) or not re.fullmatch('[0-9a-f]{32}',data['request_id']):raise ReviewError(400,'无效结论备注或请求ID')
    from .pallet_description_single import reviewer_name
    request=dict(data,reviewer=reviewer_name(data['reviewer']),note=data['note'].strip());request_hash=sha(request)
    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 triage_decisions(id INTEGER PRIMARY KEY AUTOINCREMENT, request_id TEXT UNIQUE NOT NULL, request_sha256 TEXT NOT NULL,target_key TEXT NOT NULL,payload TEXT NOT NULL)')
            old=db.execute('SELECT request_sha256,payload FROM triage_decisions WHERE request_id=?',(request['request_id'],)).fetchone()
            if old:
                if old[0]!=request_hash:raise ReviewError(409,'结论请求ID已用于其他内容')
                value=json.loads(old[1]);db.rollback();return dict(decision=value,replayed=True)
            row=db.execute('SELECT revision,payload FROM reviews WHERE target_key=?',(request['source_key'],)).fetchone()
            if not row or row[0]!=request['expected_revision']:raise ReviewError(409,'当前标注修订已变化，请读取服务器版本后记录结论')
            value=dict(request,review_payload_sha256=sha(json.loads(row[1])),recorded_at=datetime.now(timezone.utc).isoformat(),
                annotation_completion_performed=False,annotation_revision_changed=False,automatic_label_change=False)
            db.execute('INSERT INTO triage_decisions(request_id,request_sha256,target_key,payload) VALUES (?,?,?,?)',(request['request_id'],request_hash,request['source_key'],canonical(value).decode()))
            if not ed.source_guard.current():raise ReviewError(409,'记录结论前来源发生变化，已回滚')
            db.commit();return dict(decision=value,replayed=False)
        except Exception:db.rollback();raise


class TriageHandlerMixin:
    def review_route(self,path):
        if path=='/api/review/triage-policy' and self.command in ('GET','HEAD'):
            if not self.authenticated():raise ReviewError(401,'请先登录')
            g=self.server.gallery;values=g.editor.store.summary()
            return self.json(dict(policy=g.triage_policy,policy_sha256=g.triage_policy_sha256,counts=summary(g.triage_policy,values),decisions=decisions(g.editor)))
        if path=='/api/review/triage-decision' and self.command=='POST':
            if not self.authenticated():raise ReviewError(401,'请先登录')
            g=self.server.gallery
            return self.json(decide(g.editor,batch_body(self),g.triage_policy_sha256))
        return super().review_route(path)
