from datetime import date, datetime, timedelta, timezone

import pytest

import nightscout_client as ns


class FakeResponse:
    def __init__(self, payload):
        self._payload = payload

    def raise_for_status(self):
        pass

    def json(self):
        return self._payload


def test_mgdl_to_mmol_converts_correctly():
    assert ns.mgdl_to_mmol(126.0) == pytest.approx(7.0, abs=0.05)


def test_base_url_requires_nightscout_url(monkeypatch):
    monkeypatch.delenv("NIGHTSCOUT_URL", raising=False)
    with pytest.raises(ns.NightscoutConfigError):
        ns._base_url()


def test_base_url_strips_trailing_slash(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com/")
    assert ns._base_url() == "https://example.com"


def test_auth_prefers_token_over_api_secret(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_TOKEN", "my-token")
    monkeypatch.setenv("NIGHTSCOUT_API_SECRET", "my-secret")
    headers, params = ns._auth()
    assert params == {"token": "my-token"}
    assert headers == {}


def test_auth_hashes_api_secret(monkeypatch):
    monkeypatch.delenv("NIGHTSCOUT_TOKEN", raising=False)
    monkeypatch.setenv("NIGHTSCOUT_API_SECRET", "my-secret")
    headers, params = ns._auth()
    assert params == {}
    assert headers["API-SECRET"] != "my-secret"  # nooit in plaintext
    assert len(headers["API-SECRET"]) == 40  # sha1 hexdigest


def test_fetch_entries_converts_and_filters_by_time(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    monkeypatch.delenv("NIGHTSCOUT_TOKEN", raising=False)
    monkeypatch.delenv("NIGHTSCOUT_API_SECRET", raising=False)

    now = datetime.now(timezone.utc)
    recent = now - timedelta(hours=1)
    too_old = now - timedelta(hours=48)
    payload = [
        {"date": int(recent.timestamp() * 1000), "sgv": 126},
        {"date": int(too_old.timestamp() * 1000), "sgv": 90},
    ]

    monkeypatch.setattr(ns.requests, "get", lambda *a, **k: FakeResponse(payload))

    result = ns.fetch_entries(hours=24)
    assert len(result) == 1
    assert result.iloc[0]["mmol"] == pytest.approx(7.0, abs=0.05)


def test_fetch_entries_handles_empty_response(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    monkeypatch.setattr(ns.requests, "get", lambda *a, **k: FakeResponse([]))

    result = ns.fetch_entries(hours=24)
    assert result.empty
    assert list(result.columns) == ["timestamp", "mmol"]


def test_fetch_treatments_fills_missing_columns(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    now = datetime.now(timezone.utc)
    payload = [
        {"created_at": now.isoformat(), "eventType": "Site Change"},
    ]
    monkeypatch.setattr(ns.requests, "get", lambda *a, **k: FakeResponse(payload))

    result = ns.fetch_treatments(hours=24)
    assert len(result) == 1
    assert result.iloc[0]["eventType"] == "Site Change"
    assert pd_isna(result.iloc[0]["insulin"])
    assert pd_isna(result.iloc[0]["carbs"])


def pd_isna(value):
    import pandas as pd

    return pd.isna(value)


def test_fetch_entries_range_filters_to_date_boundaries(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    monkeypatch.delenv("NIGHTSCOUT_TOKEN", raising=False)
    monkeypatch.delenv("NIGHTSCOUT_API_SECRET", raising=False)

    payload = [
        {"date": int(datetime(2026, 1, 15, 12, 0, tzinfo=timezone.utc).timestamp() * 1000), "sgv": 126},
        {"date": int(datetime(2026, 1, 1, 12, 0, tzinfo=timezone.utc).timestamp() * 1000), "sgv": 90},
        {"date": int(datetime(2026, 2, 1, 12, 0, tzinfo=timezone.utc).timestamp() * 1000), "sgv": 100},
    ]
    monkeypatch.setattr(ns.requests, "get", lambda *a, **k: FakeResponse(payload))

    result = ns.fetch_entries_range(date(2026, 1, 1), date(2026, 1, 31))
    assert len(result) == 2  # de 1 feb-meting valt buiten het bereik
    assert list(result.columns) == ["timestamp", "mmol"]


def test_fetch_entries_range_handles_empty_response(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    monkeypatch.setattr(ns.requests, "get", lambda *a, **k: FakeResponse([]))

    result = ns.fetch_entries_range(date(2026, 1, 1), date(2026, 1, 31))
    assert result.empty


def test_fetch_treatments_range_filters_to_date_boundaries(monkeypatch):
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    payload = [
        {"created_at": "2026-01-15T12:00:00Z", "eventType": "Meal Bolus", "insulin": 4.0, "carbs": 40},
        {"created_at": "2026-02-01T12:00:00Z", "eventType": "Meal Bolus", "insulin": 3.0, "carbs": 30},
    ]
    monkeypatch.setattr(ns.requests, "get", lambda *a, **k: FakeResponse(payload))

    result = ns.fetch_treatments_range(date(2026, 1, 1), date(2026, 1, 31))
    assert len(result) == 1
    assert result.iloc[0]["insulin"] == pytest.approx(4.0)


def _entry(dt, sgv=100):
    return {"date": int(dt.timestamp() * 1000), "sgv": sgv, "dateString": dt.isoformat()}


def test_paginated_get_stops_when_a_short_page_is_returned(monkeypatch):
    """Nightscout kan minder dan _PAGE_SIZE teruggeven omdat er simpelweg niet meer data is.

    Dit was precies de bug: een enkel groot count-verzoek werd stilzwijgend
    afgeknipt. Met paginering moet een pagina die kleiner is dan de gevraagde
    paginagrootte de paginering laten stoppen — dat betekent "geen oudere
    data beschikbaar", niet "er ging iets mis".
    """
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    now = datetime.now(timezone.utc)
    payload = [_entry(now - timedelta(minutes=5 * i)) for i in range(5)]  # << _PAGE_SIZE

    calls = []
    monkeypatch.setattr(
        ns.requests,
        "get",
        lambda *a, **k: (calls.append(k), FakeResponse(payload))[1],
    )

    result = ns._paginated_get("/api/v1/entries/sgv.json", now - timedelta(days=1))
    assert len(result) == 5
    assert len(calls) == 1  # één pagina was genoeg, geen verdere paginering nodig


def test_paginated_get_walks_back_multiple_pages_until_since_is_reached(monkeypatch):
    """De kern-regressietest voor de bug: data die verder terugligt dan één
    pagina (~1000 documenten) moet toch volledig worden opgehaald door
    meerdere pagina's met find[date][$lte] te doorlopen."""
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    now = datetime.now(timezone.utc)

    # 3 volle pagina's (elk _PAGE_SIZE groot, 5 minuten uit elkaar, aflopend in tijd)
    # + een laatste kleinere pagina die de paginering laat stoppen.
    page_size = ns._PAGE_SIZE
    pages = []
    cursor = now
    for _ in range(3):
        page = [_entry(cursor - timedelta(minutes=5 * i)) for i in range(page_size)]
        pages.append(page)
        cursor = cursor - timedelta(minutes=5 * (page_size - 1)) - timedelta(minutes=5)
    pages.append([_entry(cursor - timedelta(minutes=5 * i)) for i in range(10)])

    call_count = {"n": 0}

    def fake_get(*_a, **_k):
        response = FakeResponse(pages[call_count["n"]])
        call_count["n"] += 1
        return response

    monkeypatch.setattr(ns.requests, "get", fake_get)

    since = now - timedelta(days=365)  # ruim voorbij alle test-pagina's
    result = ns._paginated_get("/api/v1/entries/sgv.json", since)

    assert call_count["n"] == 4  # 3 volle pagina's + 1 korte slotpagina
    assert len(result) == 3 * page_size + 10


def test_paginated_get_stops_at_since_boundary_without_fetching_further(monkeypatch):
    """Zodra een pagina data ouder dan `since` bevat, hoeft er geen volgende
    pagina meer opgehaald te worden, ook al was de pagina zelf vol."""
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    now = datetime.now(timezone.utc)
    page_size = ns._PAGE_SIZE
    # deze ene pagina spant ruim meer dan een dag, dus bevat al data voorbij `since`
    page = [_entry(now - timedelta(minutes=5 * i)) for i in range(page_size)]

    calls = {"n": 0}

    def fake_get(*_a, **_k):
        calls["n"] += 1
        return FakeResponse(page)

    monkeypatch.setattr(ns.requests, "get", fake_get)

    since = now - timedelta(hours=6)  # ruim binnen de eerste pagina
    result = ns._paginated_get("/api/v1/entries/sgv.json", since)

    assert calls["n"] == 1
    assert len(result) == page_size  # filtering op since gebeurt pas in _entries_since, niet hier


def test_fetch_entries_range_retrieves_data_spanning_multiple_pages(monkeypatch):
    """End-to-end regressietest: een 90-dagenrapport moet echt 90 dagen data
    krijgen, niet stilzwijgend worden afgeknipt tot de meest recente pagina."""
    monkeypatch.setenv("NIGHTSCOUT_URL", "https://example.com")
    monkeypatch.delenv("NIGHTSCOUT_TOKEN", raising=False)
    monkeypatch.delenv("NIGHTSCOUT_API_SECRET", raising=False)

    end_date = date(2026, 3, 31)
    start_date = date(2026, 1, 1)  # 90 dagen

    # simuleer Nightscout: elke 5 minuten een meting over de volle periode,
    # opgeknipt in door de server afgedwongen pagina's van _PAGE_SIZE
    until = datetime.combine(end_date, datetime.max.time(), tzinfo=timezone.utc)
    since = datetime.combine(start_date, datetime.min.time(), tzinfo=timezone.utc)
    all_entries = []
    t = until
    while t >= since:
        all_entries.append(_entry(t))
        t -= timedelta(minutes=5)

    page_size = ns._PAGE_SIZE

    def fake_get(*_args, **kwargs):
        cursor_ms = kwargs["params"].get("find[date][$lte]")
        pool = all_entries if cursor_ms is None else [e for e in all_entries if e["date"] <= cursor_ms]
        return FakeResponse(pool[:page_size])

    monkeypatch.setattr(ns.requests, "get", fake_get)

    result = ns.fetch_entries_range(start_date, end_date)
    assert len(result) == len(all_entries)
    assert result["timestamp"].min().date() == start_date
    assert result["timestamp"].max().date() == end_date