"""Train a material-conditioned DENIM with all 2,660 trajectories assigned.

The 1,008 basic-memory and 1,024 multiaxial trajectories teach a shared
conditional hardening representation.  The 628 incomplete-physics trajectories
then train and evaluate the closure target.  Frozen holdouts remain holdouts;
"use all data" means every trajectory has an explicit train/validation/test
role, not that benchmark cases are leaked into optimization.
"""

from __future__ import annotations

import argparse
import copy
import json
import random
import time
from collections import Counter, defaultdict
from dataclasses import dataclass
from pathlib import Path

import h5py
import numpy as np
import torch

from src.t2_denim_conditional import ConditionalDENIM, material_descriptor, rollout


ROOT = Path(__file__).resolve().parents[1]
V1_ROOT = ROOT / "data" / "t2_material_loading_memory_v1" / "shards"
V2_ROOT = ROOT / "data" / "t2_multiaxial_ood_v2" / "shards"
CLOSURE_PATH = ROOT / "data" / "t2_graybox_closure_v1" / "cohort.h5"
BOUNDARY_PATH = ROOT / "data" / "t2_denim_boundary_v1" / "cohort.h5"
MODEL_DIR = ROOT / "models" / "t2_denim_conditional_v2"
ARTIFACT_DIR = ROOT / "artifacts" / "t2_denim_conditional_v2"


@dataclass
class Trajectory:
    strain: torch.Tensor
    stress: torch.Tensor
    plastic: torch.Tensor
    peeq: torch.Tensor
    increment: torch.Tensor
    memories: torch.Tensor
    radius: torch.Tensor
    descriptor: torch.Tensor
    young: float
    poisson: float
    yield_stress: float
    source: str
    family: str
    material: str
    role: str
    evaluation: str


@dataclass
class Transitions:
    increment: torch.Tensor
    flow: torch.Tensor
    previous_flow: torch.Tensor
    old_peeq: torch.Tensor
    new_peeq: torch.Tensor
    old_memories: torch.Tensor
    new_memories: torch.Tensor
    new_radius: torch.Tensor
    descriptor: torch.Tensor
    yield_stress: torch.Tensor

    def __len__(self) -> int:
        return len(self.increment)

    def select(self, indices: torch.Tensor) -> "Transitions":
        return Transitions(**{name: value[indices] for name, value in vars(self).items()})


def _voigt(value: np.ndarray) -> np.ndarray:
    return value[..., (0, 1, 2, 0, 1, 0), (0, 1, 2, 1, 2, 2)]


def _parameters(group: h5py.Group) -> dict[str, float | str]:
    return json.loads(str(group.attrs["parameters_json"]))


def _standard_trajectory(
    group: h5py.Group,
    *,
    source: str,
    role: str,
    evaluation: str,
) -> Trajectory:
    parameters = _parameters(group)
    material = str(parameters["material_model"])
    if "total_strain_voigt" in group:
        strain = group["total_strain_voigt"][:]
        stress = group["stress_voigt_pa"][:]
        plastic = group["plastic_strain_voigt"][:]
    else:
        strain = _voigt(group["total_strain"][:])
        stress = _voigt(group["stress_pa"][:])
        plastic = _voigt(group["plastic_strain"][:])
    if material == "j2_linear_isotropic":
        memories = np.zeros((len(strain), 2, 6), dtype=np.float64)
    else:
        memories = _voigt(group["backstress_components_pa"][:])
    yield_stress = float(parameters["yield_stress_pa"])
    radius = group["yield_radius_pa"][:] - yield_stress
    return Trajectory(
        strain=torch.tensor(strain, dtype=torch.float32),
        stress=torch.tensor(stress, dtype=torch.float32),
        plastic=torch.tensor(plastic, dtype=torch.float32),
        peeq=torch.tensor(group["equivalent_plastic_strain"][:], dtype=torch.float32),
        increment=torch.tensor(group["plastic_multiplier_increment"][:], dtype=torch.float32),
        memories=torch.tensor(memories, dtype=torch.float32),
        radius=torch.tensor(radius, dtype=torch.float32),
        descriptor=material_descriptor(parameters),
        young=float(parameters["young_pa"]),
        poisson=float(parameters["poisson"]),
        yield_stress=yield_stress,
        source=source,
        family=str(group.attrs["path_family"]),
        material=material,
        role=role,
        evaluation=evaluation,
    )


