"""Freeze screened split-specific raw-text episodes, cloze and continuation tasks."""
import argparse
from collections import Counter,defaultdict
import hashlib
import json
from pathlib import Path
import re
import sqlite3

from sentencepiece_unigram import Tokenizer,read_json,sha,write_json,now


def rank(value):
    return hashlib.sha256(('20261024:'+value).encode()).hexdigest()


def clean_passage(text):
    return (len(text)>=192 and not re.search(r'[\ufffd□〓{}]|https?://|Wikisource|ウィキソース|<ref|</ref',text,re.I)
            and sum(c.isalpha() for c in text)>=len(text)*.5)


def main():
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument('--output',type=Path)
    p.add_argument('--split',choices=['validation','test'],default='validation')
    p.add_argument('--final-test',action='store_true')
    a=p.parse_args()
    if a.split=='test' and not a.final_test:p.error('Test fixtures require --final-test after model selection')
    out=a.output or Path('unified/evaluation-tasks-v1')/(a.split+'-001')
    config=read_json(Path('scripts/pretrain_hf_config.json'))['evaluation_tasks']
    split=Path('unified/training-tokens-v1/build-006')
    manifest=read_json(split/'manifest.json')
    if not manifest['complete'] or sha(split/'splits.jsonl')!=manifest['files']['splits.jsonl']:
        raise ValueError('Split metadata mismatch')
    with (split/'splits.jsonl').open() as f:
        selected=[r for r in map(json.loads,f) if r['split']==a.split and r['source'] in config['fixture_sources']]
    dbpath=Path('unified/pretrain-v1/build-002/build.sqlite3')
    dm=read_json(dbpath.parent/'manifest.json')
    if sha(dbpath)!=dm['output_sha256'][dbpath.name]:
        raise ValueError('Text database changed')
    db=sqlite3.connect('file:'+str(dbpath.resolve())+'?mode=ro',uri=True)
    tokenizer=Tokenizer(split/'tokenizer.model')
    pool=[];rejected=Counter()
    for r in selected:
        # Only IDs already whitelisted as validation are ever queried for text.
        text,metadata=db.execute('SELECT text,metadata FROM units WHERE id=?',(r['id'],)).fetchone()
        if hashlib.sha256(text.encode()).hexdigest()!=r['text_sha256']:
            raise ValueError('Source text identity mismatch')
        q=json.loads(metadata).get('quality',{})
        original=q.get('original_quality') or {}
        norm=original.get('normalization') or {}
        if original.get('problematic_pages',0) or norm.get('missing_characters_removed',0):
            rejected['quality_flag']+=1;continue
        if any(re.search('markup|problematic|residual',flag,re.I) for flag in q.get('review_flags',[])):
            rejected['review_flag']+=1;continue
        starts=sorted({0,len(text)//4,len(text)//2,3*len(text)//4})
        for start in starts:
            episode=text[start:start+config['raw_episode_max_characters']]
            if not clean_passage(episode):
                rejected['passage_screen']+=1;continue
            encoded=tokenizer.encode(episode)
            if 0 in encoded or tokenizer.decode(encoded)!=episode or len(encoded)>2048:
                rejected['tokenizer_roundtrip_or_length']+=1;continue
            n=config['prefix_characters'];length=config['continuation_characters']
            gold=episode[n:n+length]
            if sum(c.isalpha() for c in gold)<length//2:
                rejected['target_screen']+=1;continue
            pool.append(dict(id=f"{r['id']}@{start}",source_id=r['id'],source=r['source'],era=r['era'],
                         era_basis=r['era_basis'],group=r['group'],title=r['title'],
                         text_sha256=r['text_sha256'],span_start=start,
                         span_end=start+len(episode),raw_episode=episode,raw_characters=len(episode),
                         prefix=episode[:n],cloze_gold=gold[:config['cloze_gold_characters']],
                         continuation_gold=gold,review_status='automatically_screened_pending_manual_review'))
    db.close()
    chosen=[];group_count=Counter()
    for source in config['fixture_sources']:
        buckets=defaultdict(list)
        for row in pool:
            if row['source']==source:buckets[row['era'],row['group']].append(row)
        for values in buckets.values():values.sort(key=lambda r:rank(r['id']))
        source_count=0
        while source_count<config['examples_per_source']:
            progress=False
            for key in sorted(buckets,key=lambda k:(k[0],rank(k[1]))):
                values=buckets[key]
                if not values or group_count[key[1]]>=config['maximum_examples_per_work_group']:continue
                row=values.pop(0);chosen.append(row);group_count[key[1]]+=1;source_count+=1;progress=True
                if source_count==config['examples_per_source']:break
            if not progress:break
        if source_count<config['examples_per_source']:
            raise ValueError(f'Insufficient screened validation fixtures for {source}: {source_count}')
    for row in chosen:
        donors=sorted((r for r in pool if r['source']==row['source'] and r['era']==row['era']
                      and r['group']!=row['group'] and r['continuation_gold']!=row['continuation_gold']),
                      key=lambda r:rank(row['id']+':'+r['id']))
        unique=[];groups=set();texts={row['continuation_gold']}
        for donor in donors:
            if donor['group'] in groups or donor['continuation_gold'] in texts:continue
            unique.append(donor);groups.add(donor['group']);texts.add(donor['continuation_gold'])
            if len(unique)==3:break
        n=4 if len(unique)>=3 else (2 if unique else 0)
        if n:
            candidates=[dict(text=row['continuation_gold'],donor_id=row['source_id'],gold=True)]
            candidates += [dict(text=d['continuation_gold'],donor_id=d['source_id'],gold=False) for d in unique[:n-1]]
            candidates.sort(key=lambda d:rank(row['id']+':option:'+d['text']))
            row['continuation_options']=[dict(text=d['text'],donor_id=d['donor_id']) for d in candidates]
            row['correct_option']=next(i for i,d in enumerate(candidates) if d['gold'])
        else:
            row['continuation_options']=[];row['correct_option']=None
        row['choice_count']=n
        row['episode_sha256']=hashlib.sha256(row['raw_episode'].encode()).hexdigest()
    out.mkdir(parents=True,exist_ok=False)
    with (out/'cases.jsonl').open('w') as f:
        for r in chosen:f.write(json.dumps(r,ensure_ascii=False)+'\n')
    summary=dict(cases=len(chosen),by_source=dict(Counter(r['source'] for r in chosen)),
                 source_era_counts=dict(Counter(r['source']+'/'+r['era'] for r in chosen)),
                 independent_groups=len({r['group'] for r in chosen}),
                 choice_counts=dict(Counter(r['choice_count'] for r in chosen)),
                 raw_characters=sum(r['raw_characters'] for r in chosen),screen_rejections=dict(rejected),
                 status='screened_'+a.split+'_fixtures_pending_manual_clean_text_review',
                 test_examples_created=len(chosen) if a.split=='test' else 0)
    write_json(out/'report.json',summary)
    write_json(out/'manifest.json',dict(complete=True,created=now(),split=a.split,
              split_manifest_sha256=sha(split/'manifest.json'),source_database_sha256=dm['output_sha256'][dbpath.name],
              tokenizer_sha256=manifest['tokenizer_sha256'],script_sha256=sha(__file__),recipe=config,
              scoring='prefix-only cloze; force token boundary before continuation; sum conditional candidate NLL; same-length choices; BPC scores whole raw episode from BOS excluding EOS',
              files={p.name:sha(p) for p in out.iterdir() if p.name!='manifest.json'}))
    print(json.dumps(summary,ensure_ascii=False,indent=2))


if __name__=='__main__':main()