"""Shared constants and JSONL helpers for the QuantInvBench release."""

from __future__ import annotations

import hashlib
import json
import math
from pathlib import Path
from typing import Iterable, Mapping, Sequence


COINS = ("bitcoin", "ethereum", "tether", "xrp", "bnb")
ASSETS = ("BTC", "ETH", "USDT", "XRP", "BNB")
COIN_TO_ASSET = dict(zip(COINS, ASSETS))
BENCHMARK_VERSION = "2.0.0"
ATTACK_PROTOCOL_VERSION = "quantinv-byzantine-v1"
STRATEGIES = (
    "Momentum",
    "MaxSharpe",
    "TSMom14",
    "TSMom60",
    "RiskParity",
    "MinVar",
    "NewsSentiment",
    "Size",
    "ValueNVT",
    "Liquidity",
)
REBALANCE_DAYS = 7
TRANSACTION_COST = 0.001
WEIGHT_TOLERANCE = 1e-6
EXPECTED_SPLIT_COUNTS = {"train": 297, "validation": 52, "test": 52}
EXPECTED_SPLIT_RANGES = {
    "train": {
        "execution_start": "2018-07-04T00:00:00Z",
        "execution_end": "2024-03-06T00:00:00Z",
        "label_end": "2024-03-13T00:00:00Z",
    },
    "validation": {
        "execution_start": "2024-03-16T00:00:00Z",
        "execution_end": "2025-03-08T00:00:00Z",
        "label_end": "2025-03-15T00:00:00Z",
    },
    "test": {
        "execution_start": "2025-03-16T00:00:00Z",
        "execution_end": "2026-03-08T00:00:00Z",
        "label_end": "2026-03-15T00:00:00Z",
    },
}
EVALUATION_PROTOCOL = {
    "initial_portfolio": "equal_weight",
    "submitted_methods": "rebalance_every_record",
    "equal_weight_baseline": "buy_and_hold",
    "turnover": "half_l1_target_vs_return_drifted_holdings",
    "sharpe": "weekly_returns_sqrt_52_ddof_0",
    "max_drawdown": "daily_nav",
}


def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for block in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def read_jsonl(path: Path) -> list[dict]:
    records = []
    with path.open(encoding="utf-8") as handle:
        for line_number, line in enumerate(handle, start=1):
            if not line.strip():
                continue
            try:
                records.append(json.loads(line))
            except json.JSONDecodeError as exc:
                raise ValueError(f"{path}:{line_number}: invalid JSON: {exc}") from exc
    return records


def write_jsonl(path: Path, records: Iterable[dict]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8", newline="\n") as handle:
        for record in records:
            handle.write(json.dumps(record, ensure_ascii=False, allow_nan=False))
            handle.write("\n")


def validated_weights(
    values: Mapping[str, float] | Sequence[float],
    *,
    label: str,
) -> list[float]:
    if isinstance(values, Mapping):
        weights = [float(values[coin]) for coin in COINS]
    else:
        weights = [float(value) for value in values]

    if len(weights) != len(ASSETS):
        raise ValueError(f"{label}: expected {len(ASSETS)} weights, got {len(weights)}")
    if not all(math.isfinite(value) for value in weights):
        raise ValueError(f"{label}: weights contain NaN or Infinity")
    if any(value < -WEIGHT_TOLERANCE for value in weights):
        raise ValueError(f"{label}: weights must be non-negative: {weights}")

    weights = [max(0.0, value) for value in weights]
    total = sum(weights)
    if total <= 0:
        raise ValueError(f"{label}: weights sum to zero")

    normalized = [value / total for value in weights]
    rounded = [round(value, 10) for value in normalized]
    largest_index = max(range(len(rounded)), key=rounded.__getitem__)
    rounded[largest_index] = round(
        rounded[largest_index] + (1.0 - sum(rounded)), 10
    )
    if abs(sum(rounded) - 1.0) > WEIGHT_TOLERANCE:
        raise ValueError(f"{label}: normalized weights do not sum to one")
    return rounded


def usdt_fallback() -> dict[str, float]:
    return {coin: (1.0 if coin == "tether" else 0.0) for coin in COINS}