"""Read access to a generated dataset.

``Dataset`` opens a data folder (or any folder of shards) and returns tables as pandas
DataFrames; ``Episode`` bundles everything about one episode — the static graph, its event
timeline, the flows, the telemetry of any router — and rebuilds the physical state at any step:
the live graph with the capacities in force and the potential field of any flow, recomputed
exactly with the same engine that generated the data. The example scripts are written against
this API.
"""
from __future__ import annotations

import json
from functools import cached_property
from pathlib import Path
from typing import Dict, List, Optional, Sequence

import numpy as np
import pandas as pd

from .config import SimConfig
from .graph_generator import Topology, TopologyEvent, effective_capacity
from .physics_engine import LiveGraph, PotentialField, currents, live_graph, steepest_next_hops
from .telemetry_logger import read_table, shard_files, table_names

FACTORS = ("topology", "size", "traffic_profile", "load_level", "dynamics_level")


class Dataset:
    def __init__(self, path):
        self.path = Path(path)
        self.config = SimConfig.load(self.path / "config.json")
        manifest = self.path / "manifest.json"
        self.manifest: Optional[Dict] = json.loads(manifest.read_text(encoding="utf-8")) if manifest.exists() else None

    @property
    def tables(self) -> List[str]:
        return [t for t in table_names(self.config.routers) if shard_files(self.path, t)]

    @property
    def routers(self) -> Sequence[str]:
        return self.config.routers

    def table(self, name: str, columns=None, filters=None) -> pd.DataFrame:
        return read_table(self.path, name, columns=columns, filters=filters).to_pandas()

    @cached_property
    def episodes(self) -> pd.DataFrame:
        """The ``episodes`` table indexed by ``episode_id`` (list columns included)."""
        return self.table("episodes").set_index("episode_id").sort_index()

    def summary(self, name: str = "router_summary") -> pd.DataFrame:
        """A summary table joined with the design factors and the split of its episode."""
        keys = list(FACTORS) + ["split", "replicate", "n_nodes", "n_flows", "total_capacity"]
        return self.table(name).join(self.episodes[keys], on="episode_id")

    def episode(self, episode_id: int) -> "Episode":
        return Episode(self, int(episode_id))


