import ast
import hashlib
import json
import math
import subprocess
import sys
from dataclasses import dataclass
from pathlib import Path


APP = Path("/app")
ROOT = APP / "vendor/transformers"
TOOLS = ROOT / "tools"
OUT = APP / "output.json"
FIXTURE = json.loads(Path("/tests/fixtures/cases.json").read_text())
sys.path.insert(0, str(TOOLS))
from tensor_runtime import nn, tensor, torch


def sha256(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def load_smoother():
    path = ROOT / "src/transformers/trainer_pt_utils.py"
    tree = ast.parse(path.read_text())
    node = next(item for item in tree.body if isinstance(item, ast.ClassDef) and item.name == "LabelSmoother")
    module = ast.fix_missing_locations(ast.Module(body=[node], type_ignores=[]))
    namespace = {"torch": torch, "nn": nn, "dataclass": dataclass}
    exec(compile(module, str(path), "exec"), namespace)
    return namespace["LabelSmoother"](epsilon=FIXTURE["epsilon"])


def log_probs(row):
    peak = max(row)
    denominator = peak + math.log(sum(math.exp(value - peak) for value in row))
    return [denominator - value for value in row]


def independent(logits, labels, denominator=None, shift=False):
    if shift:
        logits = [rows[:-1] for rows in logits]
        labels = [row[1:] for row in labels]
    nll = 0.0
    smooth = 0.0
    active = 0
    vocabulary = len(logits[0][0])
    for batch_rows, batch_labels in zip(logits, labels):
        for row, label in zip(batch_rows, batch_labels):
            if label == -100:
                continue
            losses = log_probs(row)
            nll += losses[label]
            smooth += sum(losses)
            active += 1
    count = active if denominator is None else denominator
    epsilon = FIXTURE["epsilon"]
    return (1 - epsilon) * nll / count + epsilon * smooth / (count * vocabulary)


def objective(logits):
    return independent(logits, FIXTURE["labels"], 3) + independent(logits, FIXTURE["causal_labels"], 3, True)


def expected_update():
    flat = [value for batch in FIXTURE["logits"] for row in batch for value in row]
    step = 1e-6
    gradients = []
    for index in range(len(flat)):
        plus = flat.copy()
        minus = flat.copy()
        plus[index] += step
        minus[index] -= step
        plus_logits = [[plus[:4], plus[4:8], plus[8:12]], [plus[12:16], plus[16:20], plus[20:24]]]
        minus_logits = [[minus[:4], minus[4:8], minus[8:12]], [minus[12:16], minus[16:20], minus[20:24]]]
        gradients.append((objective(plus_logits) - objective(minus_logits)) / (2 * step))
    updated = [value - FIXTURE["learning_rate"] * gradient for value, gradient in zip(flat, gradients)]
    return sum(abs(value) for value in gradients), sum(updated)


def test_gate_artifact_schema_and_finiteness():
    assert OUT.is_file()
    data = json.loads(OUT.read_text())
    assert set(data) == set(FIXTURE["artifact_fields"])
    assert data["output_schema_version"] == "effective_batch.v1"
    assert data["finite"] is True and data["active_items"] == 3
    assert data["trainer_forwards_count"] is True
    for relative_path, expected_hash in FIXTURE["protected_sha256"].items():
        protected = ROOT / relative_path
        assert protected.is_file()
        assert sha256(protected) == expected_hash


def test_core_effective_batch_independent_recompute():
    logits = tensor(FIXTURE["logits"])
    labels = tensor(FIXTURE["labels"])
    smoother = load_smoother()
    actual = sum(
        smoother({"logits": logits[index : index + 1]}, labels[index : index + 1], num_items_in_batch=3)
        for index in range(2)
    )
    expected = independent(FIXTURE["logits"], FIXTURE["labels"], 3)
    assert abs(float(actual) - expected) < 1e-9
    assert abs(json.loads(OUT.read_text())["loss"] - expected) < 1e-9


def test_core_training_update_independent_recompute():
    expected_gradient, expected_checksum = expected_update()
    data = json.loads(OUT.read_text())
    assert math.isfinite(data["gradient_l1"]) and data["gradient_l1"] > 0
    assert abs(data["gradient_l1"] - expected_gradient) < 1e-7
    assert abs(data["parameter_checksum"] - expected_checksum) < 1e-7
    assert abs(data["total_loss"] - objective(FIXTURE["logits"])) < 1e-9


def test_edge_fallback_and_ignored_labels():
    logits = tensor(FIXTURE["logits"][:1])
    labels = tensor(FIXTURE["labels"][:1])
    actual = float(load_smoother()({"logits": logits}, labels))
    expected = independent(FIXTURE["logits"][:1], FIXTURE["labels"][:1])
    assert abs(actual - expected) < 1e-9
    assert abs(json.loads(OUT.read_text())["fallback_loss"] - expected) < 1e-9


def test_edge_causal_shift_and_trainer_propagation():
    logits = tensor(FIXTURE["logits"])
    labels = tensor(FIXTURE["causal_labels"])
    smoother = load_smoother()
    actual = sum(
        smoother(
            {"logits": logits[index : index + 1]},
            labels[index : index + 1],
            shift_labels=True,
            num_items_in_batch=3,
        )
        for index in range(2)
    )
    expected = independent(FIXTURE["logits"], FIXTURE["causal_labels"], 3, True)
    assert abs(float(actual) - expected) < 1e-9
    trainer_tree = ast.parse((ROOT / "src/transformers/trainer.py").read_text())
    calls = [
        node
        for node in ast.walk(trainer_tree)
        if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == "label_smoother"
    ]
    assert sum(any(keyword.arg == "num_items_in_batch" for keyword in call.keywords) for call in calls) >= 2


def test_edge_deterministic_artifact_matches_reexecution():
    target = Path("/tmp/recomputed.json")
    result = subprocess.run(
        ["python3", str(ROOT / "tools/effective_batch_case.py"), "--output", str(target)],
        capture_output=True,
        text=True,
        timeout=30,
    )
    assert result.returncode == 0, result.stderr
    assert json.loads(target.read_text()) == json.loads(OUT.read_text())