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

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

from refined_v4.data import atomic_json, write_rows, signature

from . import REVISION
from .catalog import skills, program
from .envs import ENC, available_hints

ROOT = Path('/nlp/scr/dhei/tiny-rl/experiments/refined-basic-python-v1')


@dataclass
class Config:
    root: str = str(ROOT)
    tokens: int = 2097152
    seed: int = 4517
    interfaces: str = 'varied'


def build(config: Config):
    root = Path(config.root)
    if config.interfaces not in ('varied','canonical'):
        raise ValueError('Unknown Python interface design')
    manifest = root/'dataset.json'
    if manifest.exists():
        existing = json.loads(manifest.read_text())
        if existing['sft_tokens'] != config.tokens or existing.get('interfaces','varied') != config.interfaces:
            raise ValueError('Frozen dataset already has a different token budget')
        return existing
    folds = {name: [] for name in ('sft','rl','dev','test')}
    for skill in skills():
        count=4 if config.interfaces=='canonical' else 16
        order = list(range(count))
        random.Random(config.seed+int(hashlib.sha256(skill.names[0].encode()).hexdigest()[:8],16)).shuffle(order)
        assignment = ({index:split for index,split in zip(order,('sft','rl','dev','test'),strict=True)}
                      if config.interfaces=='canonical' else
                      {index: ('sft' if rank<8 else 'rl' if rank<12 else 'dev' if rank<14 else 'test')
                       for rank,index in enumerate(order)})
        for index in range(count):
            name_index=index if config.interfaces=='canonical' else index//4
            name, header, reference = program(skill,name_index,index%4,config.interfaces=='canonical')
            tests = [f'assert {name}({", ".join(repr(arg) for arg in case)}) == {skill.oracle(*case)!r}'
                     for case in skill.cases]
            key = hashlib.sha256((skill.family+'/'+reference).encode()).hexdigest()[:20]
            row = dict(task='basic_python', revision=REVISION, source_id=key, group=key,
                question=skill.description, reference=reference, protected_prefix=header,
                answer=reference[len(header):], tests=tests, setup='', function_name=name,
                provenance=dict(family=skill.family,skill=skill.names[0],difficulty=skill.family,
                    body_tokens=len(ENC.encode_ordinary(reference[len(header):]))))
            folds[assignment[index]].append(row)
    rng = random.Random(config.seed)
    for split,rows in folds.items():
        for row in rows:
            if split != 'sft':
                candidates = [d for d in folds['sft'] if d['function_name'] != row['function_name']
                              and d['provenance']['skill'] != row['provenance']['skill']]
                demo1 = rng.choice(candidates)
                demo2 = rng.choice([d for d in candidates if d['function_name'] != demo1['function_name']
                                    and d['provenance']['family'] != demo1['provenance']['family']])
                row['demonstrations'] = [dict(source_id=d['source_id'],group=d['group'],reference=d['reference'])
                                         for d in (demo1,demo2)]
            row['hint_levels'] = available_hints(row)
            if not row['hint_levels']:
                raise ValueError('A function has no valid completion boundaries')
        write_rows(root/'data/basic_python'/f'{split}.jsonl.gz',rows)
    documents, tokens = [], 0
    with tqdm(total=config.tokens,desc='Clean Python SFT',unit='tok',colour='cyan') as progress:
        while tokens < config.tokens:
            selected = []
            for family in rng.sample(sorted({s.family for s in skills()}),4):
                candidates = [row for row in folds['sft'] if row['provenance']['family']==family
                              and row['function_name'] not in {d['function_name'] for d in selected}]
                selected.append(rng.choice(candidates))
            text = '\n\n'.join(row['reference'] for row in selected)
            count = len(ENC.encode_ordinary(text))
            usable = min(count,config.tokens-tokens)
            documents.append(dict(text=text,tokens=count,budget_tokens=usable,
                groups=[row['group'] for row in selected],examples=len(selected)))
            tokens += usable
            progress.update(usable)
    write_rows(root/'sft/basic_python/train.jsonl.gz',documents)
    result = dict(revision=REVISION,interfaces=config.interfaces,sft_tokens=tokens,documents=len(documents),skills=len(skills()),
        rows={name:len(rows) for name,rows in folds.items()},
        split_policy='Shared elementary skills; disjoint named function/signature contracts. All examples of one contract stay in one fold. Evaluation demonstrations use SFT only.',
        sampling='Uniform missing length 1..16, uniform eligible family, uniform eligible contract. Short functions are never padded.',
        families=sorted({s.family for s in skills()}),seed=config.seed,
        coverage={name:{str(level):dict(Counter(row['provenance']['family'] for row in rows if level in row['hint_levels']))
                        for level in range(1,17)} for name,rows in folds.items()},
        assets={str(path.relative_to(root)):signature(path) for path in sorted(root.glob('data/basic_python/*.gz'))},
        sft_sha256=signature(root/'sft/basic_python/train.jsonl.gz'))
    atomic_json(manifest,result)
    print('[green]Dataset ready[/green]',{k:v for k,v in result.items() if k not in ('assets','coverage')})
    return result


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