import gc, json, math, time
from common import ROOT, BASE, BASE_MODELS, cached, context, seed, identity, format_feedback, read, sha
from coder import FrozenCoder, extract_code

class Coder(FrozenCoder):

    def __init__(self):
        super().__init__(BASE_MODELS / 'ReasonFlux-Coder-7B')

    def _generate(self, prompt, **kwargs):
        ids = self.tokenizer.encode(prompt, add_special_tokens=False)
        if len(ids) > 15000:
            prompt = self.tokenizer.decode(ids[:5000]) + '\n[Context shortened to fit token budget]\n' + self.tokenizer.decode(ids[-10000:])
        return super()._generate(prompt, **kwargs)

    def proposal(self, task, run_seed, current=None, feedback=None, round_id=0):
        n = 1 if current is None else 4
        boundary = 'Implement the required callable named ' + task['fn_name'] + ' as a method of class Solution. Preserve the provided signature.\nStarter code:\n' + task['starter_code'] if task['fn_name'] else 'Write a complete Python script that reads standard input and prints to standard output.'
        prompt = 'Solve the following programming task. ' + boundary + '\nReturn the complete solution in one ```python code block.\nProblem:\n' + task['problem']
        if current is not None:
            prompt += '\nCurrent implementation:\n```python\n' + current + '\n```\nObserved public test feedback:\n' + format_feedback(feedback) + '\nPublic examples:\n' + json.dumps(task['public_tests'], ensure_ascii=False) + '\nRevise the implementation using this feedback.'
        key = dict(task=task['task_id'], prompt_sha=identity(prompt), fn_name=task['fn_name'], seed=run_seed, current=current, feedback=json.loads(format_feedback(feedback)) if feedback is not None else None, round=round_id, n=n, sampler='ReasonFlux-7B-temperature0.8-top_p0.95-max4096-v1')

        def generate():
            rows = self._generate(prompt, n=n, seed=seed(task['task_id'], run_seed, round_id, identity(current), 'initial' if current is None else 'repair'), max_new_tokens=4096)
            return [dict(code=extract_code(r.text), text=r.text, input_tokens=r.input_tokens, output_tokens=r.output_tokens, seconds=r.seconds) for r in rows]
        return cached('generation', key, generate)

class World:

    def __init__(self, path):
        from semantic_world import SemanticExecutionWorld
        self.model = SemanticExecutionWorld.load(path, BASE_MODELS / 'Qwen2.5-Coder-3B-Instruct', device='cuda').eval()
        self.identity = self.model.identity

    def score(self, task, current, feedback, codes):
        texts = [context(task, current, feedback, c) for c in codes]
        tok = self.model.public_world.online.tokenizer
        trimmed = []
        for text in texts:
            ids = tok.encode(text, add_special_tokens=False)
            trimmed.append(text if len(ids) <= 16000 else tok.decode(ids[:4000]) + '\n[Context shortened]\n' + tok.decode(ids[-12000:]))
        out = self.model.score_suite(trimmed)
        values = out['utility'].detach().float().cpu().tolist()
        if any((r['status'] != 'AC' for r in feedback['results'])):
            for (i, code) in enumerate(codes):
                if code == current:
                    values[i] = 0.25 * float(out['predicted_pass_fraction'][i])
        assert all((math.isfinite(x) and 0 <= x <= 1.25 for x in values))
        return values