#!/usr/bin/env python3
"""Rule-based code reward for Stage 3 verl/DAPO smoke tests."""

from __future__ import annotations

import ast
import json
import os
import re
import resource
import signal
import subprocess
import sys
import tempfile
from typing import Any


FENCE_RE = re.compile(r"```(?:python|py)?\s*(.*?)```", re.DOTALL | re.IGNORECASE)
MAX_PARSE_CODE_CHARS = 65_536
MAX_PARSE_TRIM_ATTEMPTS = 64

STATUS_CODE = {
    "passed": 0,
    "syntax_error": 1,
    "missing_entry_point": 2,
    "entry_point_not_callable": 3,
    "wrong_answer": 4,
    "runtime_error": 5,
    "timeout": 6,
    "harness_error": 7,
    "no_tests": 8,
    "eval_error": 9,
}

EVAL_HARNESS = r'''
import ast
import io
import json
import math
import signal
import sys
import traceback
from bisect import *
from collections import *
from functools import *
from heapq import *
from itertools import *
from math import *
from operator import *
from string import *
from typing import *

payload = json.loads(sys.stdin.read())
code = payload["code"]
mode = payload["mode"]
entry_point = payload.get("entry_point")
tests = payload.get("tests") or []
per_test_timeout = float(payload.get("per_test_timeout", 2.0))

class FakeStdin:
    def __init__(self, text):
        self._text = io.StringIO(str(text))
        self.buffer = io.BytesIO(str(text).encode())
    def read(self, *args):
        return self._text.read(*args)
    def readline(self, *args):
        return self._text.readline(*args)
    def readlines(self, *args):
        return self._text.readlines(*args)
    def __iter__(self):
        return iter(self._text)

def norm_text(value):
    text = "" if value is None else str(value)
    return "\n".join(line.rstrip() for line in text.strip().splitlines()).strip()

def stdout_equal(got, expected):
    a, b = norm_text(got), norm_text(expected)
    return a == b or a.split() == b.split()

def value_equal(a, b):
    if isinstance(a, bool) or isinstance(b, bool):
        return a == b
    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
        return math.isclose(float(a), float(b), rel_tol=1e-6, abs_tol=1e-6)
    if isinstance(a, (list, tuple)) and isinstance(b, (list, tuple)):
        return len(a) == len(b) and all(value_equal(x, y) for x, y in zip(a, b))
    if isinstance(a, dict) and isinstance(b, dict):
        return set(a.keys()) == set(b.keys()) and all(value_equal(a[k], b[k]) for k in a)
    return str(a) == str(b)

def result(**kwargs):
    print(json.dumps(kwargs, ensure_ascii=False))

def timeout_handler(signum, frame):
    raise TimeoutError("per-test timeout")

try:
    ast.parse(code)
except (SyntaxError, ValueError, MemoryError, RecursionError) as exc:
    result(
        passed=False,
        status="syntax_error",
        interface_ok=False,
        passed_tests=0,
        total_tests=len(tests),
        wrong_answers=0,
        runtime_errors=0,
        timeouts=0,
        error=str(exc)[:300],
    )
    raise SystemExit

try:
    if not tests:
        result(
            passed=False,
            status="no_tests",
            interface_ok=False,
            passed_tests=0,
            total_tests=0,
            wrong_answers=0,
            runtime_errors=0,
            timeouts=0,
        )
        raise SystemExit

    if mode == "function":
        ns = {"__name__": "__main__"}
        signal.signal(signal.SIGALRM, timeout_handler)
        try:
            signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
            exec(compile(code, "<solution>", "exec"), ns)
        except TimeoutError as exc:
            result(
                passed=False,
                status="timeout",
                interface_ok=False,
                passed_tests=0,
                total_tests=len(tests),
                wrong_answers=0,
                runtime_errors=0,
                timeouts=len(tests),
                error=str(exc)[:300],
            )
            raise SystemExit
        finally:
            signal.setitimer(signal.ITIMER_REAL, 0)
        try:
            candidate = eval(entry_point, ns)
        except Exception as exc:
            result(
                passed=False,
                status="missing_entry_point",
                interface_ok=False,
                passed_tests=0,
                total_tests=len(tests),
                wrong_answers=0,
                runtime_errors=0,
                timeouts=0,
                error=str(exc)[:300],
            )
            raise SystemExit
        if not callable(candidate):
            result(
                passed=False,
                status="entry_point_not_callable",
                interface_ok=False,
                passed_tests=0,
                total_tests=len(tests),
                wrong_answers=0,
                runtime_errors=0,
                timeouts=0,
            )
            raise SystemExit

        passed_tests = 0
        wrong_answers = 0
        runtime_errors = 0
        timeouts = 0
        for idx, test in enumerate(tests):
            args = test.get("args") or []
            kwargs = test.get("kwargs") or {}
            expected = test.get("output")
            try:
                signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
                got = candidate(*args, **kwargs)
                if value_equal(got, expected):
                    passed_tests += 1
                else:
                    wrong_answers += 1
            except TimeoutError:
                timeouts += 1
            except Exception:
                runtime_errors += 1
            finally:
                signal.setitimer(signal.ITIMER_REAL, 0)
            if timeouts >= 3:
                break
        skipped_after_timeout = len(tests) - (passed_tests + wrong_answers + runtime_errors + timeouts)
        timeouts += max(skipped_after_timeout, 0)
        passed = passed_tests == len(tests)
        status = "passed" if passed else "timeout" if timeouts else "runtime_error" if runtime_errors else "wrong_answer"
        result(
            passed=passed,
            status=status,
            interface_ok=True,
            passed_tests=passed_tests,
            total_tests=len(tests),
            wrong_answers=wrong_answers,
            runtime_errors=runtime_errors,
            timeouts=timeouts,
        )
    else:
        signal.signal(signal.SIGALRM, timeout_handler)
        passed_tests = 0
        wrong_answers = 0
        runtime_errors = 0
        timeouts = 0
        for idx, test in enumerate(tests):
            old_stdin, old_stdout = sys.stdin, sys.stdout
            fake_out = io.StringIO()
            ns = {"__name__": "__main__"}
            case_failed = False
            try:
                sys.stdin = FakeStdin(test.get("input", ""))
                sys.stdout = fake_out
                try:
                    signal.setitimer(signal.ITIMER_REAL, per_test_timeout)
                    exec(compile(code, "<solution>", "exec"), ns)
                except SystemExit:
                    pass
                except TimeoutError:
                    timeouts += 1
                    case_failed = True
                except Exception:
                    runtime_errors += 1
                    case_failed = True
                finally:
                    signal.setitimer(signal.ITIMER_REAL, 0)
            finally:
                sys.stdin, sys.stdout = old_stdin, old_stdout
            if not case_failed:
                got = fake_out.getvalue()
                expected = test.get("output", "")
                if stdout_equal(got, expected):
                    passed_tests += 1
                else:
                    wrong_answers += 1
            if timeouts >= 3:
                break
        skipped_after_timeout = len(tests) - (passed_tests + wrong_answers + runtime_errors + timeouts)
        timeouts += max(skipped_after_timeout, 0)
        passed = passed_tests == len(tests)
        status = "passed" if passed else "timeout" if timeouts else "runtime_error" if runtime_errors else "wrong_answer"
        result(
            passed=passed,
            status=status,
            interface_ok=True,
            passed_tests=passed_tests,
            total_tests=len(tests),
            wrong_answers=wrong_answers,
            runtime_errors=runtime_errors,
            timeouts=timeouts,
        )
except TimeoutError as exc:
    result(
        passed=False,
        status="timeout",
        interface_ok=True,
        passed_tests=0,
        total_tests=len(tests),
        wrong_answers=0,
        runtime_errors=0,
        timeouts=len(tests),
        error=str(exc)[:300],
    )
except Exception as exc:
    result(
        passed=False,
        status="runtime_error",
        interface_ok=True,
        passed_tests=0,
        total_tests=len(tests),
        wrong_answers=0,
        runtime_errors=len(tests),
        timeouts=0,
        error=str(exc)[:300],
        traceback=traceback.format_exc()[-500:],
    )
'''