class Episode:
    def __init__(self, dataset: Dataset, episode_id: int):
        self.dataset = dataset
        self.id = episode_id
        self.row = dataset.episodes.loc[episode_id]
        self.config = dataset.config
        self.events = dataset.table("events", filters=[("episode_id", "=", episode_id)]).sort_values("start")
        self.n_nodes, self.n_edges = int(self.row.n_nodes), int(self.row.n_edges)
        self.n_flows, self.tracked_flows = int(self.row.n_flows), int(self.row.tracked_flows)
        self.steps, self.field_stride = int(self.row.steps), int(self.row.field_stride)
        self.edges = np.stack([self.row.edge_u, self.row.edge_v], 1).astype(np.int16)
        self.capacity = np.asarray(self.row.capacity, np.int16)
        self.latency = np.asarray(self.row.latency, np.int16)
        self.node_role = np.asarray(self.row.node_role, np.int8)
        self.node_xy = (np.stack([self.row.node_x, self.row.node_y], 1).astype(np.float32)
                        if len(self.row.node_x) else np.zeros((0, 2), np.float32))
        self.source = np.asarray(self.row.flow_source, np.int16)
        self.sink = np.asarray(self.row.flow_sink, np.int16)

    def __repr__(self) -> str:
        cell = "/".join(str(self.row[f]) for f in FACTORS)
        return (f"Episode {self.id} [{cell}] {self.n_nodes} nodes, {self.n_edges} links, "
                f"{self.n_flows} flows, {self.steps} steps, split={self.row.split}")

    @property
    def cell(self) -> Dict[str, object]:
        return {f: self.row[f] for f in FACTORS}

    @cached_property
    def topology(self) -> Topology:
        return Topology(self.n_nodes, self.edges, self.capacity, self.latency,
                        np.flatnonzero(self.node_role == self.node_role.max()).astype(np.int16)
                        if self.node_role.max() > 0 else np.arange(self.n_nodes, dtype=np.int16),
                        self.node_role, self.node_xy)

    @cached_property
    def timeline(self) -> List[TopologyEvent]:
        """The event table as generator objects (link failures resolved to edge indices)."""
        edge_index = {(int(u), int(v)): i for i, (u, v) in enumerate(self.edges)}
        return [TopologyEvent(e.kind, int(e.start), int(e.end),
                              edge=edge_index[(int(e.edge_u), int(e.edge_v))] if e.kind == "link_failure" else -1,
                              node=int(e.node), factor=float(e.factor))
                for e in self.events.itertuples()]

    @cached_property
    def change_steps(self) -> List[int]:
        steps = {0} | {e.start for e in self.timeline} | {e.end for e in self.timeline if e.end < self.steps}
        return sorted(steps)

    def capacity_at(self, step: int) -> np.ndarray:
        """Effective capacity of every link at `step` (0 while failed)."""
        return effective_capacity(self.topology, self.timeline, step)

    def live_graph(self, step: int = 0) -> LiveGraph:
        return live_graph(self.n_nodes, self.edges, self.capacity_at(step), self.latency)

    def capacity_matrix(self, step: int) -> np.ndarray:
        """Dense symmetric N × N matrix of the capacities in force at `step` (the graph state)."""
        cap = self.capacity_at(step)
        matrix = np.zeros((self.n_nodes, self.n_nodes), np.int32)
        matrix[self.edges[:, 0], self.edges[:, 1]] = cap
        matrix[self.edges[:, 1], self.edges[:, 0]] = cap
        return matrix

    def telemetry(self, table: str, router: Optional[str] = None, columns=None) -> pd.DataFrame:
        """Rows of a telemetry table for this episode (and router), sorted by step."""
        filters = [("episode_id", "=", self.id)] + ([("router", "=", router)] if router else [])
        frame = self.dataset.table(table, columns=columns, filters=filters)
        keys = [c for c in ("router", "step", "flow") if c in frame.columns]
        return frame.sort_values(keys).reset_index(drop=True)

    def queue_depth(self, router: str) -> np.ndarray:
        """(steps, n_nodes) buffer occupancy after admission, before forwarding."""
        return np.stack(self.telemetry("network_telemetry", router, ["episode_id", "router", "step", "queue_depth"]).queue_depth)

    def node_dropped(self, router: str) -> np.ndarray:
        return np.stack(self.telemetry("network_telemetry", router, ["episode_id", "router", "step", "node_dropped"]).node_dropped)

    def link_load(self, router: str) -> np.ndarray:
        """(steps, n_edges, 2) packets forwarded per link and direction (u→v, v→u)."""
        frame = self.telemetry("link_telemetry", router)
        return np.stack([np.stack(frame.load_uv), np.stack(frame.load_vu)], axis=2)

    def link_utilisation(self, router: str) -> np.ndarray:
        """(steps, n_edges, 2) load divided by the capacity in force; NaN while a link is failed."""
        load = self.link_load(router).astype(np.float64)
        bounds = np.zeros((self.steps, self.n_edges), np.float64)
        for start, end in zip(self.change_steps, self.change_steps[1:] + [self.steps]):
            bounds[start:end] = self.capacity_at(start)
        with np.errstate(invalid="ignore", divide="ignore"):
            return np.where(bounds[:, :, None] > 0, load / bounds[:, :, None], np.nan)

    @cached_property
    def field_snapshots(self) -> pd.DataFrame:
        return self.telemetry("potential_field")

    def field(self, step: int) -> np.ndarray:
        """Stored potential of the tracked flows at a logged step: (tracked_flows, n_nodes)."""
        row = self.field_snapshots[self.field_snapshots.step == step]
        if row.empty:
            raise KeyError(f"step {step} is not logged; logged steps are multiples of {self.field_stride}")
        return np.asarray(row.potential.iloc[0], np.float64).reshape(self.tracked_flows, self.n_nodes)

    def nearest_logged_step(self, step: int) -> int:
        return int(min(self.field_snapshots.step, key=lambda s: abs(s - step)))

    def solve_field(self, step: int, queue: Optional[np.ndarray] = None, flows: Optional[Sequence[int]] = None) -> np.ndarray:
        """Recompute the potential of any flows at any step from the graph state and queue depths.

        Uses the generator's own engine (grounded Laplacian via the pseudo-inverse); with the
        potential router's queue depths at `step` this reproduces ``field(step)`` to floating-point
        precision. Returns (len(flows), n_nodes); flows default to the tracked ones.
        """
        if queue is None:
            queue = self.queue_depth("potential")[step]
        flows = np.arange(self.tracked_flows) if flows is None else np.asarray(flows)
        cfg = self.config
        field = PotentialField(self.live_graph(step), self.source[flows], self.sink[flows], cfg.source_injection)
        injection = cfg.background_injection / (self.n_nodes - 1) + cfg.congestion_gain * np.asarray(queue, np.float64) / cfg.buffer_size
        return field.solve(injection)

    def next_hops(self, step: int, phi: np.ndarray) -> np.ndarray:
        """Steepest-current next hop of every node for the given potentials (flows, n_nodes); −1 at the sink."""
        g = self.live_graph(step)
        return steepest_next_hops(currents(phi, g), g)

    def descent_path(self, step: int, phi: np.ndarray, source: int, sink: int) -> List[int]:
        """Follow the steepest-current next hops of one potential vector (n_nodes,) from source to sink."""
        hops = self.next_hops(step, np.asarray(phi, np.float64)[None, :])[0]
        node, path = int(source), [int(source)]
        while node != int(sink):
            node = int(hops[node])
            if node < 0 or len(path) > self.n_nodes:
                raise RuntimeError("descent did not reach the sink")
            path.append(node)
        return path