"""Reference solutions played as an agent would: write one script, run it, evaluate (3 actions).
Each must score 1 on several fixed instances. Common mistakes must score 0."""

import os
import tempfile

import pytest

os.environ.setdefault("TERMINAL_DESK_APP", tempfile.mkdtemp(prefix="td-solve-"))

from terminal_desk.families import all_task_ids  # noqa: E402
from terminal_desk.models import Tbench2Action  # noqa: E402
from terminal_desk.server.environment import TerminalDeskEnvironment  # noqa: E402

HERE = os.path.join(os.path.dirname(__file__), "solvers")


def solver(family: str) -> str:
    return open(os.path.join(HERE, f"{family}.py")).read()


def play(task_id: str, script: str, extra: list | None = None) -> float:
    env = TerminalDeskEnvironment()
    env.reset(task_id=task_id)
    if "{UEI}" in script:  # values an agent reads from the instruction
        script = script.replace("{UEI}", env._ep["built"].notes["uei"])
    acts = [Tbench2Action(action_type="write_file", file_path="solve.py", content=script),
            Tbench2Action(action_type="exec", command="python3 solve.py")] + (extra or [])
    for act in acts:
        obs = env.step(act)
        assert obs.success, obs.error
    return env.step(Tbench2Action(action_type="evaluate")).reward


@pytest.mark.parametrize("task_id", [f"{t}-i{k}" if k else t for t in all_task_ids() for k in range(4)])
def test_reference_solution_scores_one(task_id):
    family = task_id.split("-L")[0]
    assert play(task_id, solver(family)) == 1.0


MISTAKES = {
    # ignores cancellations
    "ev_backorder": ("cancel = {l.strip() for l in open(\"cancellations.txt\") if l.strip()}", "cancel = set()"),
    # forgets that revoked windows do not count
    "ev_calibration": ('if r["status"] == "active"]', "]"),
    # leaves videos without views out of total_hours as well
    "cmp_channels": ('    s = secs(r["duration"])', '    if not r["views"].strip():\n        continue\n    s = secs(r["duration"])'),
    # sums duplicates instead of keeping the correction
    "cmp_rainfall": ('latest[(r["station"], r["date"])] = float(r["amount"]) * f[r["unit"]]',
                     'latest[(r["station"], r["date"], len(latest))] = float(r["amount"]) * f[r["unit"]]'),
    # keeps the N/A email as a string
    "tx_contacts": ('None if e in ("", "n/a") else e', 'None if e == "" else e'),
    # keeps escaped quotes in msg
    "tx_events": ('re.sub(r"\\\\(.)", r"\\1", m.group(3))', "m.group(3)"),
    # fixes only the crash
    "fix_report": ("src = src.replace('t[\"cost\"] / t[\"shipments\"]', 't[\"cost\"] / t[\"weight\"]')\n", ""),
    # greedy by value per kg
    "plan_load": ("for r in range(len(pool) + 1):", "for r in [len(pool)] if False else range(0):"),
}


# Second batch: one plausible mistake each.
MISTAKES.update({
    "ev_deliveries": ('if r["status"] == "received":', "if True:"),
    "ev_badges": ('        role = roles["inherits"][role]; out |= set(roles["zones"][role])', "        break"),
    "ev_dupes": ('("p", "".join(c for c in r["phone"] if c.isdigit()))', '("p", r["phone"])'),
    "ev_bankrec": ("0 <= (date.fromisoformat(b[\"booked\"]) - ld).days <= 3", "True"),
    "ev_fixedin": ("key < first[iss][0]", "v < first[iss][1]"),
    "cmp_meter": ("(b - a) % 100000", "abs(b - a)"),
    "cmp_grades": ("q = sorted(d[\"q\"])[1:]", "q = d[\"q\"]"),
    "cmp_fifo": ("t * lots[0][1]", "t * lots[-1][1]"),
    "cmp_smooth": ("sorted(v[i - 1:i + 2])[1] > limit", "v[i] > limit"),
    "cmp_loan": ("p = pay if m < n else bal + i", "p = pay"),
    "tx_xml": ('";".join(t.text for t in p.findall("tag"))', '",".join(t.text for t in p.findall("tag"))'),
    "tx_pivot": ('[cells[k].get(m, "") for m in metrics]', '[cells[k].get(m, "0") for m in metrics]'),
    "tx_mdtable": ('.replace("\\\\|", "|")', ""),
    "tx_sessions": ('    if not line.strip(): continue\n', ""),
    "tx_fixedwidth": ('f"{-b if neg else b:.2f}"', 'f"{b:.2f}"'),
    "tx_dates": ('"us_branch": "%m/%d/%Y"', '"us_branch": "%d/%m/%Y"'),
    "fix_paginate": ('s = s.replace("start = number * per_page - per_page + 1", "start = (number - 1) * per_page")\n', ""),
    "fix_logline": ('s = s.replace("(\\\\d+)$", "(\\\\d+|-)$")\n', ""),
    "fix_units": ("s = s.replace(\"LENGTH_M[to_unit]\\n    return value\\n\", 'LENGTH_M[to_unit]\\n    raise ValueError(f\"cannot convert {from_unit} to {to_unit}\")\\n')\n", ""),
    "fix_bizdays": ('.replace("step = 1\\n", "step = 1 if n >= 0 else -1\\n")', ""),
    "fix_dedupe": ('row["email"] = row["email"].strip().lower()', 'row["email"] = row["email"].strip()'),
    "fix_mergelogs": ('.replace("    out += a[i:]\\n", "    out += a[i:]\\n    out += b[j:]\\n")', ""),
    "plan_disks": ("for k in range(1, len(names) + 1):", "for k in range(len(names), len(names) + 1):"),
    "plan_delivery": ("load[d] + int(o[\"weight_kg\"]) > cap[d]", "False"),
    # reports obligated minus posted
    "ev_contracts": ("posted[(a.upper(), mod(m))] - ob", "ob - posted[(a.upper(), mod(m))]"),
})


