data_loader.py

# file: data_loader.py
"""Datenlader für CSV-Dateien und synthetische Daten.

Dieses Modul bietet Funktionen zum Laden und Validieren von Marktdaten
für das BESS Pricing Projekt.
"""

import numpy as np
import pandas as pd
from pathlib import Path
from dataclasses import dataclass
from typing import Optional, Tuple, Dict, Any, List

from config_loader import Config, DataConfig
from utils.logging_config import get_logger

# Logger für dieses Modul
logger = get_logger("data_loader")


class DataValidationError(Exception):
    """Fehler bei der Datenvalidierung."""
    pass


@dataclass
class MarketData:
    """Container für Marktdaten.

    Attributes:
        price: Strompreis in EUR/MWh.
        fr_signal: Frequenzregulierungssignal im Bereich [-1, 1].
        reserve_price: Reserve-Vergütung in EUR/MW.
        timestamps: Optionale Zeitstempel der Daten.
        demand: Nachfrage für Load-Following Modus.
        re_gen: Erneuerbare Erzeugung für Load-Following Modus.
        temperature: Optionale Temperaturzeitreihe in °C.
        dt_hours: Inferenz oder Vorgabe der Zeitauflösung in Stunden.
    """
    price: np.ndarray              # Strompreis [EUR/MWh]
    fr_signal: np.ndarray          # Frequenzregulierungssignal [-1, 1]
    reserve_price: np.ndarray      # Reserve-Vergütung [EUR/MW]
    timestamps: Optional[np.ndarray] = None  # Zeitstempel
    demand: Optional[np.ndarray] = None      # Nachfrage (für Load-Following)
    re_gen: Optional[np.ndarray] = None      # Erneuerbare Erzeugung
    temperature: Optional[np.ndarray] = None  # Temperatur [°C]
    dt_hours: Optional[float] = None

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

    def __repr__(self) -> str:
        dt_repr = f", dt={self.dt_hours:.3f}h" if self.dt_hours is not None else ""
        return (
            f"MarketData(T={len(self)}, "
            f"price=[{self.price.min():.1f}, {self.price.max():.1f}], "
            f"fr=[{self.fr_signal.min():.2f}, {self.fr_signal.max():.2f}]"
            f"{dt_repr})"
        )


def infer_dt_hours(timestamps: np.ndarray) -> Optional[float]:
    """Leite die mittlere Zeitauflösung aus Zeitstempeln ab."""
    if timestamps is None or len(timestamps) < 2:
        return None

    idx = pd.to_datetime(timestamps)
    diffs = idx.to_series().diff().dropna()
    if diffs.empty:
        return None

    diff_hours = diffs.dt.total_seconds().to_numpy(dtype=np.float64) / 3600.0
    positive = diff_hours[diff_hours > 0]
    if len(positive) == 0:
        return None

    dt_hours = float(np.median(positive))
    irregularity = np.max(np.abs(positive - dt_hours))
    if irregularity > 1e-6:
        logger.warning(
            "Zeitstempel sind nicht aequidistant. Verwende mediane Schrittweite %.4fh",
            dt_hours,
        )
    return dt_hours


def validate_array(
    arr: np.ndarray,
    name: str,
    expected_length: Optional[int] = None,
    allow_nan: bool = False,
    allow_inf: bool = False,
    min_value: Optional[float] = None,
    max_value: Optional[float] = None,
) -> List[str]:
    """Validiere ein NumPy-Array und sammle Warnungen/Fehler.

    Args:
        arr: Zu validierendes Array.
        name: Name des Arrays für Fehlermeldungen.
        expected_length: Erwartete Länge (optional).
        allow_nan: Ob NaN-Werte erlaubt sind.
        allow_inf: Ob Inf-Werte erlaubt sind.
        min_value: Minimaler erlaubter Wert (optional).
        max_value: Maximaler erlaubter Wert (optional).

    Returns:
        Liste von Warnungen.

    Raises:
        DataValidationError: Bei kritischen Validierungsfehlern.
    """
    warnings = []

    # Längenprüfung
    if expected_length is not None and len(arr) != expected_length:
        raise DataValidationError(
            f"{name}: Länge {len(arr)} stimmt nicht mit erwarteter Länge {expected_length} überein"
        )

    # NaN-Prüfung
    nan_count = np.sum(np.isnan(arr))
    if nan_count > 0:
        if not allow_nan:
            raise DataValidationError(f"{name}: {nan_count} NaN-Werte gefunden")
        warnings.append(f"{name}: {nan_count} NaN-Werte gefunden")

    # Inf-Prüfung
    inf_count = np.sum(np.isinf(arr))
    if inf_count > 0:
        if not allow_inf:
            raise DataValidationError(f"{name}: {inf_count} Inf-Werte gefunden")
        warnings.append(f"{name}: {inf_count} Inf-Werte gefunden")

    # Wertebereich-Prüfung
    if min_value is not None:
        below_min = np.sum(arr < min_value)
        if below_min > 0:
            warnings.append(f"{name}: {below_min} Werte unter {min_value}")

    if max_value is not None:
        above_max = np.sum(arr > max_value)
        if above_max > 0:
            warnings.append(f"{name}: {above_max} Werte über {max_value}")

    return warnings