def _json_loads_maybe(value: Any) -> Any:
    if isinstance(value, str):
        try:
            return json.loads(value)
        except Exception:
            return {}
    return value if isinstance(value, dict) else {}


def _trim_parseable_code(code: str) -> str:
    # Generated text can contain NUL bytes, which make ast.parse raise
    # ValueError instead of SyntaxError. They are never valid Python source.
    text = code.replace("\x00", "").strip()[:MAX_PARSE_CODE_CHARS]
    if not text:
        return text
    lines = text.splitlines()
    first_end = max(1, len(lines) - MAX_PARSE_TRIM_ATTEMPTS + 1)
    for end in range(len(lines), first_end - 1, -1):
        candidate = "\n".join(lines[:end]).strip()
        if not candidate:
            continue
        try:
            ast.parse(candidate)
            return candidate
        except (SyntaxError, ValueError, MemoryError, RecursionError):
            continue
    return text


def extract_code(text: str, starter_code: str = "") -> str:
    text = text or ""
    fenced = FENCE_RE.findall(text)
    if fenced:
        code = fenced[0].strip()
    else:
        lines = text.splitlines()
        start = None
        for idx, line in enumerate(lines):
            stripped = line.strip()
            if re.match(r"(from\s+\S+\s+import\s+|import\s+\S+|class\s+\w+|def\s+\w+|if\s+__name__)", stripped):
                start = idx
                break
        code = "\n".join(lines[start:]).strip() if start is not None else text.strip()

    starter = (starter_code or "").strip()
    if starter and "class Solution" in code and starter not in code:
        code = starter.rstrip() + "\n\n" + code
    return _trim_parseable_code(code)