def _hidden_trajectory(group: h5py.Group, *, source: str) -> Trajectory:
    parameters = _parameters(group)
    split = str(group.attrs["split"])
    role = "train" if split == "train" else "validation" if split == "validation" else "test"
    if split == "test":
        evaluation = "hidden_frozen_test"
    elif split.startswith("test_"):
        evaluation = split
        role = "test"
    else:
        evaluation = f"hidden_{role}"
    return Trajectory(
        strain=torch.tensor(group["strain"][:], dtype=torch.float32),
        stress=torch.tensor(group["stress_pa"][:], dtype=torch.float32),
        plastic=torch.tensor(group["plastic_strain"][:], dtype=torch.float32),
        peeq=torch.tensor(group["peeq"][:], dtype=torch.float32),
        increment=torch.tensor(group["plastic_increment"][:], dtype=torch.float32),
        memories=torch.tensor(group["memories_pa"][:], dtype=torch.float32),
        radius=torch.tensor(group["isotropic_radius_pa"][:], dtype=torch.float32),
        descriptor=material_descriptor(parameters),
        young=float(parameters["young_pa"]),
        poisson=float(parameters["poisson"]),
        yield_stress=float(parameters["yield_stress_pa"]),
        source=source,
        family=str(group.attrs["path_family"]),
        material=str(parameters["material_model"]),
        role=role,
        evaluation=evaluation,
    )


def load_all_trajectories() -> list[Trajectory]:
    trajectories: list[Trajectory] = []
    for path in sorted(V1_ROOT.glob("*.h5")):
        with h5py.File(path, "r") as h5:
            for name in sorted(h5):
                group = h5[name]
                split = str(group.attrs["split"])
                trajectories.append(
                    _standard_trajectory(
                        group, source="basic_memory_v1", role=split,
                        evaluation=f"v1_{split}",
                    )
                )
    for path in sorted(V2_ROOT.glob("*.h5")):
        with h5py.File(path, "r") as h5:
            for name in sorted(h5):
                group = h5[name]
                splits = tuple(
                    str(group.attrs[field])
                    for field in ("split_id", "split_path_ood", "split_parameter_ood")
                )
                if all(value == "train" for value in splits):
                    role = "train"
                elif any(value == "test" for value in splits):
                    role = "test"
                else:
                    role = "validation"
                labels = []
                for protocol, value in zip(("id", "path_ood", "parameter_ood"), splits, strict=True):
                    if value == "test":
                        labels.append(protocol)
                evaluation = "v2_" + ("+".join(labels) if labels else role)
                trajectories.append(
                    _standard_trajectory(
                        group, source="multiaxial_ood_v2", role=role,
                        evaluation=evaluation,
                    )
                )
    with h5py.File(CLOSURE_PATH, "r") as h5:
        for name in sorted(h5):
            trajectories.append(_hidden_trajectory(h5[name], source="denim_closure_v1"))
    with h5py.File(BOUNDARY_PATH, "r") as h5:
        for name in sorted(h5):
            trajectories.append(_hidden_trajectory(h5[name], source="denim_boundary_v1"))
    if len(trajectories) != 2660:
        raise RuntimeError(f"Expected 2,660 trajectories, found {len(trajectories)}")
    return trajectories


