import ast
import hashlib
import random

from functional_rl import v2

REVISION='refined-code-v1'
ENC=v2.ENC
TASKS=('mbpp','mbpp_docstring','humaneval','humaneval_docstring')


def protected_prefix(row: dict) -> str:
    if row.get('protected_prefix'):
        return row['protected_prefix']
    tree=ast.parse(row['reference'])
    functions=[node for node in tree.body if isinstance(node,ast.FunctionDef)]
    if len(functions)!=1:
        raise ValueError('Expected exactly one top-level entry-point function')
    function=functions[0]
    statements=function.body[1:] if ast.get_docstring(function) is not None else function.body
    if not statements:
        raise ValueError('The entry point needs an implementation')
    return ''.join(row['reference'].splitlines(keepends=True)[:statements[0].lineno-1])


def make_episode(row: dict, level: int):
    if type(level) is not int or not 1<=level<=16 or row['task'] not in TASKS:
        raise ValueError('Expected a code task and an integer missing length in 1..16')
    groups={row['group']}
    demos=row.get('demonstrations',())
    for demo in demos:
        if demo['task']!=row['task'] or demo['group'] in groups:
            raise ValueError('Demonstrations must use distinct same-task source groups')
        groups.add(demo['group'])
    context=''.join(v2.render(d).rstrip()+'\n\n' for d in demos)
    header=context+v2.header(row)
    document=header+row['reference']
    ids=ENC.encode_ordinary(document)
    prompt_ids,completion_ids=ids[:-level],ids[-level:]
    prompt,completion=ENC.decode(prompt_ids),ENC.decode(completion_ids)
    if len(ids)>1024 or not prompt.startswith(header+row['protected_prefix']) or prompt+completion!=document:
        raise ValueError('Missing tokens must stay in the implementation and preserve the instruction/signature')
    return v2.Episode(row['task'],row['source_id'],row['group'],level,prompt,completion,
        tuple(prompt_ids),tuple(completion_ids),prompt[len(header):],row['reference'],row['answer'],
        tuple(row['tests']),row.get('setup',''),version=REVISION,question=row['question'],
        provenance=(dict(row['provenance'],rl_origin=row['sampling_origin']) if row.get('sampling_origin') else row['provenance']),
        demonstrations=tuple(dict(task=d['task'],source_id=d['source_id'],
            group=d['group'],text=v2.render(d),split='sft') for d in demos))


def available_hints(row: dict) -> list[int]:
    demos=row.get('demonstrations',())
    groups=[row['group']]+[d['group'] for d in demos]
    if row['task'] not in TASKS or len(set(groups))!=len(groups) or any(d['task']!=row['task'] for d in demos):
        return []
    context=''.join(v2.render(d).rstrip()+'\n\n' for d in demos)
    header=context+v2.header(row)
    document=header+row['reference']
    ids=ENC.encode_ordinary(document)
    if len(ids)>1024:
        return []
    protected=header+row['protected_prefix']
    return [level for level in range(1,min(16,len(ids)-1)+1)
            if ENC.decode(ids[:-level]).startswith(protected)
            and ENC.decode(ids[:-level])+ENC.decode(ids[-level:])==document]


class Pool:
    def __init__(self, rows: list[dict]):
        self.by_hint={n:[r for r in rows if n in r['hint_levels']] for n in range(1,17)}
        if any(not rows for rows in self.by_hint.values()):
            raise ValueError('Each hint length requires eligible benchmark sources')
        origins={row.get('sampling_origin') for row in rows}
        if None in origins and len(origins)>1:
            raise ValueError('An origin-balanced RL pool must label every source')
        self.by_origin=({n:{origin:[r for r in eligible if r['sampling_origin']==origin]
                           for origin in sorted(origins) if any(r['sampling_origin']==origin for r in eligible)}
                         for n,eligible in self.by_hint.items()} if None not in origins else None)

    def sample(self, rng: random.Random):
        level=rng.randint(1,16)
        eligible=self.by_hint[level]
        if self.by_origin is not None:
            groups=self.by_origin[level]
            eligible=groups[rng.choice(list(groups))]
        return make_episode(rng.choice(eligible),level)


def fixed_panel(rows: list[dict], queries: int, seed: int):
    if queries<16 or queries%16:
        raise ValueError('Evaluation draws must be a positive multiple of 16')
    pool=Pool(rows)
    ordered={n:sorted(pool.by_hint[n],key=lambda row:hashlib.sha256(
        f'{seed}/{n}/{row["group"]}'.encode()).hexdigest()) for n in range(1,17)}
    return [(ordered[i%16+1][(i//16)%len(ordered[i%16+1])],i%16+1) for i in range(queries)]