from datetime import datetime

import httpx
import pytest

from app.dashboard import pyramid_rows
from app.models import Account
from app.worldquant import WqClient, WqError


def pyramid(**extra):
    return {"category": {"id": "analyst", "name": "Analyst"}, "region": "USA", "delay": 1, **extra}


async def test_pyramid_read_paths_and_404_fallback(settings):
    calls = []

    def upstream(request):
        calls.append(request)
        assert request.method == "GET"
        if request.url.path.endswith("pyramid-multipliers"):
            return httpx.Response(200, json={"pyramids": [pyramid(multiplier=1.3)]})
        if request.url.path != "/activities/pyramid-alphas":
            return httpx.Response(404)
        return httpx.Response(200, json={"pyramids": [pyramid(alphaCount=0)]})

    client = WqClient(settings, transport=httpx.MockTransport(upstream))
    client.credentials, client.authenticated = ("test@example.com", "test-only"), True
    try:
        assert (await client.get_pyramid_multipliers())["pyramids"][0]["multiplier"] == 1.3
        data = await client.get_pyramid_alphas("2026-07-01", "2026-07-31")
        assert data["pyramids"][0]["alphaCount"] == 0
        assert [r.url.path for r in calls] == [
            "/users/self/activities/pyramid-multipliers", "/users/self/activities/pyramid-alphas",
            "/users/self/pyramid/alphas", "/activities/pyramid-alphas",
        ]
        for request in calls[1:]:
            assert dict(request.url.params) == {
                "startDate": "2026-07-01", "endDate": "2026-07-31",
            }
    finally:
        await client.close()


@pytest.mark.parametrize("status,code,expected_calls", [(403, "access_denied", 1), (404, "not_found", 3)])
async def test_pyramid_errors_preserve_access_boundary(settings, status, code, expected_calls):
    calls = []

    def upstream(request):
        calls.append(request)
        return httpx.Response(status, json={"detail": "private-upstream-body"})

    client = WqClient(settings, transport=httpx.MockTransport(upstream))
    client.credentials, client.authenticated = ("test@example.com", "test-only"), True
    try:
        with pytest.raises(WqError) as error:
            await client.get_pyramid_alphas()
        assert error.value.code == code
        assert "private-upstream-body" not in str(error.value)
        assert len(calls) == expected_calls
        assert all(not request.url.query for request in calls)
    finally:
        await client.close()


def test_pyramid_normalization_preserves_zero_unknown_and_allowlist():
    rows = pyramid_rows({"pyramids": [pyramid(alphaCount=0, token="private"), pyramid()]}, "alphaCount")
    assert rows[0].value == 0 and rows[1].value is None
    assert "private" not in str(rows)
    assert pyramid_rows({"pyramids": []}, "multiplier") == []


@pytest.mark.parametrize("data", [
    {}, {"pyramids": {}}, {"pyramids": [None]},
    {"pyramids": [pyramid(alphaCount="3")]},
    {"pyramids": [pyramid(alphaCount=True)]},
    {"pyramids": [pyramid(alphaCount=-1)]},
    {"pyramids": [pyramid(alphaCount=2.5)]},
    {"pyramids": [pyramid(alphaCount=float("nan"))]},
    {"pyramids": [pyramid(category=None)]},
])
def test_pyramid_unknown_shapes_are_not_empty_success(data):
    with pytest.raises(WqError, match="格式无法识别"):
        pyramid_rows(data, "alphaCount")


async def test_dashboard_auth_connection_dates_and_independent_errors(app, client, logged_in, monkeypatch):
    calls = []

    async def read_alphas(start_date=None, end_date=None):
        calls.append((start_date, end_date))
        return {"pyramids": [pyramid(alphaCount=7)], "token": "private"}

    async def read_multipliers():
        raise WqError("无权访问该平台资源", "access_denied")

    monkeypatch.setattr(app.state.runner.client, "get_pyramid_alphas", read_alphas)
    monkeypatch.setattr(app.state.runner.client, "get_pyramid_multipliers", read_multipliers)
    prefix = "/api/v1/dashboard"
    assert (await logged_in.get(f"{prefix}/pyramid-alphas")).status_code == 409
    assert calls == []
    async with app.state.sessions.begin() as db:
        account = await db.get(Account, 1)
        account.connection_status, account.wq_user_id = "connected", "TEST_USER"
    for query in ("start_date=bad", "start_date=2026-08-02&end_date=2026-08-01"):
        assert (await logged_in.get(f"{prefix}/pyramid-alphas?{query}")).status_code == 422
    assert calls == []
    response = await logged_in.get(f"{prefix}/pyramid-alphas?start_date=2026-07-01&end_date=2026-07-31")
    assert response.status_code == 200
    assert calls == [("2026-07-01", "2026-07-31")]
    result = response.json()
    assert result["items"][0] == {
        "region": "USA", "delay": 1, "category_id": "analyst", "category_name": "Analyst", "value": 7,
    }
    assert result["start_date"] == "2026-07-01" and result["end_date"] == "2026-07-31"
    assert datetime.fromisoformat(result["fetched_at"]).tzinfo is not None
    assert "private" not in response.text
    assert (await logged_in.get(f"{prefix}/pyramid-multipliers")).status_code == 502
    assert (await logged_in.get("/api/v1/auth/me")).status_code == 200
    await logged_in.get(f"{prefix}/pyramid-alphas")
    assert calls[-1] == (None, None)
    await logged_in.get(f"{prefix}/pyramid-alphas?end_date=2026-07-31")
    assert calls[-1] == (None, "2026-07-31")
    client.cookies.clear()
    for endpoint in ("pyramid-alphas", "pyramid-multipliers"):
        assert (await client.get(f"{prefix}/{endpoint}")).status_code == 401