def transitions(trajectories: list[Trajectory]) -> Transitions:
    values: dict[str, list[torch.Tensor]] = defaultdict(list)
    for trajectory in trajectories:
        increment = trajectory.increment[1:]
        active = increment > 1.0e-11
        if not torch.any(active):
            continue
        old_plastic = trajectory.plastic[:-1]
        new_plastic = trajectory.plastic[1:]
        flow = (new_plastic - old_plastic) / increment.clamp_min(1.0e-14)[:, None]
        previous_increment = trajectory.increment[:-1]
        previous_plastic = torch.cat((torch.zeros_like(old_plastic[:1]), old_plastic[:-1]), dim=0)
        previous_flow = (old_plastic - previous_plastic) / previous_increment.clamp_min(1.0e-14)[:, None]
        previous_flow = torch.where(
            (previous_increment > 1.0e-11)[:, None], previous_flow,
            torch.zeros_like(previous_flow),
        )
        count = int(active.sum())
        values["increment"].append(increment[active])
        values["flow"].append(flow[active])
        values["previous_flow"].append(previous_flow[active])
        values["old_peeq"].append(trajectory.peeq[:-1][active])
        values["new_peeq"].append(trajectory.peeq[1:][active])
        values["old_memories"].append(trajectory.memories[:-1][active])
        values["new_memories"].append(trajectory.memories[1:][active])
        values["new_radius"].append(trajectory.radius[1:][active])
        values["descriptor"].append(trajectory.descriptor[None].expand(count, -1))
        values["yield_stress"].append(torch.full((count,), trajectory.yield_stress))
    return Transitions(**{name: torch.cat(parts, dim=0) for name, parts in values.items()})


def _loss(model: ConditionalDENIM, data: Transitions) -> tuple[torch.Tensor, dict[str, float]]:
    from src.t2_graybox_discrete_energy import GrayboxState

    count = len(data)
    state = GrayboxState(
        plastic_strain=torch.zeros((count, 6)),
        peeq=data.old_peeq,
        memories=data.old_memories,
        previous_flow=data.previous_flow,
    )
    embedding = model.encode(data.descriptor)
    predicted, _, _ = model.update_memories(
        state, data.flow, data.increment, data.yield_stress, embedding
    )
    radius = model.isotropic_radius(data.new_peeq, data.yield_stress, embedding)
    scale = data.yield_stress.clamp_min(1.0)
    memory = ((predicted - data.new_memories) / scale[:, None, None]).square().mean()
    delta = (
        ((predicted - data.old_memories) - (data.new_memories - data.old_memories))
        / (0.05 * scale[:, None, None])
    ).square().mean()
    isotropic = ((radius - data.new_radius) / scale).square().mean()
    total = memory + 0.08 * delta + isotropic
    return total, {
        "memory": float(memory.detach()),
        "memory_increment": float(delta.detach()),
        "isotropic": float(isotropic.detach()),
    }


def _train_stage(
    model: ConditionalDENIM,
    train_sets: list[Transitions],
    validation_sets: list[Transitions],
    *,
    steps: int,
    seed: int,
    batch_size: int = 4096,
    learning_rate: float = 2.0e-3,
) -> dict[str, object]:
    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=1.0e-6)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, steps, eta_min=2.0e-5)
    generator = torch.Generator().manual_seed(seed)
    best = float("inf")
    best_state = None
    history = []
    started = time.perf_counter()
    for step in range(steps):
        optimizer.zero_grad()
        total = torch.zeros(())
        diagnostics = []
        for data in train_sets:
            index = torch.randint(len(data), (min(batch_size, len(data)),), generator=generator)
            value, detail = _loss(model, data.select(index))
            total = total + value / len(train_sets)
            diagnostics.append(detail)
        total.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 10.0)
        optimizer.step()
        scheduler.step()
        if step % 50 == 0 or step + 1 == steps:
            model.eval()
            with torch.no_grad():
                validation = []
                for data in validation_sets:
                    # Deterministic cap keeps validation fast and balanced.
                    selected = torch.arange(min(24000, len(data)))
                    validation.append(float(_loss(model, data.select(selected))[0]))
                score = sum(validation) / len(validation)
            model.train()
            history.append(
                {
                    "step": step,
                    "training_loss": float(total.detach()),
                    "validation_loss": score,
                    "parts": diagnostics,
                }
            )
            if score < best:
                best = score
                best_state = copy.deepcopy(model.state_dict())
    if best_state is None:
        raise RuntimeError("Training stage produced no checkpoint")
    model.load_state_dict(best_state)
    model.eval()
    return {
        "steps": steps,
        "seconds": time.perf_counter() - started,
        "best_validation_loss": best,
        "history": history,
    }