def generate_synthetic_data(
    days: int = 60,
    dt_hours: float = 1.0,
    seed: int = 7,
    task: str = "arbitrage",
) -> MarketData:
    """Generiere synthetische Marktdaten für Testing/Demo.

    Erzeugt realistische Preismuster mit:
    - Täglicher Zyklus (Peak mittags/abends)
    - Wöchentlicher Zyklus (Wochenende günstiger)
    - Zufälligem Rauschen

    Args:
        days: Anzahl der Tage.
        dt_hours: Zeitschritt in Stunden.
        seed: Random Seed für Reproduzierbarkeit.

    Returns:
        MarketData mit synthetischen Werten.
    """
    rng = np.random.default_rng(seed)
    T = int(days * 24 / dt_hours)
    hours = np.arange(T, dtype=np.float64) * dt_hours

    logger.debug(f"Generiere {T} synthetische Datenpunkte für {days} Tage")

    # Strompreis mit Intraday-, Wochen- und Volatilitaetsregime
    base_price = 55.0
    morning_peak = 12.0 * np.exp(-0.5 * ((hours % 24 - 8.0) / 2.5) ** 2)
    evening_peak = 24.0 * np.exp(-0.5 * ((hours % 24 - 19.0) / 3.0) ** 2)
    weekend_discount = -8.0 * (((hours // 24) % 7) >= 5)
    seasonal = 6.0 * np.sin(2 * np.pi * hours / (24.0 * 30.0))

    innovations = rng.normal(0.0, 6.0, size=T)
    mean_reverting = np.zeros(T, dtype=np.float64)
    for t in range(1, T):
        mean_reverting[t] = 0.82 * mean_reverting[t - 1] + innovations[t]

    spike_mask = rng.random(T) < 0.015
    spikes = rng.normal(45.0, 20.0, size=T) * spike_mask
    negative_mask = rng.random(T) < 0.01
    negative_events = rng.normal(-35.0, 10.0, size=T) * negative_mask

    price = np.clip(
        base_price
        + morning_peak
        + evening_peak
        + weekend_discount
        + seasonal
        + mean_reverting
        + spikes
        + negative_events,
        -40.0,
        350.0,
    ).astype(np.float32)

    # FR-Signal als AR(1) mit leichter Mean-Reversion
    fr_signal = np.zeros(T, dtype=np.float32)
    for t in range(1, T):
        fr_signal[t] = 0.75 * fr_signal[t - 1] + rng.normal(0.0, 0.35)
    fr_signal = np.clip(fr_signal, -1.0, 1.0).astype(np.float32)

    # Reserve-Preis korreliert mit Volatilitaet und Peak-Zeiten
    reserve_base = 1.8 + 0.04 * np.maximum(price, 0.0)
    reserve_peak = 1.2 * (((hours % 24) >= 7.0) & ((hours % 24) <= 10.0))
    reserve_peak += 1.6 * (((hours % 24) >= 17.0) & ((hours % 24) <= 21.0))
    reserve_noise = rng.normal(0.0, 0.2, size=T)
    reserve_price = np.clip(reserve_base + reserve_peak + reserve_noise, 0.5, 12.0).astype(np.float32)

    # Einfache Temperaturzeitreihe fuer temperaturabhaengige Alterung
    temperature = (
        18.0
        + 7.0 * np.sin(2 * np.pi * hours / (24.0 * 365.0))
        + 3.0 * np.sin(2 * np.pi * (hours % 24) / 24.0 - np.pi / 2.0)
        + rng.normal(0.0, 1.5, size=T)
    ).astype(np.float32)

    # Zeitstempel
    start = pd.Timestamp("2024-01-01")
    timestamps = (start + pd.to_timedelta(hours, unit="h")).to_numpy()

    demand = None
    re_gen = None
    if task == "load_following":
        demand = (
            0.55
            + 0.18 * np.sin(2 * np.pi * (hours % 24 - 7.0) / 24.0)
            + 0.08 * np.sin(2 * np.pi * hours / 168.0)
            + rng.normal(0.0, 0.04, size=T)
        )
        demand = np.clip(demand, 0.15, 0.95).astype(np.float32)

        solar = np.maximum(0.0, np.sin(2 * np.pi * (hours % 24 - 6.0) / 24.0))
        wind = 0.2 + 0.25 * (1.0 + np.sin(2 * np.pi * hours / 72.0))
        re_gen = (0.42 * solar + 0.18 * wind + rng.normal(0.0, 0.02, size=T))
        re_gen = np.clip(re_gen, 0.0, 0.7).astype(np.float32)

    logger.info(f"Synthetische Daten generiert: {T} Schritte, Preis [{price.min():.1f}, {price.max():.1f}] EUR/MWh")

    return MarketData(
        price=price,
        fr_signal=fr_signal,
        reserve_price=reserve_price,
        timestamps=timestamps,
        demand=demand,
        re_gen=re_gen,
        temperature=temperature,
        dt_hours=float(dt_hours),
    )


def load_csv_data(
    path: str,
    columns: Dict[str, str],
    task: str = "arbitrage",
) -> MarketData:
    """Lade Marktdaten aus CSV-Datei.

    Args:
        path: Pfad zur CSV-Datei.
        columns: Spalten-Mapping (config.data.columns).
        task: "arbitrage" oder "load_following".

    Returns:
        MarketData-Objekt.

    Raises:
        FileNotFoundError: Wenn Datei nicht existiert.
        DataValidationError: Bei ungültigen Daten.
    """
    path = Path(path)
    if not path.exists():
        raise FileNotFoundError(f"Datendatei nicht gefunden: {path}")

    logger.info(f"Lade Daten aus: {path}")

    # CSV laden
    try:
        df = pd.read_csv(path)
    except Exception as e:
        raise DataValidationError(f"Fehler beim Laden der CSV-Datei: {e}")

    logger.debug(f"CSV geladen: {len(df)} Zeilen, Spalten: {list(df.columns)}")

    # Pflichtfelder prüfen
    price_col = columns.get("price", "price")
    if price_col not in df.columns:
        raise DataValidationError(
            f"Preis-Spalte '{price_col}' nicht in CSV gefunden. "
            f"Verfügbare Spalten: {list(df.columns)}"
        )

    # Zeitstempel (optional)
    ts_col = columns.get("timestamp", "timestamp")
    timestamps = None
    if ts_col in df.columns:
        try:
            parsed = pd.to_datetime(df[ts_col], errors="raise")
            df = df.assign(_timestamp=parsed).sort_values("_timestamp").reset_index(drop=True)
            timestamps = df["_timestamp"].to_numpy()
        except Exception as e:
            raise DataValidationError(f"Konnte Zeitstempel nicht parsen: {e}")

    price = df[price_col].values.astype(np.float32)
    T = len(price)

    # Alle Warnungen sammeln
    all_warnings = []

    # Preis validieren
    all_warnings.extend(validate_array(
        price, "price",
        allow_nan=False,
        allow_inf=False,
    ))

    # FR-Signal (optional, default = 0)
    fr_col = columns.get("fr_signal", "fr_signal")
    if fr_col in df.columns:
        fr_signal = df[fr_col].values.astype(np.float32)
        # Validieren und clippen
        all_warnings.extend(validate_array(
            fr_signal, "fr_signal",
            expected_length=T,
            allow_nan=False,
            allow_inf=False,
        ))
        fr_signal = np.clip(fr_signal, -1, 1).astype(np.float32)
    else:
        logger.debug(f"Spalte '{fr_col}' nicht gefunden, verwende Nullen")
        fr_signal = np.zeros(T, dtype=np.float32)

    # Reserve-Preis (optional, default = 0)
    res_col = columns.get("reserve_price", "reserve_price")
    if res_col in df.columns:
        reserve_price = df[res_col].values.astype(np.float32)
        all_warnings.extend(validate_array(
            reserve_price, "reserve_price",
            expected_length=T,
            allow_nan=False,
            allow_inf=False,
            min_value=0,
        ))
    else:
        logger.debug(f"Spalte '{res_col}' nicht gefunden, verwende Nullen")
        reserve_price = np.zeros(T, dtype=np.float32)

    # Load-Following spezifische Felder
    demand = None
    re_gen = None
    if task == "load_following":
        demand_col = columns.get("demand", "demand")
        re_col = columns.get("re_gen", "re_gen")

        if demand_col not in df.columns:
            raise DataValidationError(
                f"Für Load-Following ist Spalte '{demand_col}' erforderlich"
            )
        if re_col not in df.columns:
            raise DataValidationError(
                f"Für Load-Following ist Spalte '{re_col}' erforderlich"
            )

        demand = df[demand_col].values.astype(np.float32)
        re_gen = df[re_col].values.astype(np.float32)

        all_warnings.extend(validate_array(demand, "demand", expected_length=T))
        all_warnings.extend(validate_array(re_gen, "re_gen", expected_length=T))

    # Temperatur (optional)
    temperature = None
    temp_col = columns.get("temperature", "temperature")
    if temp_col in df.columns:
        temperature = df[temp_col].values.astype(np.float32)
        all_warnings.extend(validate_array(
            temperature, "temperature",
            expected_length=T,
            allow_nan=False,
            allow_inf=False,
            min_value=-40.0,
            max_value=80.0,
        ))

    dt_hours = infer_dt_hours(timestamps) if timestamps is not None else None

    # Warnungen ausgeben
    for warning in all_warnings:
        logger.warning(warning)

    logger.info(f"Daten geladen: {T} Schritte, Preis [{price.min():.1f}, {price.max():.1f}] EUR/MWh")

    return MarketData(
        price=price,
        fr_signal=fr_signal,
        reserve_price=reserve_price,
        timestamps=timestamps,
        demand=demand,
        re_gen=re_gen,
        temperature=temperature,
        dt_hours=dt_hours,
    )


def load_data(config: Config) -> MarketData:
    """Lade Daten basierend auf Konfiguration.

    Verwendet CSV wenn data.path gesetzt, sonst synthetische Daten.

    Args:
        config: Konfigurationsobjekt.

    Returns:
        MarketData-Objekt.
    """
    if config.data.path is not None and config.data.path != "null":
        return load_csv_data(
            path=config.data.path,
            columns=config.data.columns,
            task=config.task,
        )
    else:
        logger.info(f"Generiere synthetische Daten ({config.synthetic.days} Tage)")
        return generate_synthetic_data(
            days=config.synthetic.days,
            dt_hours=config.env.dt_hours,
            seed=config.synthetic.seed,
            task=config.task,
        )


def split_data(
    data: MarketData,
    train_ratio: float = 0.8,
) -> Tuple[MarketData, MarketData]:
    """Teile Daten in Training und Validation.

    Args:
        data: Eingabedaten.
        train_ratio: Anteil für Training (0-1).

    Returns:
        Tuple aus (train_data, val_data).

    Raises:
        ValueError: Bei ungültigem train_ratio.
    """
    if not 0 < train_ratio < 1:
        raise ValueError(f"train_ratio muss zwischen 0 und 1 liegen, ist {train_ratio}")

    T = len(data)
    split_idx = int(T * train_ratio)

    logger.debug(f"Teile Daten: {split_idx} Training, {T - split_idx} Validation")

    train = MarketData(
        price=data.price[:split_idx],
        fr_signal=data.fr_signal[:split_idx],
        reserve_price=data.reserve_price[:split_idx],
        timestamps=data.timestamps[:split_idx] if data.timestamps is not None else None,
        demand=data.demand[:split_idx] if data.demand is not None else None,
        re_gen=data.re_gen[:split_idx] if data.re_gen is not None else None,
        temperature=data.temperature[:split_idx] if data.temperature is not None else None,
        dt_hours=data.dt_hours,
    )

    val = MarketData(
        price=data.price[split_idx:],
        fr_signal=data.fr_signal[split_idx:],
        reserve_price=data.reserve_price[split_idx:],
        timestamps=data.timestamps[split_idx:] if data.timestamps is not None else None,
        demand=data.demand[split_idx:] if data.demand is not None else None,
        re_gen=data.re_gen[split_idx:] if data.re_gen is not None else None,
        temperature=data.temperature[split_idx:] if data.temperature is not None else None,
        dt_hours=data.dt_hours,
    )

    return train, val


def get_data_statistics(data: MarketData) -> Dict[str, Any]:
    """Berechne Statistiken der Marktdaten.

    Args:
        data: MarketData-Objekt.

    Returns:
        Dictionary mit Statistiken für price, fr_signal, reserve_price.
    """
    stats = {
        "length": len(data),
        "price": {
            "mean": float(np.mean(data.price)),
            "std": float(np.std(data.price)),
            "min": float(np.min(data.price)),
            "max": float(np.max(data.price)),
            "median": float(np.median(data.price)),
        },
        "fr_signal": {
            "mean": float(np.mean(data.fr_signal)),
            "std": float(np.std(data.fr_signal)),
            "min": float(np.min(data.fr_signal)),
            "max": float(np.max(data.fr_signal)),
        },
        "reserve_price": {
            "mean": float(np.mean(data.reserve_price)),
            "max": float(np.max(data.reserve_price)),
        },
        "dt_hours": data.dt_hours,
    }

    # Load-Following Statistiken
    if data.demand is not None:
        stats["demand"] = {
            "mean": float(np.mean(data.demand)),
            "std": float(np.std(data.demand)),
        }
    if data.re_gen is not None:
        stats["re_gen"] = {
            "mean": float(np.mean(data.re_gen)),
            "std": float(np.std(data.re_gen)),
        }
    if data.temperature is not None:
        stats["temperature"] = {
            "mean": float(np.mean(data.temperature)),
            "std": float(np.std(data.temperature)),
            "min": float(np.min(data.temperature)),
            "max": float(np.max(data.temperature)),
        }

    return stats