"""Data loading functions for MacroLens benchmark."""

from __future__ import annotations

from typing import Any

import pandas as pd

from ._compat import WhatIfTSFDataset, ValuationDataset, config

_TASK_ALIASES: dict[str, str] = {
    # Numeric aliases (Task 1 = TSF, use load_tsf() instead)
    "2": "A",
    "3": "B",
    "4": "C",
    "5": "D",
    "6": "E",
    "7": "F",
    # Letter aliases (legacy)
    "a": "A",
    "b": "B",
    "c": "C",
    "d": "D",
    "e": "E",
    "f": "F",
    # Name aliases → Task 2 (Val-PT)
    "valuation": "A",
    "val-pt": "A",
    "val_pt": "A",
    "valuation_accuracy": "A",
    # Name aliases → Task 3 (Stmt-Gen)
    "statement_generation": "B",
    "stmt-gen": "B",
    "stmt_gen": "B",
    # Name aliases → Task 4 (Scen-Ret)
    "scenario_forecast": "C",
    "scen-ret": "C",
    "scen_ret": "C",
    # Name aliases → Task 5 (Priv-Val)
    "private_valuation": "D",
    "priv-val": "D",
    "priv_val": "D",
    "pe_valuation": "D",
    # Name aliases → Task 6 (Gen-Eval)
    "generator_evaluation": "E",
    "gen-eval": "E",
    "gen_eval": "E",
    # Name aliases → Task 7 (RE-Val)
    "real_estate_valuation": "F",
    "re-val": "F",
    "re_val": "F",
}


def load_tsf(
    split: str = "test",
    horizon: int = 21,
    lookback: int | None = None,
    granularity: str = "daily",
    target_col: str = "close",
    load_text: bool = False,
) -> WhatIfTSFDataset:
    """Load the time-series forecasting dataset.

    Parameters
    ----------
    split : str
        ``"train"`` or ``"test"`` (default: ``"test"``).
    horizon : int
        Forecast horizon in periods. Must be one of the benchmark's
        defined horizons (daily: 5, 21, 63). Default: 21.
    lookback : int, optional
        Lookback window length. Default: first benchmark lookback (63 for daily).
    granularity : str
        ``"daily"`` (default), ``"weekly"``, or ``"monthly"``.
    target_col : str
        Target column name (default: ``"close"``).
    load_text : bool
        Whether to load filing text into context. Default: ``False``
        (faster loading; set ``True`` for LLM/RAG experiments).

    Returns
    -------
    WhatIfTSFDataset
        Iterable dataset with ``__len__`` and ``__getitem__`` support.

    Example
    -------
    >>> tsf = macrolens.load_tsf(split="test", horizon=21)
    >>> len(tsf)
    1303243
    >>> sample = tsf[0]
    >>> sample["lookback"].shape
    (63, 103)
    >>> sample["target"].shape
    (21,)
    """
    valid_horizons = config.get_horizons(granularity)
    if horizon not in valid_horizons:
        raise ValueError(
            f"Invalid horizon {horizon} for granularity '{granularity}'. "
            f"Valid horizons: {valid_horizons}"
        )
    if split not in ("train", "test"):
        raise ValueError(f"split must be 'train' or 'test', got '{split}'")

    if lookback is None:
        lookback = config.get_lookback_windows(granularity)[0]

    return WhatIfTSFDataset(
        split=split,
        lookback=lookback,
        horizon=horizon,
        granularity=granularity,
        target_col=target_col,
        load_text=load_text,
    )


def load_task(
    task: str,
    granularity: str = "daily",
) -> ValuationDataset:
    """Load a valuation-task dataset (Task 2, 3, or 4).

    Parameters
    ----------
    task : str
        Task identifier. Accepts: ``"2"``, ``"3"``, ``"4"`` (or legacy ``"A"``, ``"B"``, ``"C"``),
        or full names like ``"valuation"``, ``"statement_generation"``, ``"scenario_forecast"``.
    granularity : str
        ``"daily"`` (default), ``"weekly"``, or ``"monthly"``.

    Returns
    -------
    ValuationDataset
        Dataset with ``inputs``, ``ground_truth``, and ``holdout_tickers``
        attributes.

    Example
    -------
    >>> task_2 = macrolens.load_task("2")
    >>> len(task_2)
    11839
    >>> task_2.inputs.columns.tolist()[:5]
    ['ticker', 'date', 'sector', 'industry', 'derived_market_cap']
    """
    canonical = _TASK_ALIASES.get(task.lower(), task.upper())
    if canonical not in ("A", "B", "C", "D", "E", "F"):
        raise ValueError(
            f"Unknown task '{task}'. Valid: '2' (valuation), "
            "'3' (statement generation), '4' (scenario forecast), "
            "'5' (private valuation), '6' (generator eval), '7' (RE valuation)"
        )
    return ValuationDataset(task=canonical, granularity=granularity)


def load_scenarios(granularity: str = "daily") -> pd.DataFrame:
    """Load raw scenario ground-truth data.

    Returns the full ``scenario_forecast_ground_truth.parquet`` as a DataFrame.

    Parameters
    ----------
    granularity : str
        ``"daily"`` (default).

    Returns
    -------
    pd.DataFrame
        Columns include ``scenario_id``, ``ticker``, ``event_type``,
        ``event_date``, ``actual_return_pct``.

    Example
    -------
    >>> sc = macrolens.load_scenarios()
    >>> sc.shape
    (3100000, 7)
    >>> sc["event_type"].nunique()
    50
    """
    bench_dir = config.get_benchmark_dir(granularity)
    path = bench_dir / "scenario_forecast_ground_truth.parquet"
    if not path.exists():
        raise FileNotFoundError(
            f"Scenario ground truth not found at {path}. "
            "Run benchmark assembly first."
        )
    return pd.read_parquet(path)


def load_panel(
    split: str = "train",
    granularity: str = "daily",
    columns: list[str] | None = None,
) -> pd.DataFrame:
    """Load the raw panel data as a DataFrame.

    Useful for custom feature engineering or analysis. For standard
    benchmark evaluation, prefer :func:`load_tsf` or :func:`load_task`.

    Parameters
    ----------
    split : str
        ``"train"`` or ``"test"``.
    granularity : str
        ``"daily"`` (default).
    columns : list[str], optional
        Subset of columns to load (faster for large panels).

    Returns
    -------
    pd.DataFrame
        The benchmark panel with all features.

    Example
    -------
    >>> panel = macrolens.load_panel("train", columns=["ticker", "date", "close"])
    >>> panel.shape
    (2160000, 3)
    """
    if split not in ("train", "test"):
        raise ValueError(f"split must be 'train' or 'test', got '{split}'")

    bench_dir = config.get_benchmark_dir(granularity)
    path = bench_dir / f"panel_{split}.parquet"
    if not path.exists():
        raise FileNotFoundError(f"Panel not found at {path}.")

    kwargs: dict[str, Any] = {}
    if columns is not None:
        kwargs["columns"] = columns
    return pd.read_parquet(path, **kwargs)