from __future__ import annotations

import tempfile
import unittest
from datetime import datetime
from pathlib import Path
from typing import Any

from source_activity_runtime.exceptions import ProviderDataError
from source_activity_runtime.models import ExtractionContext, SourceRequest
from source_activity_runtime.providers.dunia import DuniaProvider


class FakeResponse:
    def __init__(self, payload: Any, status_code: int = 200) -> None:
        self._payload = payload
        self.status_code = status_code
        self.text = "" if isinstance(payload, (dict, list)) else str(payload)

    def json(self):
        if isinstance(self._payload, Exception):
            raise self._payload
        return self._payload


class FakeSession:
    def __init__(self, pages: dict[int, dict[str, Any]]) -> None:
        self.pages = pages
        self.headers: dict[str, str] = {}
        self.calls: list[tuple[str, str]] = []

    def get(self, url: str, **kwargs):
        self.calls.append(("GET", url))
        if url.endswith("/api/menus"):
            return FakeResponse({
                "agent_menu": {
                    "4": {
                        "child": [
                            {"address": "paymentLog"},
                            {"address": "transLog"},
                        ]
                    }
                }
            })
        if "/api/pay_billing" in url:
            offset = 0
            if "offset=" in url:
                offset = int(url.rsplit("offset=", 1)[1])
            return FakeResponse(self.pages.get(offset, {"data": []}))
        return FakeResponse("<html></html>")

    def post(self, url: str, **kwargs):
        self.calls.append(("POST", url))
        return FakeResponse({"token": "TOKEN", "name": "Agent", "code": "123"})


class DuniaProviderTest(unittest.TestCase):
    def context(self, root: Path) -> ExtractionContext:
        return ExtractionContext(
            job_id="dunia-test",
            audit_run_id=None,
            period_from=datetime.fromisoformat("2026-07-08T00:00:00+03:00"),
            period_to=datetime.fromisoformat("2026-07-09T00:00:00+03:00"),
            source=SourceRequest(
                source="dunia",
                source_account_key="a" * 64,
                service_source_id=31,
                credential_id=22,
                account_label="Dunia",
                credentials={"username": "123", "password": "secret"},
                provider_options={},
            ),
            source_directory=root,
            checkpoint_path=root / "checkpoint.json",
        )

    def test_har_shaped_pages_are_filtered_and_persisted(self):
        pages = {
            0: {
                "data": [
                    self.row("2026-07-09 00:30:00+03", 111, 10),
                    self.row("2026-07-08 12:09:30+03", 112, 240),
                    self.row("2026-07-08 01:00:00+03", 113, 185),
                    self.row("2026-07-07 23:59:59+03", 114, 100),
                ]
            }
        }
        session = FakeSession(pages)
        provider = DuniaProvider(session=session)

        with tempfile.TemporaryDirectory() as tmp:
            records = list(provider.iter_records(self.context(Path(tmp))))
            self.assertEqual(len(records), 2)
            self.assertEqual(records[0].record_type, "pay_bill_adsl")
            self.assertEqual(records[0].provider_status, "recorded")
            self.assertEqual(records[0].subscriber_identifier, "112")
            self.assertEqual(records[0].amount, 240)
            self.assertIsNone(records[0].provider_transaction_id)
            self.assertIsNone(records[0].provider_reference)
            self.assertTrue((Path(tmp) / "raw" / "login.metadata.json").is_file())
            self.assertTrue((Path(tmp) / "raw" / "pay_billing-offset-00000000.json").is_file())
            self.assertEqual(session.headers.get("Authorization"), "TOKEN")
            self.assertEqual(provider.result_metadata()["rows_in_period"], 2)

    def test_unordered_pages_fail_instead_of_guessing(self):
        pages = {
            0: {
                "data": [
                    self.row("2026-07-08 10:00:00+03", 111, 10),
                    self.row("2026-07-08 11:00:00+03", 112, 20),
                ]
            }
        }
        provider = DuniaProvider(session=FakeSession(pages))

        with tempfile.TemporaryDirectory() as tmp:
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(self.context(Path(tmp))))

    @staticmethod
    def row(op_time: str, phone: int, money: int) -> dict[str, Any]:
        return {
            "total_count": 4,
            "sum_balance": 535,
            "sum_money": 535,
            "money": money,
            "balance": money,
            "op_time": op_time,
            "in_debt": 0,
            "phone": phone,
            "en_title": "pay_bill_adsl",
            "ar_title": "دفع فاتورة",
            "op_code": "pay_bill_adsl",
            "user_username": "agent",
            "user_code": 123,
            "can_update": 1,
            "adsl_name": "Customer",
            "current_pkg": "ADSL",
            "new_pkg": "None",
            "pbx": "PBX",
            "next_bill": "2026-08-08",
        }


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