from __future__ import annotations
import os, resource, shutil, signal, subprocess, sys, tempfile, time
from pathlib import Path
from dataclasses import dataclass

@dataclass(frozen=True)
class TestCase:
    input: str
    expected: str
    test_id: str

@dataclass(frozen=True)
class TestResult:
    test_id: str
    status: str
    actual: str
    expected: str
    stderr: str
    seconds: float

@dataclass(frozen=True)
class Execution:
    results: tuple[TestResult, ...]
    wall_seconds: float

    @property
    def all_pass(self) -> bool:
        return bool(self.results) and all((r.status == 'AC' for r in self.results))

    @property
    def pass_fraction(self) -> float:
        return sum((r.status == 'AC' for r in self.results)) / len(self.results) if self.results else 0.0

@dataclass(frozen=True)
class Candidate:
    candidate_id: str
    code: str

def _limits():
    if sys.platform != 'linux':
        return
    resource.setrlimit(resource.RLIMIT_CPU, (10, 11))
    resource.setrlimit(resource.RLIMIT_AS, (1024 ** 3, 1024 ** 3))
    resource.setrlimit(resource.RLIMIT_FSIZE, (1024 ** 2, 1024 ** 2))
    resource.setrlimit(resource.RLIMIT_NOFILE, (64, 64))

def _run_one(script: Path, test: TestCase, timeout: float, sandbox: str) -> TestResult:
    started = time.monotonic()
    if sandbox == 'required':
        if not shutil.which('runuser') or not shutil.which('unshare'):
            raise RuntimeError('Required runuser/unshare sandbox is unavailable')
        interpreter = os.environ.get('RSI_SANDBOX_PYTHON', '/usr/bin/python3')
        if not os.path.isfile(interpreter) or not os.access(interpreter, os.X_OK):
            raise RuntimeError(f'Sandbox Python interpreter is unavailable: {interpreter}')
        cmd = [shutil.which('runuser'), '-u', 'nobody', '--', shutil.which('unshare'), '-Urn', '--', interpreter, '-I', str(script)]
    elif sandbox == 'local_test':
        cmd = [sys.executable, '-I', str(script)]
    else:
        raise ValueError(f'unknown sandbox: {sandbox}')
    env = {'PATH': '/usr/bin:/bin', 'PYTHONIOENCODING': 'utf-8', 'PYTHONDONTWRITEBYTECODE': '1'}
    proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, start_new_session=True, preexec_fn=_limits, env=env)
    try:
        stdout, stderr = proc.communicate(test.input, timeout=timeout)
    except subprocess.TimeoutExpired:
        os.killpg(proc.pid, signal.SIGKILL)
        proc.communicate()
        return TestResult(test.test_id, 'TLE', '', test.expected, 'timeout', time.monotonic() - started)
    elapsed = time.monotonic() - started
    if proc.returncode:
        return TestResult(test.test_id, 'RE', stdout[-1024:], test.expected, stderr[-2048:], elapsed)
    status = 'AC' if stdout.strip() == test.expected.strip() else 'WA'
    return TestResult(test.test_id, status, stdout[-1024:], test.expected, stderr[-2048:], elapsed)

def execute(code: str, tests: tuple[TestCase, ...], *, timeout: float=3.0, sandbox: str='required') -> Execution:
    started = time.monotonic()
    if not tests:
        raise ValueError('Cannot execute an empty test suite')
    if not code.strip():
        results = tuple((TestResult(t.test_id, 'CE', '', t.expected, 'Empty candidate program', 0.0) for t in tests))
        return Execution(results, time.monotonic() - started)
    try:
        compile(code, 'candidate.py', 'exec')
    except SyntaxError as exc:
        msg = f'{type(exc).__name__}: {exc.msg} (line {exc.lineno})'
        results = tuple((TestResult(t.test_id, 'CE', '', t.expected, msg, 0.0) for t in tests))
        return Execution(results, time.monotonic() - started)
    with tempfile.TemporaryDirectory(prefix='cure_wm_') as tmp:
        tmp_dir = Path(tmp)
        tmp_dir.chmod(493)
        script = tmp_dir / 'candidate.py'
        script.write_text(code, encoding='utf-8')
        script.chmod(420)
        results = tuple((_run_one(script, test, timeout, sandbox) for test in tests))
    return Execution(results, time.monotonic() - started)