from __future__ import annotations

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.sawa import SawaProvider


class FakeResponse:
    def __init__(
        self,
        status_code: int,
        text: str = "",
        payload: Any = None,
        url: str = "",
    ) -> None:
        self.status_code = status_code
        self.text = text
        self._payload = payload
        self.url = url

    def json(self) -> Any:
        if self._payload is None:
            raise ValueError("not json")
        return self._payload


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

    def get(self, url: str, **kwargs: Any) -> FakeResponse:
        self.calls.append(("GET", url, kwargs))
        if url.endswith("/abili/login"):
            return FakeResponse(
                200,
                '<html><input type="hidden" name="_token" value="login-token"></html>',
                url=url,
            )
        if url.endswith("/"):
            return FakeResponse(200, "<html>home</html>", url=url)
        if url.endswith("/sales_points_transactions"):
            return FakeResponse(
                200,
                '<html><form id="form_transactions_search">'
                '<input type="hidden" name="_token" value="report-token">'
                '</form></html>',
                url=url,
            )
        raise AssertionError(f"Unexpected GET {url}")

    def post(self, url: str, **kwargs: Any) -> FakeResponse:
        self.calls.append(("POST", url, kwargs))
        if url.endswith("/abili/login"):
            return FakeResponse(302, url=url)
        if url.endswith("/sales_points_transactions_ajax"):
            offset = int((kwargs.get("data") or {}).get("offset", 0))
            return FakeResponse(200, payload=self.pages[offset], url=url)
        raise AssertionError(f"Unexpected POST {url}")


def row(
    operation_id: str,
    operation_type: str,
    occurred_at: str,
    phone: str = "112345678",
    amount: str = "380",
    donor: str = "DOCTORMOBILE",
    recipient: str = "customer.login",
    notes: str = "",
) -> dict[str, str]:
    return {
        "operation_id": operation_id,
        "operation_type": operation_type,
        "occurred_at": occurred_at,
        "donor": donor,
        "recipient_name": recipient,
        "phone_number": phone,
        "paid_amount": amount,
        "notes": notes,
    }


def ajax_payload(rows: list[dict[str, str]], total: int) -> dict[str, Any]:
    body = []
    for item in rows:
        color = "#aaffaa" if item["operation_type"] == "تعبئة رصيد نقطة بيع" else "#ffaaaa"
        body.append(
            f'<tr style="background-color:{color}">'
            f'<td>{item["operation_id"]}</td>'
            f'<td>{item["operation_type"]}</td>'
            f'<td>{item["occurred_at"]}</td>'
            f'<td>{item["donor"]}</td>'
            f'<td>{item["recipient_name"]}</td>'
            f'<td>{item["phone_number"]}</td>'
            f'<td>{item["paid_amount"]}</td>'
            f'<td>{item["notes"]}</td>'
            '</tr>'
        )
    headers = "".join(f"<th>{value}</th>" for value in (
        "رقم العملية",
        "نوع العملية",
        "التاريخ",
        "المانح",
        "اسم المستلم",
        "رقم الهاتف",
        "قيمة الدفعة المسددة",
        "ملاحظات",
    ))
    html = (
        f'<table id="table2"><thead><tr>{headers}</tr></thead>'
        f'<tbody>{"".join(body)}</tbody></table>'
        f'<div>عدد النتائج: {total}</div>'
    )
    return {"result_status": "success", "result": html}


def make_context(
    root: Path,
    period_from: datetime | None = None,
    period_to: datetime | None = None,
) -> ExtractionContext:
    tz = ZoneInfo("Asia/Damascus")
    source_directory = root / "sawa"
    source_directory.mkdir(parents=True, exist_ok=True)
    return ExtractionContext(
        job_id="test-job",
        audit_run_id="test-audit",
        period_from=period_from or datetime(2026, 7, 17, 9, 0, 0, tzinfo=tz),
        period_to=period_to or datetime(2026, 7, 17, 12, 0, 0, tzinfo=tz),
        source=SourceRequest(
            source="sawa",
            source_account_key="c" * 64,
            service_source_id=9,
            credential_id=10,
            account_label="سوا",
            credentials={"username": "u", "password": "p"},
            provider_options={"currency_code": "SYR"},
        ),
        source_directory=source_directory,
        checkpoint_path=root / "checkpoint.json",
    )