# Mistakes that only the L2 variants catch (the extra rule is ignored).
MISTAKES_L2 = {
    "ev_backorder/receipts": ('if os.path.exists("receipts.csv"):', "if False:"),
    "ev_backorder/aliases": ('if os.path.exists("sku_aliases.csv") else {}', "if False else {}"),
    "cmp_rainfall/scale": ('if os.path.exists("gauges.csv") else []', "if False else []"),
    "cmp_rainfall/qc": ('if os.path.exists("qc.csv") else set()', "if False else set()"),
}


@pytest.mark.parametrize("family", sorted(MISTAKES))
def test_common_mistake_scores_zero(family):
    old, new = MISTAKES[family]
    src = solver(family)
    assert old in src, family
    bad = src.replace(old, new)
    if family == "plan_load":  # no search: load only the priority items
        bad = bad.replace("best = None", "best = (sum(int(i['value']) for i in must), base, sorted(i['item_id'] for i in must))")
    rewards = [play(f"{family}-L1" + (f"-i{k}" if k else ""), bad) for k in range(4)]
    assert max(rewards) == 0.0, rewards


@pytest.mark.parametrize("name", sorted(MISTAKES_L2))
def test_l2_mistake_scores_zero(name):
    family = name.split("/")[0]
    old, new = MISTAKES_L2[name]
    src = solver(family)
    assert old in src, name
    rewards = [play(f"{family}-L2" + (f"-i{k}" if k else ""), src.replace(old, new)) for k in range(4)]
    assert max(rewards) == 0.0, rewards


def test_unrepaired_report_with_correct_summary_scores_zero():
    """Hand-writing out/summary.json without repairing report.py must fail the hidden-input run."""
    from terminal_desk.core.grading import render_artifact

    env = TerminalDeskEnvironment()
    env.reset(task_id="fix_report-L1")
    art = env._ep["built"].artifact
    env.step(Tbench2Action(action_type="write_file", file_path=art.path, content=render_artifact(art)))
    assert env.step(Tbench2Action(action_type="evaluate")).reward == 0.0


def test_roster_breaking_one_rule_scores_zero():
    env = TerminalDeskEnvironment()
    env.reset(task_id="plan_shifts-L1")
    oracle = env._ep["built"].notes["oracle"]
    rows = [[s, p] for s, ps in oracle.items() for p in ps]
    rows = rows[:-1]  # one shift is now short of its headcount
    content = "shift_id,staff\n" + "".join(f"{s},{p}\n" for s, p in rows)
    env.step(Tbench2Action(action_type="write_file", file_path="roster.csv", content=content))
    assert env.step(Tbench2Action(action_type="evaluate")).reward == 0.0


def test_course_plan_breaking_only_prerequisites_scores_zero():
    """Selecting by every rule except prerequisites must fail. A solver that ignores one rule can
    still land on a valid plan, so this searches for a plan that breaks only that rule."""
    import csv
    import io
    import itertools
    import json
    import re

    checked = 0
    for k in range(4):
        task = "plan_courses-L1" + (f"-i{k}" if k else "")
        env = TerminalDeskEnvironment()
        env.reset(task_id=task)
        f = env._ep["built"].files
        lo, hi = map(int, re.search(r"between (\d+) and (\d+)", f["PLAN_RULES.md"]).groups())
        done = {x.strip() for x in f["transcript.txt"].splitlines()[1:] if x.strip()}
        req = {x.strip() for x in f["required.txt"].splitlines() if x.strip()}
        cs = {r["code"]: r for r in csv.DictReader(io.StringIO(f["courses.csv"]))}
        opts = [c for c, r in cs.items() if c not in done and r["offered"] == "yes"]
        blocked = lambda c: not set(filter(None, cs[c]["prerequisites"].split(";"))) <= done  # noqa: E731
        bad = next((sel for n in range(1, 7) for sel in itertools.combinations(opts, n)
                    if any(blocked(c) for c in sel) and req <= set(sel) and len({cs[c]["slot"] for c in sel}) == n
                    and lo <= sum(int(cs[c]["credits"]) for c in sel) <= hi), None)
        if bad is None:
            continue
        checked += 1
        env.step(Tbench2Action(action_type="write_file", file_path="plan.json", content=json.dumps({"courses": list(bad)})))
        assert env.step(Tbench2Action(action_type="evaluate")).reward == 0.0
    assert checked >= 2