def _metric(prediction: torch.Tensor, reference: torch.Tensor) -> dict[str, float | int]:
    error = prediction - reference
    denominator = (reference - reference.mean()).square().sum().clamp_min(1.0)
    return {
        "trajectory_count": len(reference),
        "rmse_mpa": float(torch.sqrt(error.square().mean()) / 1.0e6),
        "mae_mpa": float(error.abs().mean() / 1.0e6),
        "r2": float(1.0 - error.square().sum() / denominator),
    }


def evaluate(model: ConditionalDENIM, selected: list[Trajectory]) -> dict[str, float | int]:
    predictions = []
    references = []
    by_points: dict[int, list[Trajectory]] = defaultdict(list)
    for item in selected:
        by_points[len(item.strain)].append(item)
    with torch.no_grad():
        for group in by_points.values():
            for start in range(0, len(group), 96):
                batch = group[start : start + 96]
                strain = torch.stack([item.strain for item in batch])
                result = rollout(
                    strain,
                    torch.tensor([item.young for item in batch]),
                    torch.tensor([item.poisson for item in batch]),
                    torch.tensor([item.yield_stress for item in batch]),
                    torch.stack([item.descriptor for item in batch]),
                    model,
                    bisection_iterations=24,
                )
                predictions.append(result["stress"].reshape(-1, 6))
                references.append(
                    torch.stack([item.stress for item in batch]).reshape(-1, 6)
                )
    result = _metric(torch.cat(predictions), torch.cat(references))
    result["trajectory_count"] = len(selected)
    result["state_point_count"] = sum(len(item.strain) for item in selected)
    return result


