#!/usr/bin/env python3
"""Finite-domain model verification for QP-YINGQI-001 (Python 3, no packages).
This evaluates the published equations and ranking model, not a Vir binary.
Run: python3 verify.py
"""
from pathlib import Path
from collections import defaultdict
import json, random, itertools, hashlib
ROOT=Path(__file__).resolve().parent
PRIORITY={
 'R_VOID_FILL':1,'R_MONTH_BREAK_FILL':2,'R_MONTH_BREAK_COMBINE':2,
 'R_TOMB_CLASH':3,'R_ADVANCING_PROCEED':4,'R_VOID_CLASH':5,
 'R_COMBINE_CLASH':6,'R_VALUE_DIRECT':7,'R_MOVING_VALUE_COMBINE':8,
 'R_MOVED_TRANSFORMED':9,'R_STATIC_VALUE_CLASH':10,'R_WANING_ASSIST':11,
 'R_RETREATING_HALT':12,'R_OVERSTRONG_TOMB_CONTROL':13,
 'R_ATTACKED_RESTRICT_ATTACKER':14,'R_ONLY_MOVING_STATIC':15,
 'R_HIDDEN_SPIRIT_VALUE':16,'R_HIDDEN_SPIRIT_CLASH_FLY':17}
HARMONY={1:2,2:1,3:12,12:3,4:11,11:4,5:10,10:5,6:9,9:6,7:8,8:7}

def ahead(base,target):
    d=target-base
    return d+12 if d<=0 else d

def clash(branch): return branch+6 if branch<=6 else branch-6

def strength(score): return 'high' if score>=50 else 'medium' if score>=40 else 'low'
def confidence(score): return 'high' if score>=54 else 'medium' if score>=48 else 'low'
def trigger(branch,score,rule): return dict(branch=branch,score=score,ruleId=rule,useLine=2)

def model(triggers,base=1,top_k=3):
    """Procedural model of grouping, primary-rule selection and branch picking."""
    if not triggers: return []
    k=min(3 if top_k<=0 else top_k,len(triggers),60)
    branches=list(dict.fromkeys(t['branch'] for t in triggers))
    def info(branch):
        rows=[t for t in triggers if t['branch']==branch]
        primary=rows[0]
        for row in rows[1:]:
            if row['score']>primary['score'] or (row['score']==primary['score'] and PRIORITY[row['ruleId']]<PRIORITY[primary['ruleId']]): primary=row
        score=max(0,*(r['score'] for r in rows))+3*(len(rows)-1)
        return dict(branch=branch,score=score,primary_rule=primary['ruleId'],offset=ahead(base,branch),evidence_count=len(rows))
    result=[]
    while branches and len(result)<k:
        chosen=branches[0]
        for branch in branches[1:]:
            a,b=info(branch),info(chosen)
            ka=(-a['score'],PRIORITY[a['primary_rule']],a['offset'],a['branch'])
            kb=(-b['score'],PRIORITY[b['primary_rule']],b['offset'],b['branch'])
            if ka<kb: chosen=branch
        result.append(info(chosen)); branches.remove(chosen)
    return result

def oracle(triggers,base,k):
    """Independent batch aggregation and lexicographic sort for comparison."""
    groups=defaultdict(list)
    for t in triggers: groups[t['branch']].append(t)
    rows=[]
    for b,items in groups.items():
        primary=min(enumerate(items),key=lambda pair:(-pair[1]['score'],PRIORITY[pair[1]['ruleId']],pair[0]))[1]
        rows.append((b,max([0]+[x['score'] for x in items])+3*(len(items)-1),primary['ruleId'],1+((b-base-1)%12),len(items)))
    rows.sort(key=lambda row:(-row[1],PRIORITY[row[2]],row[3],row[0]))
    return [dict(zip(['branch','score','primary_rule','offset','evidence_count'],r)) for r in rows[:min(3 if k<=0 else k,len(triggers),60)]]