def activity_data(rows, properties=None):
    return {"records": {"schema": {"properties": properties or ["date", "value"]}, "records": rows}}


def test_activity_calendar_preserves_missing_zero_and_column_order():
    from app.dashboard import activity_snapshot

    at = datetime.fromisoformat("2026-09-11T02:00:00+00:00")
    data = activity_data([
        [3, "2026-09-10", "private"], [0, "2026-09-09", "private"],
        [99, "2026-09-11", "future"], [15, "2025-01-01", "old"],
    ], [{"name": "value"}, {"name": "date"}, {"name": "secret"}])
    result = activity_snapshot(data, 14, at)
    assert result.today.isoformat() == "2026-09-10"
    assert len(result.items) == 14 and result.items[0].date.isoformat() == "2026-08-28"
    assert [day.count for day in result.items[-3:]] == [None, 0, 3]
    assert "private" not in result.model_dump_json()
    assert result.timezone == "America/New_York"
    assert len(activity_snapshot(data, 182, at).items) == 182


@pytest.mark.parametrize("timestamp,today", [
    ("2026-03-08T04:59:59+00:00", "2026-03-07"),
    ("2026-03-08T05:00:00+00:00", "2026-03-08"),
    ("2026-03-09T04:00:00+00:00", "2026-03-09"),
    ("2026-11-01T04:00:00+00:00", "2026-11-01"),
    ("2026-11-02T04:59:59+00:00", "2026-11-01"),
    ("2026-11-02T05:00:00+00:00", "2026-11-02"),
    ("2027-01-01T04:00:00+00:00", "2026-12-31"),
])
def test_activity_uses_eastern_calendar_across_dst_and_year(timestamp, today):
    from app.dashboard import activity_snapshot

    result = activity_snapshot(activity_data([]), 14, datetime.fromisoformat(timestamp))
    assert result.today.isoformat() == today
    assert all(day.count is None for day in result.items)
    assert len({day.date for day in result.items}) == 14
    assert (result.items[-1].date - result.items[0].date).days == 13


@pytest.mark.parametrize("data", [
    {}, {"records": None}, activity_data([None]), activity_data([["2026-09-10"]]),
    activity_data([["invalid", 1]]), activity_data([["20260910", 1]]),
    activity_data([["2026-09-10", True]]), activity_data([["2026-09-10", -1]]),
    activity_data([["2026-09-10", 1.5]]), activity_data([["2026-09-10", "3"]]),
    activity_data([["2026-09-10", 1], ["2026-09-10", 2]]),
    activity_data([], ["date", "date", "value"]), activity_data([], ["date"]),
])
def test_activity_rejects_malformed_or_ambiguous_counts(data):
    from app.dashboard import activity_snapshot

    with pytest.raises(WqError, match="格式无法识别"):
        activity_snapshot(data, 14, datetime.fromisoformat("2026-09-11T12:00:00+00:00"))


async def test_activity_endpoint_auth_connection_and_independent_failures(app, client, logged_in, monkeypatch):
    calls = []

    async def read(path):
        calls.append(path)
        if path.endswith("simulations"):
            raise WqError("无权访问该平台资源", "access_denied")
        return activity_data([])

    monkeypatch.setattr(app.state.runner.client, "get", read)
    prefix = "/api/v1/dashboard/activity"
    assert (await logged_in.get(f"{prefix}/submissions")).status_code == 409
    assert not calls
    async with app.state.sessions.begin() as db:
        account = await db.get(Account, 1)
        account.connection_status, account.wq_user_id = "connected", "TEST_USER"
    assert (await logged_in.get(f"{prefix}/arbitrary")).status_code == 422
    assert not calls
    response = await logged_in.get(f"{prefix}/submissions")
    assert response.status_code == 200 and len(response.json()["items"]) == 182
    assert all(day["count"] is None for day in response.json()["items"])
    assert (await logged_in.get(f"{prefix}/simulations")).status_code == 502
    assert calls == ["/users/self/activities/submissions", "/users/self/activities/simulations"]
    assert (await logged_in.get("/api/v1/auth/me")).status_code == 200

    async def waiting(path):
        raise WqError("需要人工验证", "verification_required")

    monkeypatch.setattr(app.state.runner.client, "get", waiting)
    assert (await logged_in.get(f"{prefix}/submissions")).status_code == 409
    client.cookies.clear()
    assert (await client.get(f"{prefix}/submissions")).status_code == 401
    assert (await client.get(f"{prefix}/simulations")).status_code == 401