from __future__ import annotations

import json
import tempfile
import unittest
from datetime import datetime
from pathlib import Path
from typing import Any
from zoneinfo import ZoneInfo

from source_activity_runtime.exceptions import ProviderDataError
from source_activity_runtime.models import ExtractionContext, SourceRequest
from source_activity_runtime.providers.shop2topup import Shop2TopupProvider


class FakeResponse:
    def __init__(
        self,
        status_code: int,
        *,
        payload: Any = None,
        text: str = "",
        headers: dict[str, str] | None = None,
    ) -> None:
        self.status_code = status_code
        self._payload = payload
        self.text = text
        self.headers = headers or {}

    def json(self) -> Any:
        if isinstance(self._payload, BaseException):
            raise self._payload
        return self._payload


class FakeSession:
    def __init__(self, responses: list[FakeResponse]) -> None:
        self.responses = list(responses)
        self.calls: list[dict[str, Any]] = []

    def get(self, url: str, **kwargs: Any) -> FakeResponse:
        self.calls.append({"url": url, **kwargs})
        if not self.responses:
            raise AssertionError("No fake response left")
        return self.responses.pop(0)


def order_row(
    order_id: str,
    *,
    status: str = "completed",
    created_at: str = "2026-07-18T05:30:00Z",
    charged_amount: str = "0.950000",
    quantity: int = 1,
    currency: str = "USD",
    player_id: str | None = "123456789",
) -> dict[str, Any]:
    row = {
        "order_id": order_id,
        "status": status,
        "subcategory_name": "FF 100 Diamonds",
        "quantity": quantity,
        "charged_amount": charged_amount,
        "currency": currency,
        "created_at": created_at,
    }
    if player_id is not None:
        row["player_id"] = player_id
    return row


def page_payload(
    orders: list[dict[str, Any]],
    *,
    page: int,
    limit: int = 100,
    total: int | None = None,
    total_pages: int | None = None,
) -> dict[str, Any]:
    if total is None:
        total = len(orders)
    if total_pages is None:
        total_pages = 0 if total == 0 else (total + limit - 1) // limit
    return {
        "success": True,
        "orders": orders,
        "pagination": {
            "page": page,
            "limit": limit,
            "total": total,
            "total_pages": total_pages,
        },
    }


def make_context(root: Path, *, request_options: dict[str, Any] | None = None) -> ExtractionContext:
    tz = ZoneInfo("Asia/Damascus")
    source_directory = root / "shop2topup"
    source_directory.mkdir(parents=True, exist_ok=True)
    return ExtractionContext(
        job_id="shop2topup-test",
        audit_run_id="audit-test",
        period_from=datetime(2026, 7, 18, 8, 0, 0, tzinfo=tz),
        period_to=datetime(2026, 7, 18, 10, 0, 0, tzinfo=tz),
        source=SourceRequest(
            source="shop2topup",
            source_account_key="e" * 64,
            service_source_id=20,
            credential_id=26,
            account_label="shop2topup",
            credentials={"api_token": "key.secret"},
            provider_options={
                "base_url": "https://v2sandbox.shop2topup.com/api/endpoints/v1",
                "currency_code": "USD",
                "request_options": request_options or {},
            },
        ),
        source_directory=source_directory,
        checkpoint_path=root / "checkpoint.json",
    )


