from __future__ import annotations

import itertools
import random
from dataclasses import dataclass
from typing import Any

from .models import BenchCase
from .tokenizer import TokenizerProtocol
from .util import sha256_json


SYSTEM_PROMPT = (
    "You are running a deterministic long-context evaluation. Read the complete "
    "context, ignore stale or decoy records, and return only the requested bare JSON."
)


@dataclass(frozen=True)
class ContextSpec:
    suite_id: str
    matrix: str
    family: str
    target_tokens: int
    position: float
    seed: int
    query_placement: str = "after"

    @property
    def case_id(self) -> str:
        position = f"p{round(self.position * 100):02d}"
        return (
            f"{self.matrix}__{self.family}__t{self.target_tokens}__{position}"
            f"__s{self.seed}__q{self.query_placement}"
        )


def expand_context_config(config: dict[str, Any]) -> list[ContextSpec]:
    suite_id = str(config["suite_id"])
    context_window = int(config.get("context_window") or 0)
    reserved_output = int(config.get("reserved_output_tokens") or 0)
    maximum_prompt = context_window - reserved_output if context_window and reserved_output else None
    specs: list[ContextSpec] = []
    for matrix in config["matrices"]:
        values = itertools.product(
            matrix["families"],
            matrix["lengths"],
            matrix["positions"],
            matrix["seeds"],
            matrix.get("query_placements", ["after"]),
        )
        for family, length, position, seed, placement in values:
            if not 0 < float(position) < 1:
                raise ValueError(f"Position must be between zero and one: {position}")
            if placement not in {"before", "after"}:
                raise ValueError(f"Unsupported query placement: {placement}")
            if maximum_prompt is not None and int(length) > maximum_prompt:
                raise ValueError(
                    f"Prompt length {length} exceeds context-minus-output budget {maximum_prompt}"
                )
            specs.append(
                ContextSpec(
                    suite_id=suite_id,
                    matrix=str(matrix["name"]),
                    family=str(family),
                    target_tokens=int(length),
                    position=float(position),
                    seed=int(seed),
                    query_placement=str(placement),
                )
            )
    identifiers = [item.case_id for item in specs]
    if len(identifiers) != len(set(identifiers)):
        raise ValueError("Context configuration produces duplicate case identifiers")
    return specs


def _secret(seed: int, label: str) -> str:
    rng = random.Random(f"{seed}:{label}")
    left = ["amber", "cedar", "indigo", "marble", "opal", "quartz", "saffron"]
    right = ["falcon", "harbor", "lighthouse", "otter", "raven", "willow"]
    return f"{rng.choice(left)}-{rng.randrange(100000, 999999)}-{rng.choice(right)}"


def _task_payload(spec: ContextSpec) -> tuple[list[tuple[float, str, str]], str, dict[str, Any]]:
    target = _secret(spec.seed, spec.family)
    decoy_a = _secret(spec.seed + 101, "decoy-a")
    decoy_b = _secret(spec.seed + 202, "decoy-b")
    marker = f"<<SX_PRIMARY_{spec.seed}_{spec.family.upper()}>>"
    common: dict[str, Any] = {"record": target}
    insertions: list[tuple[float, str, str]] = [
        (0.08, "decoy-a", f"STALE RECORD record={decoy_a} status=revoked revision=2"),
        (0.92, "decoy-b", f"DECOY RECORD record={decoy_b} status=simulation revision=99"),
    ]

    if spec.family == "single_key":
        primary = f"{marker} CANONICAL RECORD record={target} status=active"
        query = "Return the active canonical record."
    elif spec.family == "binding":
        key = f"device-{(spec.seed % 83) + 10}"
        primary = (
            f"{marker} AUTHORITATIVE BINDING device={key} record={target} "
            "status=active; similar device identifiers are unrelated."
        )
        common["device"] = key
        query = f"Return the active record bound specifically to device {key}."
    elif spec.family == "latest_record":
        primary = f"{marker} CHANGELOG record={target} revision=12 state=current"
        insertions.extend(
            [
                (0.19, "older", f"CHANGELOG record={decoy_a} revision=10 state=superseded"),
                (0.77, "newer-decoy", f"CHANGELOG record={decoy_b} revision=13 state=test-only"),
            ]
        )
        common["revision"] = 12
        query = "Return the highest production revision marked current, excluding test-only entries."
    elif spec.family == "multi_hop":
        relay = f"relay-{(spec.seed % 71) + 20}"
        zone = ["north", "south", "east", "west"][spec.seed % 4]
        primary = f"{marker} ROUTE MAP record={target} uses_relay={relay}"
        insertions.append(
            (1.0 - spec.position, "hop-two", f"RELAY DIRECTORY relay={relay} final_zone={zone}"),
        )
        common.update({"relay": relay, "zone": zone})
        query = "Follow the route map through the relay directory and return record, relay, and final zone."
    elif spec.family == "semantic":
        callsign = f"unit-{(spec.seed % 89) + 10}"
        primary = (
            f"{marker} The only solar-powered courier approved for silent night delivery "
            f"has registry value {target} and operational callsign {callsign}."
        )
        common["callsign"] = callsign
        query = (
            "Identify the registry value and callsign of the emission-free messenger "
            "authorized to work after dark."
        )
    elif spec.family == "state_tracking":
        counter = 10 + spec.seed % 7
        add_a = 3 + spec.seed % 5
        subtract = 1 + spec.seed % 3
        final = counter + add_a - subtract
        primary = f"{marker} STATE stream={target} value={counter} sequence=1"
        insertions.extend(
            [
                (min(0.95, spec.position + 0.18), "update-a", f"UPDATE stream={target} add={add_a} sequence=2"),
                (min(0.98, spec.position + 0.34), "update-b", f"UPDATE stream={target} subtract={subtract} sequence=3"),
            ]
        )
        common["final_value"] = final
        query = "Apply the ordered updates and return the stream record and final value."
    else:
        raise ValueError(f"Unknown context family: {spec.family}")

    primary_end_marker = f"<<SX_PRIMARY_END_{spec.seed}_{spec.family.upper()}>>"
    insertions.append((spec.position, "primary", primary + " " + primary_end_marker))
    return sorted(insertions, key=lambda item: (item[0], item[1])), query, common