class SawaProviderTests(unittest.TestCase):
    @staticmethod
    def provider(session: FakeSawaSession, now: datetime | None = None) -> SawaProvider:
        tz = ZoneInfo("Asia/Damascus")
        fixed_now = now or datetime(2026, 7, 17, 12, 30, 0, tzinfo=tz)
        return SawaProvider(
            session=session,
            now_factory=lambda _tz: fixed_now,
        )

    def test_direct_filtered_request_and_exact_half_open_period(self) -> None:
        rows = [
            row("1001", "تعبئة رصيد زبون", "2026-07-17 08:59:59"),
            row("1002", "تعبئة رصيد زبون", "2026-07-17 09:10:00", amount="380"),
            row("1003", "تعبئة رصيد زبون", "2026-07-17 12:00:00"),
            row("1004", "تعبئة رصيد نقطة بيع", "2026-07-17 10:00:00", phone="", amount="30000"),
        ]
        session = FakeSawaSession({0: ajax_payload(rows, 4)})
        with tempfile.TemporaryDirectory() as tmp:
            provider = self.provider(session)
            records = list(provider.iter_records(make_context(Path(tmp))))

        self.assertEqual(1, len(records))
        record = records[0]
        self.assertEqual("1002", record.provider_transaction_id)
        self.assertEqual("completed", record.provider_status)
        self.assertEqual("112345678", record.subscriber_identifier)
        self.assertEqual("380", record.amount)
        self.assertEqual("380", record.cost_amount)
        self.assertEqual(
            "112345678",
            record.raw_payload["reconciliation_identifiers"]["phone"],
        )

        ajax_calls = [call for call in session.calls if call[1].endswith("_ajax")]
        self.assertEqual(1, len(ajax_calls))
        data = ajax_calls[0][2]["data"]
        self.assertEqual("2026-07-17", data["from_date"])
        self.assertEqual("", data["to_date"])
        self.assertNotEqual("", data["from_date"])
        self.assertEqual((30, 300), ajax_calls[0][2]["timeout"])
        self.assertEqual(
            "from_date_open_end_current_day",
            provider.result_metadata()["query_mode"],
        )
        self.assertEqual(
            "2026-07-18",
            provider.result_metadata()["desired_exclusive_to_date"],
        )
        self.assertTrue(provider.result_metadata()["coverage_verified"])
        self.assertTrue(provider.result_metadata()["zero_records_authoritative"])
        self.assertEqual(
            "verified_complete_filtered_period",
            provider.result_metadata()["coverage_policy"],
        )

    def test_historical_partial_day_uses_verified_exclusive_end_date(self) -> None:
        tz = ZoneInfo("Asia/Damascus")
        rows = [
            row("1501", "تعبئة رصيد زبون", "2026-07-16 22:00:00"),
        ]
        session = FakeSawaSession({0: ajax_payload(rows, 1)})
        with tempfile.TemporaryDirectory() as tmp:
            provider = self.provider(session)
            records = list(provider.iter_records(make_context(
                Path(tmp),
                period_from=datetime(2026, 7, 15, 0, 0, 0, tzinfo=tz),
                period_to=datetime(2026, 7, 16, 23, 59, 59, tzinfo=tz),
            )))

        self.assertEqual(1, len(records))
        ajax_calls = [call for call in session.calls if call[1].endswith("_ajax")]
        data = ajax_calls[0][2]["data"]
        self.assertEqual("2026-07-15", data["from_date"])
        self.assertEqual("2026-07-17", data["to_date"])
        self.assertEqual("exclusive_end_date", provider.result_metadata()["query_mode"])

    def test_midnight_period_end_does_not_add_an_extra_day(self) -> None:
        tz = ZoneInfo("Asia/Damascus")
        rows = [
            row("1601", "تعبئة رصيد زبون", "2026-07-16 22:00:00"),
        ]
        session = FakeSawaSession({0: ajax_payload(rows, 1)})
        with tempfile.TemporaryDirectory() as tmp:
            provider = self.provider(session)
            records = list(provider.iter_records(make_context(
                Path(tmp),
                period_from=datetime(2026, 7, 16, 0, 0, 0, tzinfo=tz),
                period_to=datetime(2026, 7, 17, 0, 0, 0, tzinfo=tz),
            )))

        self.assertEqual(1, len(records))
        ajax_calls = [call for call in session.calls if call[1].endswith("_ajax")]
        data = ajax_calls[0][2]["data"]
        self.assertEqual("2026-07-16", data["from_date"])
        self.assertEqual("2026-07-17", data["to_date"])

    def test_pagination_collects_all_rows_and_deduplicates_overlap(self) -> None:
        first = [
            row("2001", "تعبئة رصيد زبون", "2026-07-17 09:10:00"),
            row("2002", "تعبئة رصيد زبون", "2026-07-17 10:10:00"),
        ]
        second = [
            row("2002", "تعبئة رصيد زبون", "2026-07-17 10:10:00"),
            row("2003", "تعبئة رصيد زبون", "2026-07-17 11:10:00"),
        ]
        session = FakeSawaSession({
            0: ajax_payload(first, 3),
            100: ajax_payload(second, 3),
        })
        with tempfile.TemporaryDirectory() as tmp:
            provider = self.provider(session)
            records = list(provider.iter_records(make_context(Path(tmp))))
            metadata = provider.result_metadata()

        self.assertEqual(["2001", "2002", "2003"], [r.provider_transaction_id for r in records])
        self.assertEqual([0, 100], metadata["offsets_fetched"])
        self.assertEqual(1, metadata["duplicate_rows"])
        self.assertEqual(3, metadata["unique_rows"])

    def test_unknown_operation_type_fails_without_guessing(self) -> None:
        rows = [row("3001", "عملية غير معروفة", "2026-07-17 10:00:00")]
        session = FakeSawaSession({0: ajax_payload(rows, 1)})
        with tempfile.TemporaryDirectory() as tmp:
            provider = self.provider(session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp))))

    def test_pagination_no_progress_fails_instead_of_claiming_completeness(self) -> None:
        rows = [row("4001", "تعبئة رصيد زبون", "2026-07-17 10:00:00")]
        session = FakeSawaSession({
            0: ajax_payload(rows, 2),
            100: ajax_payload(rows, 2),
        })
        with tempfile.TemporaryDirectory() as tmp:
            provider = self.provider(session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp))))


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