VECTORS=[
 {'id':'YINGQI-V001','base':1,'top_k':3,'triggers':[trigger(1,52,'R_VALUE_DIRECT'),trigger(7,45,'R_STATIC_VALUE_CLASH')],'expected_branches':[1,7],'expected_scores':[52,45],'expected_offsets':[12,6]},
 {'id':'YINGQI-V002','base':5,'top_k':3,'triggers':[trigger(3,55,'R_VOID_FILL'),trigger(3,52,'R_VALUE_DIRECT'),trigger(9,48,'R_VOID_CLASH'),trigger(9,45,'R_STATIC_VALUE_CLASH')],'expected_branches':[3,9],'expected_scores':[58,51],'expected_offsets':[10,4]},
 {'id':'YINGQI-V003','base':1,'top_k':3,'triggers':[trigger(2,50,'R_ONLY_MOVING_STATIC'),trigger(9,50,'R_MONTH_BREAK_COMBINE')],'expected_branches':[9,2],'expected_scores':[50,50],'expected_offsets':[8,1]},
 {'id':'YINGQI-V004','base':1,'top_k':3,'triggers':[trigger(1,50,'R_ONLY_MOVING_STATIC'),trigger(2,50,'R_ONLY_MOVING_STATIC')],'expected_branches':[2,1],'expected_scores':[50,50],'expected_offsets':[1,12]},
 {'id':'YINGQI-V005','base':1,'top_k':60,'triggers':[trigger(3,52,'R_VALUE_DIRECT'),trigger(3,52,'R_VALUE_DIRECT')],'expected_branches':[3],'expected_scores':[55],'expected_offsets':[2]},
 {'id':'YINGQI-V006','base':1,'top_k':0,'triggers':[],'expected_branches':[],'expected_scores':[],'expected_offsets':[]}
]

def verify():
    counts={}
    for base in range(1,13):
        for branch in range(1,13):
            d=ahead(base,branch); assert 1<=d<=12 and (base-1+d)%12+1==branch
    counts['branch_distance_pairs']=144
    for b in range(1,13): assert clash(clash(b))==b and HARMONY[HARMONY[b]]==b and clash(b)!=b and HARMONY[b]!=b
    counts['branch_involution_inputs']=12
    for v in VECTORS:
        result=model(v['triggers'],v['base'],v['top_k'])
        for key,expected in [('branch','expected_branches'),('score','expected_scores'),('offset','expected_offsets')]: assert [r[key] for r in result]==v[expected],v['id']
    counts['hand_checked_vectors']=len(VECTORS)
    rng=random.Random(20261121); rules=list(PRIORITY); rankings=0
    for _ in range(120):
        ts=[trigger(rng.randint(1,12),rng.randint(43,55),rng.choice(rules)) for _ in range(rng.randint(1,36))]
        for base in range(1,13):
            for k in [0,1,3,60]:
                rows=model(ts,base,k)
                assert rows==oracle(ts,base,k)
                assert len({r['branch'] for r in rows})==len(rows)<=12
                assert sum(r['evidence_count'] for r in rows)<=len(ts)
                rankings+=1
    counts['ranking_oracle_cases']=rankings
    for score,s,c in [(39,'low','low'),(40,'medium','low'),(47,'medium','low'),(48,'medium','medium'),(49,'medium','medium'),(50,'high','medium'),(53,'high','medium'),(54,'high','high')]:
        assert strength(score)==s and confidence(score)==c
    counts['label_boundary_cases']=8
    # All 18 source rule IDs and their priorities are part of the published registry.
    assert len(PRIORITY)==18
    rules_file=ROOT/'rules.json'
    if rules_file.exists(): assert {r['rule_id']:r['priority'] for r in json.loads(rules_file.read_text())}==PRIORITY
    return dict(status='pass',verification_kind='finite-domain mathematical model; not native execution',counts=counts,seed=20261121,rule_ids=len(PRIORITY))

if __name__=='__main__':
    result=verify()
    # Deterministic artifacts: no timestamps or private input.
    (ROOT/'test-vectors.json').write_text(json.dumps(VECTORS,ensure_ascii=False,indent=2)+'\n')
    (ROOT/'verification-summary.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n')
    print(json.dumps(result,ensure_ascii=False,indent=2))
