"""Tests for GET /api/gestion4sat/dashboard datos_completitud field."""
import os
import pytest
import requests

BASE_URL = os.environ.get("REACT_APP_BACKEND_URL", "https://doc-manager-111.preview.emergentagent.com").rstrip("/")

ADMIN_EMAIL = "admin4sat@demo.com"
ADMIN_PASSWORD = "Test1234!"


@pytest.fixture(scope="module")
def token():
    r = requests.post(
        f"{BASE_URL}/api/auth/login",
        json={"email": ADMIN_EMAIL, "password": ADMIN_PASSWORD},
        timeout=15,
    )
    assert r.status_code == 200, f"login failed: {r.status_code} {r.text}"
    data = r.json()
    tok = data.get("token") or data.get("access_token")
    assert tok, f"no token in login response: {data}"
    return tok


@pytest.fixture(scope="module")
def auth_headers(token):
    return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}


@pytest.fixture(scope="module")
def dashboard(auth_headers):
    r = requests.get(f"{BASE_URL}/api/gestion4sat/dashboard", headers=auth_headers, timeout=20)
    assert r.status_code == 200, f"dashboard failed: {r.status_code} {r.text}"
    return r.json()


class TestDashboardCompletitudShape:
    """Verify datos_completitud object exists with all required fields."""

    def test_dashboard_has_datos_completitud(self, dashboard):
        assert "datos_completitud" in dashboard, f"missing key. Keys: {list(dashboard.keys())}"
        assert isinstance(dashboard["datos_completitud"], dict)

    def test_empresas_completas_field(self, dashboard):
        dc = dashboard["datos_completitud"]
        assert "empresas_completas" in dc
        assert isinstance(dc["empresas_completas"], int)
        assert dc["empresas_completas"] >= 0

    def test_empresas_sin_razon_field(self, dashboard):
        dc = dashboard["datos_completitud"]
        assert "empresas_sin_razon" in dc
        assert isinstance(dc["empresas_sin_razon"], int)
        assert dc["empresas_sin_razon"] >= 0

    def test_empresas_sii_no_encontrado_field(self, dashboard):
        dc = dashboard["datos_completitud"]
        assert "empresas_sii_no_encontrado" in dc
        assert isinstance(dc["empresas_sii_no_encontrado"], int)
        assert dc["empresas_sii_no_encontrado"] >= 0

    def test_porcentaje_field(self, dashboard):
        dc = dashboard["datos_completitud"]
        assert "porcentaje" in dc
        p = dc["porcentaje"]
        assert isinstance(p, (int, float))
        assert 0 <= p <= 100, f"porcentaje out of range: {p}"

    def test_ultimo_enriquecimiento_key_present(self, dashboard):
        dc = dashboard["datos_completitud"]
        assert "ultimo_enriquecimiento" in dc, "key must be present (may be None)"
        ue = dc["ultimo_enriquecimiento"]
        # May be None if never enriched, else dict with expected sub-keys
        assert ue is None or isinstance(ue, dict)
        if isinstance(ue, dict):
            # Should contain at least estado, actualizados, finished_at according to spec
            for k in ("estado", "actualizados", "finished_at"):
                assert k in ue, f"ultimo_enriquecimiento missing '{k}'. Got: {list(ue.keys())}"


class TestDashboardCompletitudMath:
    """Verify porcentaje calculation is correct."""

    def test_porcentaje_calculation(self, dashboard):
        dc = dashboard["datos_completitud"]
        total = dashboard["total_empresas"]
        completas = dc["empresas_completas"]
        expected = round((completas / total * 100) if total > 0 else 100)
        assert dc["porcentaje"] == expected, (
            f"porcentaje={dc['porcentaje']} but expected {expected} "
            f"(completas={completas}, total={total})"
        )

    def test_counts_sum_matches_total(self, dashboard):
        dc = dashboard["datos_completitud"]
        total = dashboard["total_empresas"]
        s = dc["empresas_completas"] + dc["empresas_sin_razon"] + dc["empresas_sii_no_encontrado"]
        assert s == total, (
            f"empresas_completas + empresas_sin_razon + empresas_sii_no_encontrado = {s} "
            f"but total_empresas = {total}"
        )


class TestDashboardRegression:
    """Existing KPIs still returned."""

    @pytest.mark.parametrize("field", [
        "total_empresas", "total_dispositivos", "dispositivos_activos",
        "dispositivos_stock", "dispositivos_online", "dispositivos_offline",
        "total_servicios", "servicios_pendientes", "alertas_pendientes",
        "top_empresas",
    ])
    def test_kpi_field_present(self, dashboard, field):
        assert field in dashboard, f"missing regression field '{field}'. Keys: {list(dashboard.keys())}"

    def test_top_empresas_is_list(self, dashboard):
        assert isinstance(dashboard["top_empresas"], list)


class TestDashboardAuth:
    def test_no_auth_rejected(self):
        r = requests.get(f"{BASE_URL}/api/gestion4sat/dashboard", timeout=15)
        assert r.status_code in (401, 403), f"expected 401/403, got {r.status_code}"


if __name__ == "__main__":
    pytest.main([__file__, "-v"])