"""Generator configuration.

One frozen dataclass holds every knob: which levels of the experimental design to generate, how
many replicates per cell, the physical model constants and the potential-field parameters.
``scripts/run_local_sweep.py`` turns each field into a command-line flag, and the resolved
configuration is written next to the data as ``data/config.json`` so that any episode can be
re-created bit for bit from ``(config, episode_id)``.
"""
from __future__ import annotations

import json
from dataclasses import asdict, dataclass, field, fields
from pathlib import Path
from typing import List

from . import design

DATASET_VERSION = "2.0"
ROUTERS = ("potential", "potential_split", "potential_static",
           "shortest_path", "ecmp", "adaptive_shortest_path")


def _f(default, help_text):
    return field(default=default, metadata={"help": help_text})


@dataclass(frozen=True)
class SimConfig:
    # Experimental design (see src/design.py for the level definitions)
    replicates: int = _f(10, "episodes per design cell; episodes = replicates x cells")
    topologies: tuple = _f(design.TOPOLOGIES, "topology families to include")
    sizes: tuple = _f(design.SIZES, "nominal network sizes to include")
    traffic_profiles: tuple = _f(tuple(design.TRAFFIC_PROFILES), "traffic profiles to include")
    load_levels: tuple = _f(tuple(design.LOAD_LEVELS), "load levels to include")
    dynamics_levels: tuple = _f(tuple(design.DYNAMICS_LEVELS), "topology-dynamics levels to include")
    routers: tuple = _f(ROUTERS, "routers replayed on identical traffic and events")

    # Sweep
    seed: int = _f(2026, "base seed; episode e draws from numpy default_rng([seed, e])")
    shard_episodes: int = _f(40, "episodes per Parquet shard (one shard = one resumable unit)")
    field_budget_bytes: int = _f(1_000_000, "potential field of the tracked flows is logged every k steps to stay within this budget")

    # Physical model
    steps: int = _f(1000, "simulated steps per episode (1 step = 1 ms)")
    buffer_size: int = _f(256, "per-node drop-tail buffer in packets (< 32768)")
    mean_degree: int = _f(6, "target mean degree of the random-graph families")
    capacity_range: tuple = _f((8, 80), "link capacity in packets/step for random graphs (1 pkt/step ~ 12 Mbps)")
    latency_range: tuple = _f((1, 10), "link propagation delay in steps for random graphs")
    fat_tree_capacity: int = _f(40, "fat-tree fabric link capacity, packets/step (host links carry twice this)")
    flows_per_endpoint: int = _f(2, "flows per endpoint node; sources and sinks are distinct ordered pairs")
    tracked_flows: int = _f(8, "flows per episode with step-level telemetry and stored potential field")

    # Potential field  L_g phi = b  with  b = source + background/(N-1) + gain * queue/buffer
    source_injection: float = _f(1.0, "unit injection at a flow's source")
    background_injection: float = _f(0.5, "total background injection spread over all non-sink nodes")
    congestion_gain: float = _f(2.0, "repulsive injection of a full buffer (alpha)")

    def __post_init__(self):
        for f in fields(self):  # JSON round-trips turn tuples into lists
            if isinstance(f.default, tuple):
                object.__setattr__(self, f.name, tuple(getattr(self, f.name)))
        for name, allowed in (("topologies", design.TOPOLOGIES), ("sizes", design.SIZES),
                              ("traffic_profiles", design.TRAFFIC_PROFILES), ("load_levels", design.LOAD_LEVELS),
                              ("dynamics_levels", design.DYNAMICS_LEVELS), ("routers", ROUTERS)):
            chosen = getattr(self, name)
            if not chosen or set(chosen) - set(allowed):
                raise ValueError(f"{name} must be a non-empty subset of {tuple(allowed)}, got {chosen}")
        if self.replicates < 1:
            raise ValueError("replicates must be at least 1")
        if not 0 < self.buffer_size < 32768:
            raise ValueError("buffer_size must fit in an int16 telemetry column (< 32768)")
        if self.flows_per_endpoint < 1 or self.tracked_flows < 1:
            raise ValueError("flows_per_endpoint and tracked_flows must be positive")
        if self.mean_degree < 2:
            raise ValueError("mean_degree must be at least 2")
        for name in ("capacity_range", "latency_range"):
            lo, hi = getattr(self, name)
            if not 0 < lo <= hi:
                raise ValueError(f"{name} must satisfy 0 < low <= high, got {(lo, hi)}")
        if self.background_injection <= 0:
            raise ValueError("background_injection must be positive: it guarantees loop-free descent")

    @property
    def cells(self) -> List[design.Cell]:
        return design.cells(self.topologies, self.sizes, self.traffic_profiles, self.load_levels, self.dynamics_levels)

    @property
    def episodes(self) -> int:
        return self.replicates * len(self.cells)

    def to_json(self) -> str:
        return json.dumps(asdict(self), indent=2)

    def save(self, path: Path) -> None:
        path.write_text(self.to_json(), encoding="utf-8")

    @classmethod
    def load(cls, path: Path) -> "SimConfig":
        return cls(**json.loads(path.read_text(encoding="utf-8")))

    def __eq__(self, other) -> bool:  # tuples vs. JSON lists compare equal
        return isinstance(other, SimConfig) and self.to_json() == other.to_json()