"""Strompreise und Marktdaten — Europa.

Nutzt:
- ENTSO-E Transparency Platform (optional, mit Key) für EU-Day-Ahead-Preise
- Bundesnetzagentur SMARD (kein Key) für deutsche Großhandelspreise
"""

import httpx
from datetime import datetime, timedelta
from mcp.server.fastmcp import FastMCP
from src.config import SMARD_BASE, ENTSOE_BASE, ENTSOE_TOKEN

# SMARD Indikator für Großhandelspreis
SMARD_PRICE_INDICATOR = 4169  # Großhandelsstrompreis Deutschland


def register_price_tools(mcp: FastMCP) -> None:
    """Registriert Strompreis-Tools."""

    @mcp.tool()
    async def get_germany_wholesale_price() -> dict:
        """Aktueller Großhandelsstrompreis Deutschland (EUR/MWh) von SMARD.

        Keine Registrierung nötig — direkt aus Bundesnetzagentur-Daten.

        Returns:
            Aktueller Preis in EUR/MWh, Zeitraum, Quelle.
        """
        async with httpx.AsyncClient(timeout=20) as client:
            # Letzte 7 Tage abrufen (Stundenwerte)
            url = (
                f"{SMARD_BASE}/{SMARD_PRICE_INDICATOR}"
                f"/index_hour.json?language=de"
            )
            resp = await client.get(url)
            resp.raise_for_status()
            data = resp.json()
            timestamps = data.get("timestamps", [])
            if not timestamps:
                return {"error": "Keine Preis-Daten verfügbar"}

            # Neueste Datenpunkte holen
            latest_ts = timestamps[-1]
            values_url = (
                f"{SMARD_BASE}/{SMARD_PRICE_INDICATOR}"
                f"/{latest_ts}_hour.json?language=de"
            )
            values_resp = await client.get(values_url)
            values_resp.raise_for_status()
            values_data = values_resp.json()
            series = values_data.get("series", [])

            # Letzte nicht-None Werte
            recent = [(ts, val) for ts, val in series if val is not None][-24:]

            if not recent:
                return {"error": "Keine aktuellen Preisdaten"}

            latest_ts_ms, latest_price = recent[-1]
            prices_eur_mwh = [val for _, val in recent]
            avg_24h = sum(prices_eur_mwh) / len(prices_eur_mwh)

            return {
                "aktueller_preis_eur_mwh": latest_price,
                "zeitpunkt": datetime.fromtimestamp(latest_ts_ms / 1000).isoformat(),
                "durchschnitt_24h_eur_mwh": round(avg_24h, 2),
                "minimum_24h": min(prices_eur_mwh),
                "maximum_24h": max(prices_eur_mwh),
                "stundenpreise_letzt_24h": [
                    {
                        "zeit": datetime.fromtimestamp(ts / 1000).strftime("%H:%M"),
                        "preis_eur_mwh": val,
                    }
                    for ts, val in recent
                ],
                "quelle": "SMARD — Bundesnetzagentur",
            }

    @mcp.tool()
    async def get_eu_day_ahead_prices(country_code: str = "DE") -> dict:
        """Day-Ahead Strompreise für EU-Länder (benötigt ENTSOE_TOKEN).

        Args:
            country_code: EIC-Ländercode, z.B. 'DE', 'FR', 'ES', 'IT', 'PL'.

        Returns:
            Stündliche Day-Ahead Preise für morgen in EUR/MWh.
            Benötigt ENTSOE_TOKEN aus https://transparency.entsoe.eu registrieren.
        """
        if not ENTSOE_TOKEN:
            return {
                "error": "ENTSOE_TOKEN nicht gesetzt.",
                "hinweis": "Kostenlosen Token unter https://transparency.entsoe.eu registrieren.",
                "alternative": "get_germany_wholesale_price() für DE-Daten ohne Key verfügbar.",
            }

        # EIC-Codes für Gebotszonen
        eic_codes = {
            "DE": "10Y1001A1001A83F",
            "FR": "10YFR-RTE------C",
            "ES": "10YES-REE------0",
            "IT": "10YIT-GRTN-----B",
            "PL": "10YPL-AREA-----S",
            "NL": "10YNL----------L",
            "BE": "10YBE----------2",
            "AT": "10YAT-APG------L",
            "CH": "10YCH-SWISSGRIDZ",
            "NO": "10YNO-0--------C",
        }

        eic = eic_codes.get(country_code.upper())
        if not eic:
            return {
                "error": f"Land '{country_code}' nicht bekannt.",
                "verfügbare_länder": list(eic_codes.keys()),
            }

        tomorrow = datetime.now() + timedelta(days=1)
        period_start = tomorrow.strftime("%Y%m%d0000")
        period_end = tomorrow.strftime("%Y%m%d2300")

        async with httpx.AsyncClient(timeout=20) as client:
            resp = await client.get(
                ENTSOE_BASE,
                params={
                    "securityToken": ENTSOE_TOKEN,
                    "documentType": "A44",
                    "in_Domain": eic,
                    "out_Domain": eic,
                    "periodStart": period_start,
                    "periodEnd": period_end,
                },
            )
            if resp.status_code != 200:
                return {"error": f"ENTSO-E Fehler: {resp.status_code}", "detail": resp.text[:200]}

            # XML-Antwort als Text zurückgeben (Parsing vereinfacht)
            return {
                "land": country_code,
                "datum": tomorrow.strftime("%Y-%m-%d"),
                "raw_xml": resp.text[:2000],
                "hinweis": "XML-Antwort enthält stündliche Preise in EUR/MWh",
            }