def _filler_pool(tokenizer: TokenizerProtocol, seed: int) -> list[int]:
    rng = random.Random(seed)
    services = ["atlas", "beacon", "cinder", "delta", "ember", "fjord", "garnet", "helios"]
    states = ["nominal", "queued", "retrying", "stable", "verified", "warming"]
    regions = ["north-ridge", "west-field", "central-bay", "east-grove"]
    lines = []
    for index in range(5000):
        service = rng.choice(services)
        state = rng.choice(states)
        region = rng.choice(regions)
        trace = f"{rng.getrandbits(48):012x}"
        lines.append(
            f"event {index:05d}: service={service} region={region} state={state} "
            f"latency_ms={rng.randrange(3, 997)} trace={trace}; routine telemetry only."
        )
    token_ids = tokenizer.encode("\n" + "\n".join(lines) + "\n")
    if len(token_ids) < 1000:
        raise ValueError("Tokenizer produced an unexpectedly small filler pool")
    return token_ids


def _take(pool: list[int], count: int, offset: int) -> list[int]:
    if count <= 0:
        return []
    start = offset % len(pool)
    rotated = pool[start:] + pool[:start]
    repeats, remainder = divmod(count, len(rotated))
    return rotated * repeats + rotated[:remainder]


def _allocate_filler(total: int, insertion_positions: list[float]) -> list[int]:
    gaps = []
    previous = 0.0
    for position in insertion_positions:
        gaps.append(max(0.0, position - previous))
        previous = position
    gaps.append(max(0.0, 1.0 - previous))
    raw = [total * gap for gap in gaps]
    values = [int(value) for value in raw]
    for index in sorted(range(len(raw)), key=lambda item: raw[item] - values[item], reverse=True):
        if sum(values) >= total:
            break
        values[index] += 1
    return values