def run(*, pretrain_steps: int = 1800, joint_steps: int = 1800, scratch_steps: int = 1800) -> dict[str, object]:
    random.seed(20260927)
    np.random.seed(20260927)
    torch.manual_seed(20260927)
    trajectories = load_all_trajectories()
    known_train = [x for x in trajectories if x.material != "hidden_three_memory_tabulated_hardening" and x.role == "train"]
    known_validation = [x for x in trajectories if x.material != "hidden_three_memory_tabulated_hardening" and x.role == "validation"]
    hidden_train = [x for x in trajectories if x.material == "hidden_three_memory_tabulated_hardening" and x.role == "train"]
    hidden_validation = [x for x in trajectories if x.material == "hidden_three_memory_tabulated_hardening" and x.role == "validation"]

    datasets = {
        "known_train": transitions(known_train),
        "known_validation": transitions(known_validation),
        "hidden_train": transitions(hidden_train),
        "hidden_validation": transitions(hidden_validation),
    }
    pretrained = ConditionalDENIM()
    pretraining = _train_stage(
        pretrained, [datasets["known_train"]], [datasets["known_validation"]],
        steps=pretrain_steps, seed=20260927,
    )
    print(json.dumps({"stage": "known_pretraining", "best_validation_loss": pretraining["best_validation_loss"]}), flush=True)
    transfer = copy.deepcopy(pretrained)
    joint_training = _train_stage(
        transfer,
        [datasets["known_train"], datasets["hidden_train"]],
        [datasets["known_validation"], datasets["hidden_validation"]],
        steps=joint_steps, seed=20260928,
    )
    print(json.dumps({"stage": "mixed_replay", "best_validation_loss": joint_training["best_validation_loss"]}), flush=True)
    scratch = ConditionalDENIM()
    scratch_training = _train_stage(
        scratch, [datasets["hidden_train"]], [datasets["hidden_validation"]],
        steps=scratch_steps, seed=20260929,
    )
    print(json.dumps({"stage": "hidden_scratch", "best_validation_loss": scratch_training["best_validation_loss"]}), flush=True)

    MODEL_DIR.mkdir(parents=True, exist_ok=True)
    torch.save({"state_dict": transfer.state_dict(), "stage": "pre_evaluation"}, MODEL_DIR / "denim_conditional_v2.inprogress.pt")

    groups: dict[str, list[Trajectory]] = defaultdict(list)
    for trajectory in trajectories:
        groups[trajectory.evaluation].append(trajectory)
    primary = (
        "v1_test", "v2_id", "v2_path_ood", "v2_parameter_ood",
        "v2_id+path_ood", "v2_id+parameter_ood", "v2_path_ood+parameter_ood",
        "v2_id+path_ood+parameter_ood", "hidden_frozen_test",
        "test_path_ood", "test_amplitude_ood", "test_long_horizon",
        "test_discretization",
    )
    evaluations: dict[str, object] = {}
    for name in primary:
        if not groups[name]:
            continue
        evaluations[name] = {
            "transfer": evaluate(transfer, groups[name]),
            "scratch": evaluate(scratch, groups[name])
            if groups[name][0].material == "hidden_three_memory_tabulated_hardening"
            else None,
        }
    # Aggregate strict holdouts gives a stable headline for the two known families.
    known_test = [x for x in trajectories if x.material != "hidden_three_memory_tabulated_hardening" and x.role == "test"]
    hidden_test = [x for x in trajectories if x.material == "hidden_three_memory_tabulated_hardening" and x.role == "test" and len(x.strain) == 241]
    evaluations["known_strict_test_all"] = {"transfer": evaluate(transfer, known_test)}
    evaluations["hidden_all_fixed_length_test"] = {
        "transfer": evaluate(transfer, hidden_test),
        "scratch": evaluate(scratch, hidden_test),
    }

    accounting = {
        "total": len(trajectories),
        "by_source": dict(Counter(x.source for x in trajectories)),
        "by_role": dict(Counter(x.role for x in trajectories)),
        "training": len(known_train) + len(hidden_train),
        "validation": len(known_validation) + len(hidden_validation),
        "test": sum(x.role == "test" for x in trajectories),
        "known_training": len(known_train),
        "hidden_training": len(hidden_train),
        "transition_counts": {name: len(data) for name, data in datasets.items()},
    }
    metrics: dict[str, object] = {
        "name": "material-conditioned DENIM v2",
        "scope": "three synthetic material families; shared conditional closure with strict frozen holdouts",
        "parameter_count": sum(parameter.numel() for parameter in transfer.parameters()),
        "accounting": accounting,
        "training": {
            "known_family_pretraining": pretraining,
            "mixed_replay_transfer": joint_training,
            "hidden_only_scratch": scratch_training,
        },
        "evaluation": evaluations,
        "descriptor_policy": {
            "known_families": "E, nu, initial yield plus declared hardening parameters and family indicator",
            "incomplete_family": "E, nu, initial yield and family indicator only; hidden hardening parameters remain zero",
        },
    }
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
    torch.save(
        {
            "state_dict": transfer.state_dict(),
            "architecture": "ConditionalDENIM(channels=2, embedding=32, hidden=48)",
            "data_accounting": accounting,
        },
        MODEL_DIR / "denim_conditional_v2.pt",
    )
    torch.save(
        {"state_dict": pretrained.state_dict(), "stage": "known_family_pretraining"},
        MODEL_DIR / "denim_conditional_pretrained.pt",
    )
    torch.save(
        {"state_dict": scratch.state_dict(), "stage": "hidden_only_scratch"},
        MODEL_DIR / "denim_conditional_scratch.pt",
    )
    (ARTIFACT_DIR / "model_metrics.json").write_text(
        json.dumps(metrics, indent=2) + "\n", encoding="utf-8"
    )
    print(json.dumps({"accounting": accounting, "evaluation": evaluations}, indent=2))
    return metrics


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--pretrain-steps", type=int, default=1800)
    parser.add_argument("--joint-steps", type=int, default=1800)
    parser.add_argument("--scratch-steps", type=int, default=1800)
    arguments = parser.parse_args()
    run(
        pretrain_steps=arguments.pretrain_steps,
        joint_steps=arguments.joint_steps,
        scratch_steps=arguments.scratch_steps,
    )


if __name__ == "__main__":
    main()