def _format_ok(solution_str: str) -> bool:
    text = (solution_str or "").strip()
    if not text:
        return False
    if "```" in text:
        return False
    prose_markers = ["Here is", "Explanation", "```python", "The solution"]
    return not any(marker.lower() in text[:160].lower() for marker in prose_markers)


def _set_eval_limits(memory_limit_gib: float, exec_timeout: float, output_limit_mib: float) -> None:
    memory_bytes = max(1, int(memory_limit_gib * 1024**3))
    output_bytes = max(1, int(output_limit_mib * 1024**2))
    cpu_seconds = max(1, int(exec_timeout) + 1)
    resource.setrlimit(resource.RLIMIT_AS, (memory_bytes, memory_bytes))
    resource.setrlimit(resource.RLIMIT_CPU, (cpu_seconds, cpu_seconds))
    resource.setrlimit(resource.RLIMIT_FSIZE, (output_bytes, output_bytes))
    resource.setrlimit(resource.RLIMIT_NOFILE, (128, 128))
    resource.setrlimit(resource.RLIMIT_NPROC, (256, 256))


def _kill_process_group(proc: subprocess.Popen[str]) -> None:
    try:
        os.killpg(proc.pid, signal.SIGKILL)
    except ProcessLookupError:
        pass


def _run_eval(
    code: str,
    meta: dict[str, Any],
    exec_timeout: float,
    per_test_timeout: float,
    memory_limit_gib: float,
    output_limit_mib: float,
) -> dict[str, Any]:
    payload = {
        "code": code,
        "mode": meta.get("mode"),
        "entry_point": meta.get("entry_point"),
        "tests": meta.get("tests") or [],
        "per_test_timeout": per_test_timeout,
    }
    proc = None
    try:
        with (
            tempfile.TemporaryFile(mode="w+t", encoding="utf-8") as stdout_file,
            tempfile.TemporaryFile(mode="w+t", encoding="utf-8") as stderr_file,
        ):
            proc = subprocess.Popen(
                [sys.executable, "-c", EVAL_HARNESS],
                stdin=subprocess.PIPE,
                stdout=stdout_file,
                stderr=stderr_file,
                text=True,
                start_new_session=True,
                preexec_fn=lambda: _set_eval_limits(memory_limit_gib, exec_timeout, output_limit_mib),
            )
            try:
                proc.communicate(input=json.dumps(payload, ensure_ascii=False), timeout=exec_timeout)
            except subprocess.TimeoutExpired:
                _kill_process_group(proc)
                proc.communicate()
                raise
            _kill_process_group(proc)
            stdout_file.seek(0)
            stdout = stdout_file.read()

        parsed = None
        for line in reversed(stdout.strip().splitlines()):
            candidate = _json_loads_maybe(line)
            if isinstance(candidate, dict) and "passed" in candidate and "total_tests" in candidate:
                parsed = candidate
                break
        if parsed is None:
            return {
                "passed": False,
                "status": "harness_error",
                "interface_ok": False,
                "passed_tests": 0,
                "total_tests": len(payload["tests"]),
                "wrong_answers": 0,
                "runtime_errors": len(payload["tests"]),
                "timeouts": 0,
            }
        return parsed
    except subprocess.TimeoutExpired:
        return {
            "passed": False,
            "status": "timeout",
            "interface_ok": True,
            "passed_tests": 0,
            "total_tests": len(payload["tests"]),
            "wrong_answers": 0,
            "runtime_errors": 0,
            "timeouts": len(payload["tests"]),
        }
    except Exception:
        return {
            "passed": False,
            "status": "eval_error",
            "interface_ok": False,
            "passed_tests": 0,
            "total_tests": len(payload["tests"]),
            "wrong_answers": 0,
            "runtime_errors": len(payload["tests"]),
            "timeouts": 0,
        }