class Shop2TopupProviderTests(unittest.TestCase):
    def test_imports_documented_statuses_and_exact_identifiers(self) -> None:
        rows = [
            order_row("uuid-completed", status="completed", charged_amount="0.95"),
            order_row("uuid-pending", status="pending", charged_amount="1.25"),
            order_row("uuid-refunded", status="refunded", charged_amount="2.50"),
            order_row("uuid-partial", status="partial", charged_amount="3.75"),
            order_row("uuid-failed", status="failed", charged_amount="4.00"),
            order_row(
                "uuid-outside",
                status="completed",
                created_at="2026-07-18T04:59:59Z",
            ),
        ]
        session = FakeSession([
            FakeResponse(200, payload=page_payload(rows, page=1, total=6, total_pages=1))
        ])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            records = list(provider.iter_records(make_context(Path(tmp))))
            metadata = provider.result_metadata()

        self.assertEqual(5, len(records))
        by_id = {record.provider_transaction_id: record for record in records}
        self.assertEqual("completed", by_id["uuid-completed"].provider_status)
        self.assertEqual("pending", by_id["uuid-pending"].provider_status)
        self.assertEqual("failed", by_id["uuid-refunded"].provider_status)
        self.assertEqual("partial", by_id["uuid-partial"].provider_status)
        self.assertEqual("failed", by_id["uuid-failed"].provider_status)
        self.assertEqual("0.95", str(by_id["uuid-completed"].cost_amount))
        self.assertIsNone(by_id["uuid-completed"].amount)
        self.assertEqual("uuid-completed", by_id["uuid-completed"].provider_reference)
        self.assertEqual("order:uuid-completed", by_id["uuid-completed"].provider_record_key)
        self.assertEqual("123456789", by_id["uuid-completed"].subscriber_identifier)
        self.assertEqual(
            "123456789",
            by_id["uuid-completed"].raw_payload["reconciliation_identifiers"]["player_id"],
        )
        self.assertEqual(1, metadata["rows_outside_period"])
        self.assertEqual(5, metadata["rows_in_period"])
        self.assertTrue(metadata["pagination_verified"])
        self.assertEqual(
            "2026-07-18T04:59:59.000000Z",
            session.calls[0]["params"]["created_after"],
        )
        self.assertEqual(
            "2026-07-18T07:00:00.000000Z",
            session.calls[0]["params"]["created_before"],
        )
        self.assertEqual("Bearer key.secret", session.calls[0]["headers"]["Authorization"])

    def test_fetches_all_pages_and_verifies_total(self) -> None:
        page1 = [order_row(f"uuid-{index:03d}") for index in range(100)]
        page2 = [order_row(f"uuid-{index:03d}") for index in range(100, 103)]
        session = FakeSession([
            FakeResponse(
                200,
                payload=page_payload(page1, page=1, total=103, total_pages=2),
                headers={"X-RateLimit-Remaining": "1"},
            ),
            FakeResponse(
                200,
                payload=page_payload(page2, page=2, total=103, total_pages=2),
                headers={"X-RateLimit-Remaining": "0", "X-RateLimit-Reset": "9999999999"},
            ),
        ])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session, sleeper=lambda _: None)
            records = list(provider.iter_records(make_context(Path(tmp))))
            metadata = provider.result_metadata()

        self.assertEqual(103, len(records))
        self.assertEqual(2, metadata["pages_fetched"])
        self.assertEqual(103, metadata["provider_total_results"])
        self.assertEqual(103, metadata["unique_orders"])
        self.assertEqual([1, 2], [call["params"]["page"] for call in session.calls])

    def test_429_uses_retry_after_and_retries_same_page(self) -> None:
        waits: list[float] = []
        session = FakeSession([
            FakeResponse(429, payload={"success": False}, headers={"Retry-After": "2"}),
            FakeResponse(200, payload=page_payload([], page=1, total=0, total_pages=0)),
        ])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session, sleeper=waits.append)
            records = list(provider.iter_records(make_context(Path(tmp))))
            metadata = provider.result_metadata()

        self.assertEqual([], records)
        self.assertEqual([2.0], waits)
        self.assertTrue(metadata["coverage_verified"])
        self.assertTrue(metadata["zero_records_authoritative"])
        self.assertEqual("verified_complete_filtered_period", metadata["coverage_policy"])
        self.assertEqual(1, metadata["http_retries"])
        self.assertEqual(1, metadata["rate_limit_waits"])
        self.assertEqual(2, len(session.calls))

    def test_duplicate_order_id_across_pages_fails(self) -> None:
        session = FakeSession([
            FakeResponse(
                200,
                payload=page_payload([order_row("same-id")], page=1, limit=1, total=2, total_pages=2),
                headers={"X-RateLimit-Remaining": "1"},
            ),
            FakeResponse(
                200,
                payload=page_payload([order_row("same-id")], page=2, limit=1, total=2, total_pages=2),
            ),
        ])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp), request_options={"page_limit": 1})))

    def test_inconsistent_total_fails(self) -> None:
        session = FakeSession([
            FakeResponse(
                200,
                payload=page_payload([order_row("id-1")], page=1, limit=1, total=2, total_pages=2),
                headers={"X-RateLimit-Remaining": "1"},
            ),
            FakeResponse(
                200,
                payload=page_payload([order_row("id-2")], page=2, limit=1, total=3, total_pages=3),
            ),
        ])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp), request_options={"page_limit": 1})))

    def test_unknown_status_fails_without_guessing(self) -> None:
        session = FakeSession([
            FakeResponse(
                200,
                payload=page_payload([order_row("id-new", status="mystery")], page=1),
            )
        ])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp))))

    def test_accepts_nested_data_envelope_observed_in_project(self) -> None:
        payload = {
            "success": True,
            "data": {
                "success": True,
                "data": {
                    "orders": [order_row("nested-order")],
                    "pagination": {
                        "page": 1,
                        "limit": 100,
                        "total": 1,
                        "total_pages": 1,
                    },
                },
            },
        }
        session = FakeSession([FakeResponse(200, payload=payload)])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            records = list(provider.iter_records(make_context(Path(tmp))))
            metadata = provider.result_metadata()

        self.assertEqual(["nested-order"], [record.provider_transaction_id for record in records])
        self.assertEqual(["$.data.data"], metadata["response_envelope_paths"])
        self.assertEqual(["orders"], metadata["response_orders_keys"])

    def test_accepts_nested_collection_data_with_sibling_pagination(self) -> None:
        payload = {
            "success": True,
            "data": {
                "success": True,
                "data": [order_row("nested-list-order")],
                "pagination": {
                    "page": 1,
                    "limit": 100,
                    "total": 1,
                    "total_pages": 1,
                },
            },
        }
        session = FakeSession([FakeResponse(200, payload=payload)])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            records = list(provider.iter_records(make_context(Path(tmp))))
            metadata = provider.result_metadata()

        self.assertEqual(["nested-list-order"], [record.provider_transaction_id for record in records])
        self.assertEqual(["$.data"], metadata["response_envelope_paths"])
        self.assertEqual(["data"], metadata["response_orders_keys"])

    def test_nested_success_false_fails_safely(self) -> None:
        payload = {
            "success": True,
            "data": {
                "success": False,
                "data": {
                    "orders": [],
                    "pagination": {
                        "page": 1,
                        "limit": 100,
                        "total": 0,
                        "total_pages": 0,
                    },
                },
            },
        }
        session = FakeSession([FakeResponse(200, payload=payload)])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            with self.assertRaisesRegex(ProviderDataError, "success!=true"):
                list(provider.iter_records(make_context(Path(tmp))))

    def test_malformed_response_is_saved_before_shape_failure(self) -> None:
        payload = {
            "success": True,
            "data": {
                "message": "collection wrapper without rows",
            },
        }
        session = FakeSession([FakeResponse(200, payload=payload)])

        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            provider = Shop2TopupProvider(session=session)
            with self.assertRaisesRegex(ProviderDataError, "no supported orders/pagination payload"):
                list(provider.iter_records(make_context(root)))

            raw_path = root / "shop2topup" / "raw" / "orders.page-000001.json"
            self.assertTrue(raw_path.is_file())
            stored = json.loads(raw_path.read_text(encoding="utf-8"))
            self.assertEqual(payload, stored["response"])
            self.assertEqual("dict", stored["response_shape"]["$"]["data"])
            self.assertNotIn("Authorization", json.dumps(stored))

    def test_derives_total_pages_when_null_for_empty_response(self) -> None:
        payload = page_payload([], page=1, total=0, total_pages=0)
        payload["pagination"]["total_pages"] = None
        session = FakeSession([FakeResponse(200, payload=payload)])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            records = list(provider.iter_records(make_context(Path(tmp))))
            metadata = provider.result_metadata()

        self.assertEqual([], records)
        self.assertTrue(metadata["pagination_verified"])
        self.assertEqual(0, metadata["provider_total_pages"])
        self.assertEqual(
            ["derived_from_total_and_limit"],
            metadata["pagination_total_pages_sources"],
        )

    def test_derives_missing_total_pages_and_still_fetches_every_page(self) -> None:
        first = page_payload(
            [order_row("derived-1")],
            page=1,
            limit=1,
            total=2,
            total_pages=2,
        )
        second = page_payload(
            [order_row("derived-2")],
            page=2,
            limit=1,
            total=2,
            total_pages=2,
        )
        first["pagination"].pop("total_pages")
        second["pagination"].pop("total_pages")
        session = FakeSession([
            FakeResponse(200, payload=first),
            FakeResponse(200, payload=second),
        ])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            records = list(
                provider.iter_records(
                    make_context(Path(tmp), request_options={"page_limit": 1})
                )
            )
            metadata = provider.result_metadata()

        self.assertEqual(
            ["derived-1", "derived-2"],
            [record.provider_transaction_id for record in records],
        )
        self.assertEqual([1, 2], [call["params"]["page"] for call in session.calls])
        self.assertEqual(2, metadata["provider_total_pages"])
        self.assertEqual(
            [
                "derived_from_total_and_limit",
                "derived_from_total_and_limit",
            ],
            metadata["pagination_total_pages_sources"],
        )

    def test_invalid_non_null_total_pages_still_fails_safely(self) -> None:
        payload = page_payload([], page=1, total=0, total_pages=0)
        payload["pagination"]["total_pages"] = {"unexpected": True}
        session = FakeSession([FakeResponse(200, payload=payload)])

        with tempfile.TemporaryDirectory() as tmp:
            provider = Shop2TopupProvider(session=session)
            with self.assertRaisesRegex(
                ProviderDataError,
                "pagination.total_pages must be an integer",
            ):
                list(provider.iter_records(make_context(Path(tmp))))

    def test_base_url_host_root_is_normalized_to_documented_path(self) -> None:
        session = FakeSession([
            FakeResponse(200, payload=page_payload([], page=1, total=0, total_pages=0))
        ])
        with tempfile.TemporaryDirectory() as tmp:
            context = make_context(Path(tmp))
            context = ExtractionContext(
                job_id=context.job_id,
                audit_run_id=context.audit_run_id,
                period_from=context.period_from,
                period_to=context.period_to,
                source=SourceRequest(
                    source=context.source.source,
                    source_account_key=context.source.source_account_key,
                    service_source_id=context.source.service_source_id,
                    credential_id=context.source.credential_id,
                    account_label=context.source.account_label,
                    credentials=context.source.credentials,
                    provider_options={"base_url": "https://v2sandbox.shop2topup.com"},
                ),
                source_directory=context.source_directory,
                checkpoint_path=context.checkpoint_path,
            )
            provider = Shop2TopupProvider(session=session)
            list(provider.iter_records(context))

        self.assertEqual(
            "https://v2sandbox.shop2topup.com/api/endpoints/v1/orders",
            session.calls[0]["url"],
        )


if __name__ == "__main__":
    unittest.main()
