from __future__ import annotations

import json
import random
import sys
from pathlib import Path
from typing import Any

import numpy as np
import torch
import yaml

PROJECT_ROOT = Path(__file__).resolve().parents[1]
if str(PROJECT_ROOT) not in sys.path:
    sys.path.insert(0, str(PROJECT_ROOT))


def load_config(config_path: str | Path | None = None) -> dict[str, Any]:
    path = Path(config_path) if config_path else PROJECT_ROOT / "conf" / "config.yaml"
    if not path.is_absolute():
        path = PROJECT_ROOT / path
    with path.open("r", encoding="utf-8") as f:
        return yaml.safe_load(f)


def project_path(path: str | Path) -> Path:
    path = Path(path)
    return path if path.is_absolute() else PROJECT_ROOT / path


def seed_everything(seed: int) -> None:
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)


def select_device(value: str = "auto") -> torch.device:
    if value == "auto":
        return torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    return torch.device(value)


def ensure_parent(path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)


def ensure_runtime_dirs(cfg: dict[str, Any]) -> None:
    for key in ("fake_data", "prediction", "metrics", "loss", "figure"):
        ensure_parent(project_path(cfg["paths"][key]))
    ensure_parent(project_path(cfg["training"]["checkpoint"]))


def build_model(cfg: dict[str, Any]) -> torch.nn.Module:
    from model import PINNsformer1D

    model_cfg = cfg["model"]
    return PINNsformer1D(
        d_out=int(model_cfg["d_out"]),
        d_hidden=int(model_cfg["d_hidden"]),
        d_model=int(model_cfg["d_model"]),
        N=int(model_cfg["num_layers"]),
        heads=int(model_cfg["heads"]),
    )


def initial_condition(x: np.ndarray | torch.Tensor, cfg: dict[str, Any]):
    initial = cfg["equation"]["initial"]
    center = initial["center"]
    sigma = initial["sigma"]
    if isinstance(x, torch.Tensor):
        return torch.exp(-((x - center) ** 2) / (2 * sigma**2))
    return np.exp(-((x - center) ** 2) / (2 * sigma**2))


def exact_reaction_solution(
    x: np.ndarray | torch.Tensor,
    t: np.ndarray | torch.Tensor,
    cfg: dict[str, Any],
):
    h = initial_condition(x, cfg)
    rate = cfg["equation"]["reaction_rate"]
    if isinstance(h, torch.Tensor):
        exp_term = torch.exp(rate * t)
    else:
        exp_term = np.exp(rate * t)
    return h * exp_term / (h * exp_term + 1 - h)


def relative_errors(pred: np.ndarray, target: np.ndarray) -> dict[str, float]:
    return {
        "relative_l1": float(np.sum(np.abs(target - pred)) / np.sum(np.abs(target))),
        "relative_l2": float(np.sqrt(np.sum((target - pred) ** 2) / np.sum(target**2))),
    }


def write_json(path: Path, payload: dict[str, Any]) -> None:
    ensure_parent(path)
    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")