import ast
from collections import Counter
from dataclasses import dataclass
import hashlib
import json
from pathlib import Path
import random
import shutil

from omegaconf import OmegaConf
from rich import print
from tqdm import tqdm

from functional_rl import v2
from hinted_rl.teacher_programs import canonical
from refined_v4.data import load_rows,write_rows,atomic_json,signature
from refined_v4.fast_generate import CodeExample,code_row
from . import ROOT,TASKS
from .audit import authentic
from .data import annotate,documents


@dataclass
class Config:
    root: str=str(ROOT/'variants/fresh-native-full-v1')
    source: str=str(ROOT/'variants/clear-practice-rl-v1')
    tokens: int=16777216
    benchmark_fraction: float=.1
    seed: int=7169


def convert(raw: dict,task: str):
    tree=ast.parse(raw['reference'])
    functions=[n for n in tree.body if isinstance(n,ast.FunctionDef)]
    if len(functions)!=1:raise ValueError('One entry-point function required')
    function=functions[0]
    if ast.get_docstring(function) is not None:raise ValueError('Expected an implementation without a documentation wrapper')
    lines=raw['reference'].splitlines(keepends=True)
    start=function.body[0].lineno-1
    item=CodeExample(index=0,instruction=raw['question'],signature=''.join(lines[:start]).strip(),
        body=''.join(lines[start:]),example=raw['tests'][0])
    row=code_row(task,item,raw['provenance'].get('response_id',''))
    if row is None:raise ValueError('Native formatting rejected the source')
    if task.startswith('humaneval'):
        assertion=ast.parse(item.example).body
        if len(assertion)!=1 or not isinstance(assertion[0],ast.Assert):raise ValueError('Expected a single assertion example')
        documentation=item.instruction+'\n\n>>> '+ast.unparse(assertion[0].test)+'\nTrue'
        if task.endswith('_docstring'):
            literal=documentation.replace('\\','\\\\').replace('"""','\\"\\"\\"')
            prefix=item.signature+'\n    """'+literal.replace('\n','\n    ')+'\n    """\n'
        else:
            prefix=''.join('# '+line+'\n' if line else '#\n' for line in documentation.splitlines())+item.signature+'\n'
        body=raw['reference'][len(''.join(lines[:start])):]
        row.update(reference=prefix+body,answer=prefix+body,protected_prefix=prefix)
    identity=hashlib.sha256((raw['group']+raw['reference']).encode()).hexdigest()
    row.update(source_id='fresh-contract/'+identity,group=raw['group'],tests=raw['tests'],setup=raw.get('setup',''))
    row['provenance']=dict(raw['provenance'],sft_origin='cached_api_contract',format_revision='native-code-doctest-v1')
    row=annotate(row)
    if len(v2.ENC.encode_ordinary(v2.render(row)))>900:raise ValueError('Source too long for complete few-shot packing')
    return row


def build(config: Config):
    root,source=Path(config.root),Path(config.source)
    if (root/'dataset.json').exists():raise ValueError('Fresh dataset already frozen')
    root.mkdir(parents=True,exist_ok=True)
    original={task:load_rows(source,task,'sft') for task in TASKS}
    blocked_groups,blocked_code,blocked_questions=set(),set(),set()
    for task in TASKS:
        for split in ('rl','calibration','dev','test'):
            for row in load_rows(source,task,split):
                blocked_groups.add(row['group']);blocked_code.add(canonical(row['reference']))
                if row['question']:blocked_questions.add(row['question'])
    base=original['mbpp']
    retained=[row for row in base if not authentic(row)]
    seen_groups={r['group'] for r in base}|blocked_groups
    seen_code={canonical(r['reference']) for r in retained}|blocked_code
    selected=list(retained)
    counts=Counter()
    cache=Path('/nlp/scr/dhei/tiny-rl/experiments/refined-tasks-v4/fast-api/mbpp/rows.jsonl')
    for line in tqdm(cache.open(),desc='Expand the native SFT source bank',colour='cyan',mininterval=10):
        row=json.loads(line)
        if not row['source_id'].startswith('fast-api/') or row['group'] in seen_groups or row['question'] in blocked_questions:continue
        try:
            fingerprint=canonical(row['reference'])
            if fingerprint in seen_code:continue
            converted=convert(row,'mbpp')
        except (SyntaxError,ValueError,KeyError):
            counts['format_or_context']+=1
            continue
        selected.append(row)
        seen_groups.add(row['group']);seen_code.add(fingerprint)
        counts['additional_contracts']+=1
    report=json.loads((source/'dataset.json').read_text())
    report.update(revision='fresh-native-code-v1',source=str(source),sft_tokens=config.tokens,seed=config.seed,
        benchmark_draw_probability=config.benchmark_fraction,source_expansion=dict(counts),
        sft_policy='Use the existing clear source bank plus unused cached API contracts; deduplicate source groups and canonical code against RL and held-out pools. Uniform source-origin selection with the declared benchmark probability. Full native programs, 2–4 independent examples/document.',
        humaneval_synthetic_format='Native comments or docstrings with valid doctest-style boolean examples; no wrapper tokens.',
        validation='SFT syntax/context checks only. The existing independently tested RL bank and original held-out bytes stay unchanged.')
    for task in TASKS:
        rows=[r for r in original[task] if authentic(r)]
        seen={canonical(r['reference']) for r in rows}|blocked_code
        for raw in tqdm(selected,desc=task+' native sources',colour='cyan',mininterval=10):
            try:
                row=convert(raw,task)
                fingerprint=canonical(row['reference'])
                if fingerprint in seen:continue
                seen.add(fingerprint)
                rows.append(row)
            except (SyntaxError,ValueError,KeyError):continue
        shutil.copytree(source/'data'/task,root/'data'/task,dirs_exist_ok=True)
        write_rows(root/'data'/task/'sft.jsonl.gz',rows)
        corpus=documents(rows,config.tokens,random.Random(config.seed),config.benchmark_fraction)
        target=root/'sft'/task/'train.jsonl.gz';write_rows(target,corpus)
        item=report['tasks'][task]
        item.update(rows=dict(item['rows'],sft=len(rows)),documents=len(corpus),source_groups=len({r['group'] for r in rows}),
            document_example_counts=dict(Counter(len(d['examples']) for d in corpus)),sft_sha256=signature(target),
            unique_sft_programs_used=len({e['source_id'] for d in corpus for e in d['examples']}),
            source_bank_rendered_tokens=sum(len(v2.ENC.encode_ordinary(v2.render(r))) for r in rows))
        item['assets']['data/'+task+'/sft.jsonl.gz']=signature(root/'data'/task/'sft.jsonl.gz')
        item.setdefault('hint_coverage',{})['sft']={str(n):sum(n in r['hint_levels'] for r in rows) for n in range(1,17)}
        for split in ('rl','calibration','dev','test'):
            assert signature(root/'data'/task/(split+'.jsonl.gz'))==signature(source/'data'/task/(split+'.jsonl.gz'))
        atomic_json(root/'build-progress.json',report)
    atomic_json(root/'dataset.json',report)
    print('[green]Larger native SFT bank built; RL and held-out data unchanged[/green]',flush=True)


if __name__=='__main__':
    build(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config),OmegaConf.from_cli())))