def compute_score(
    data_source: str,
    solution_str: str,
    ground_truth: Any,
    extra_info: dict[str, Any] | None = None,
    exec_timeout: float = 6.0,
    per_test_timeout: float = 2.0,
    memory_limit_gib: float = 2.0,
    output_limit_mib: float = 16.0,
) -> dict[str, float]:
    """Return full-pass bonus or capped partial-credit execution reward."""
    del data_source
    meta = _json_loads_maybe(ground_truth)
    if not meta and extra_info:
        meta = _json_loads_maybe(extra_info)

    tests = meta.get("tests") or []
    format_ok = _format_ok(solution_str)
    try:
        code = extract_code(solution_str, meta.get("starter_code") or "")
        ast.parse(code)
        parse_ok = True
    except (SyntaxError, ValueError, MemoryError, RecursionError):
        code = ""
        parse_ok = False

    if not tests:
        eval_result = {
            "passed": False,
            "status": "no_tests",
            "interface_ok": False,
            "passed_tests": 0,
            "total_tests": 0,
        }
    elif not parse_ok:
        eval_result = {
            "passed": False,
            "status": "syntax_error",
            "interface_ok": False,
            "passed_tests": 0,
            "total_tests": len(tests),
        }
    else:
        try:
            eval_result = _run_eval(
                code,
                meta,
                exec_timeout=exec_timeout,
                per_test_timeout=per_test_timeout,
                memory_limit_gib=memory_limit_gib,
                output_limit_mib=output_limit_mib,
            )
        except (Exception, MemoryError) as exc:
            eval_result = {
                "passed": False,
                "status": "eval_error",
                "interface_ok": False,
                "passed_tests": 0,
                "total_tests": len(tests),
                "error": str(exc)[:300],
            }

    total_tests = int(eval_result.get("total_tests") or len(tests) or 0)
    passed_tests = int(eval_result.get("passed_tests") or 0)
    pass_frac = passed_tests / max(total_tests, 1)
    interface_ok = bool(eval_result.get("interface_ok"))
    passed = bool(eval_result.get("passed"))
    status = str(eval_result.get("status") or "eval_error")

    # A fully correct solution gets 1.0. Any imperfect solution is capped at
    # 0.8 and scaled by its test pass fraction. For example, 70/80 -> 0.7.
    score = 1.0 if total_tests > 0 and passed else 0.8 * pass_frac

    return {
        "score": score,
        "acc": 1.0 if passed else 0.0,
        "format_ok": float(format_ok),
        "parse_ok": float(parse_ok),
        "interface_ok": float(interface_ok),
        "pass_frac": float(pass_frac),
        "passed": 1.0 if passed else 0.0,
        "passed_tests": float(passed_tests),
        "total_tests": float(total_tests),
        "wrong_answers": float(eval_result.get("wrong_answers") or 0),
        "runtime_errors": float(eval_result.get("runtime_errors") or 0),
        "timeouts": float(eval_result.get("timeouts") or 0),
        "status_code": float(STATUS_CODE.get(status, STATUS_CODE["eval_error"])),
    }