def build_context_case(spec: ContextSpec, tokenizer: TokenizerProtocol) -> BenchCase:
    insertions, query, expected = _task_payload(spec)
    start_sentinel = f"SX_START_{spec.seed}_{spec.family}"
    end_sentinel = f"SX_END_{spec.seed}_{spec.family}"
    expected = {"start_sentinel": start_sentinel, **expected, "end_sentinel": end_sentinel}
    keys = ", ".join(expected)
    query_text = f"{query} Return exactly one JSON object with keys: {keys}."
    prefix_query = query_text + "\n\n" if spec.query_placement == "before" else ""
    suffix_query = "\n\n" + query_text if spec.query_placement == "after" else ""

    fixed_user = (
        prefix_query
        + f"BEGIN CONTEXT\nSTART SENTINEL: {start_sentinel}\n"
        + "\n".join(text for _, _, text in insertions)
        + f"\nEND SENTINEL: {end_sentinel}\nEND CONTEXT"
        + suffix_query
    )
    fixed_messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": fixed_user},
    ]
    fixed_tokens = len(tokenizer.encode(tokenizer.render_chat(fixed_messages)))
    available = spec.target_tokens - fixed_tokens
    if available < 512:
        raise ValueError(
            f"Target {spec.target_tokens} is too small for {spec.family}; only {available} filler tokens remain"
        )

    pool = _filler_pool(tokenizer, spec.seed)
    allocations = _allocate_filler(available, [item[0] for item in insertions])
    segments = [_take(pool, size, spec.seed * 97 + index * 7919) for index, size in enumerate(allocations)]
    primary_index = next(index for index, item in enumerate(insertions) if item[1] == "primary")
    primary_marker = insertions[primary_index][2].split(" ", 1)[0]
    primary_end_marker = f"<<SX_PRIMARY_END_{spec.seed}_{spec.family.upper()}>>"

    def make_messages() -> list[dict[str, Any]]:
        context_parts = [f"START SENTINEL: {start_sentinel}\n"]
        for index, (_, _, insertion) in enumerate(insertions):
            context_parts.append(tokenizer.decode(segments[index]))
            context_parts.append("\n" + insertion + "\n")
        context_parts.append(tokenizer.decode(segments[-1]))
        context_parts.append(f"\nEND SENTINEL: {end_sentinel}")
        user = prefix_query + "BEGIN CONTEXT\n" + "".join(context_parts) + "\nEND CONTEXT" + suffix_query
        return [
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user},
        ]

    diagnostics: list[tuple[int, int, int]] = []
    for iteration in range(24):
        messages = make_messages()
        rendered = tokenizer.render_chat(messages)
        actual_total = len(tokenizer.encode(rendered))
        total_delta = spec.target_tokens - actual_total
        primary_start = tokenizer.token_offset(rendered, primary_marker)
        primary_end = tokenizer.token_offset(rendered, primary_end_marker)
        actual_offset = round((primary_start + primary_end) / 2)
        context_start = tokenizer.token_offset(rendered, "START SENTINEL:")
        context_end = tokenizer.token_offset(rendered, "END SENTINEL:")
        diagnostics.append((actual_total, actual_offset, total_delta))
        if total_delta:
            if total_delta > 0:
                segments[-1].extend(_take(pool, total_delta, spec.seed + iteration * 3571))
            else:
                remaining = -total_delta
                for segment in reversed(segments):
                    removed = min(remaining, len(segment))
                    if removed:
                        del segment[-removed:]
                        remaining -= removed
                    if remaining == 0:
                        break
                if remaining:
                    raise ValueError("Unable to trim context to requested token count")
            continue

        desired_offset = context_start + round((context_end - context_start) * spec.position)
        position_delta = desired_offset - actual_offset
        tolerance = max(4, round(spec.target_tokens * 0.0025))
        if abs(position_delta) <= tolerance:
            break
        before = segments[primary_index]
        after = segments[primary_index + 1]
        if position_delta > 0:
            movement = min(position_delta, len(after))
            before.extend(_take(pool, movement, spec.seed + iteration * 1237))
            del after[:movement]
        else:
            movement = min(-position_delta, len(before))
            del before[-movement:]
            after[:0] = _take(pool, movement, spec.seed + iteration * 1237)
    else:
        raise RuntimeError(
            f"Exact context construction did not converge for {spec.case_id}; "
            f"last iterations={diagnostics[-6:]}"
        )

    messages = make_messages()
    rendered = tokenizer.render_chat(messages)
    actual_total = len(tokenizer.encode(rendered))
    primary_start = tokenizer.token_offset(rendered, primary_marker)
    primary_end = tokenizer.token_offset(rendered, primary_end_marker)
    actual_offset = round((primary_start + primary_end) / 2)
    context_start = tokenizer.token_offset(rendered, "START SENTINEL:")
    context_end = tokenizer.token_offset(rendered, "END SENTINEL:")
    if actual_total != spec.target_tokens:
        raise AssertionError(f"Requested {spec.target_tokens} rendered tokens, produced {actual_total}")
    actual_position = (actual_offset - context_start) / (context_end - context_start)
    metadata = {
        "matrix": spec.matrix,
        "family": spec.family,
        "seed": spec.seed,
        "target_prompt_tokens": spec.target_tokens,
        "actual_rendered_tokens": actual_total,
        "requested_position": spec.position,
        "actual_primary_token_offset": actual_offset,
        "actual_primary_start_token_offset": primary_start,
        "actual_primary_end_token_offset": primary_end,
        "actual_primary_position": actual_position,
        "context_start_token_offset": context_start,
        "context_end_token_offset": context_end,
        "query_placement": spec.query_placement,
        "tokenizer_fingerprint": tokenizer.fingerprint,
        "prompt_hash": sha256_json(messages),
        "truncation_sentinels": [start_sentinel, end_sentinel],
    }
    return BenchCase(
        case_id=spec.case_id,
        suite_id=spec.suite_id,
        lane="long-context",
        messages=messages,
        scorer="strict_json_exact",
        expected=expected,
        max_output_tokens=2048,
        metadata=metadata,
    )