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.three_abilly import ThreeAbillyProvider


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

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


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

    def post(self, url: str, **kwargs: Any) -> FakeResponse:
        self.calls.append(("POST", url, kwargs))
        if url.endswith("/api/login"):
            return FakeResponse(
                200,
                payload={
                    "status": 200,
                    "message": "success",
                    "balance": "1000.00",
                    "token": "secret-token",
                },
                url=url,
            )
        if url.endswith("/api/report"):
            from_date = str((kwargs.get("data") or {}).get("from_date") or "")
            payload = self.reports[from_date]
            return FakeResponse(200, payload=payload, url=url)
        raise AssertionError(f"Unexpected POST {url}")


def report_row(
    *,
    operation_type: str = "تسديد",
    value: str = "107.00",
    response: str = "تمت عملية التعبئة بنجاح",
    number: str = "0930790493",
    kind: str = "وحدات SYRIATEL",
) -> dict[str, str]:
    return {
        "type": operation_type,
        "value": value,
        "response": response,
        "number": number,
        "kind": kind,
    }


def make_context(root: Path, *, chunk_seconds: int = 3600) -> ExtractionContext:
    tz = ZoneInfo("Asia/Damascus")
    source_directory = root / "three_abilly"
    source_directory.mkdir(parents=True, exist_ok=True)
    return ExtractionContext(
        job_id="test-job",
        audit_run_id="test-audit",
        period_from=datetime(2026, 7, 17, 9, 30, 0, tzinfo=tz),
        period_to=datetime(2026, 7, 17, 11, 30, 0, tzinfo=tz),
        source=SourceRequest(
            source="three_abilly",
            source_account_key="d" * 64,
            service_source_id=18,
            credential_id=19,
            account_label="عبيلي فورا",
            credentials={"username": "0930000000", "password": "secret"},
            provider_options={
                "currency_code": "SYR",
                "request_options": {"chunk_seconds": chunk_seconds},
            },
        ),
        source_directory=source_directory,
        checkpoint_path=root / "checkpoint.json",
    )


class ThreeAbillyProviderTests(unittest.TestCase):
    def test_windowed_report_imports_success_failure_and_excludes_funding(self) -> None:
        session = FakeThreeAbillySession({
            "2026-07-17 09:30:00": [
                report_row(),
                report_row(
                    value="214.00",
                    response="فشلت عملية التعبئة  syr 10_10",
                    number="0930000001",
                ),
                report_row(
                    operation_type="دفعة نقدية",
                    value="10000.00",
                    response=" ",
                    number="",
                    kind="فورا",
                ),
            ],
            "2026-07-17 10:30:00": [],
        })

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

        self.assertEqual(2, len(records))
        self.assertEqual(["completed", "failed"], sorted(r.provider_status for r in records))
        self.assertEqual(["107.00", "214.00"], sorted(r.cost_amount for r in records))
        self.assertTrue(all(r.amount is None for r in records))
        self.assertTrue(all(r.provider_transaction_id is None for r in records))
        self.assertTrue(all(r.occurred_at.isoformat() == "2026-07-17T09:59:59+03:00" for r in records))
        self.assertEqual(2, metadata["report_calls"])
        self.assertEqual(3, metadata["rows_seen"])
        self.assertEqual(2, metadata["customer_rows"])
        self.assertEqual(1, metadata["source_funding_rows_excluded"])
        self.assertEqual({"completed": 1, "failed": 1}, metadata["status_counts"])
        self.assertTrue(metadata["coverage_verified"])
        self.assertTrue(metadata["zero_records_authoritative"])
        self.assertEqual(
            "verified_complete_non_overlapping_windows",
            metadata["coverage_policy"],
        )
        completed_record = next(record for record in records if record.provider_status == "completed")
        identifiers = completed_record.raw_payload["reconciliation_identifiers"]
        self.assertEqual("0930790493", identifiers["phone"])
        self.assertEqual("0930790493", identifiers["external_target"])

        report_calls = [call for call in session.calls if call[1].endswith("/api/report")]
        self.assertEqual(2, len(report_calls))
        self.assertEqual(
            {
                "from_date": "2026-07-17 09:30:00",
                "to_date": "2026-07-17 10:29:59",
            },
            report_calls[0][2]["data"],
        )
        self.assertEqual(
            {
                "from_date": "2026-07-17 10:30:00",
                "to_date": "2026-07-17 11:29:59",
            },
            report_calls[1][2]["data"],
        )
        self.assertEqual("Bearer secret-token", report_calls[0][2]["headers"]["Authorization"])

    def test_identical_rows_are_preserved_with_deterministic_unique_keys(self) -> None:
        repeated = report_row(value="100.00", number="0967707905", kind="جملة وحدات MTN - درعا")
        reports = {
            "2026-07-17 09:30:00": [dict(repeated), dict(repeated)],
            "2026-07-17 10:30:00": [],
        }

        with tempfile.TemporaryDirectory() as tmp1, tempfile.TemporaryDirectory() as tmp2:
            provider1 = ThreeAbillyProvider(session=FakeThreeAbillySession(reports))
            records1 = list(provider1.iter_records(make_context(Path(tmp1))))
            provider2 = ThreeAbillyProvider(session=FakeThreeAbillySession(reports))
            records2 = list(provider2.iter_records(make_context(Path(tmp2))))

        keys1 = [record.provider_record_key for record in records1]
        keys2 = [record.provider_record_key for record in records2]
        self.assertEqual(2, len(keys1))
        self.assertEqual(2, len(set(keys1)))
        self.assertEqual(keys1, keys2)
        self.assertTrue(keys1[0].endswith(":1"))
        self.assertTrue(keys1[1].endswith(":2"))
        self.assertEqual(1, provider1.result_metadata()["duplicate_identical_rows"])

    def test_non_phone_number_is_typed_only_as_external_target(self) -> None:
        session = FakeThreeAbillySession({
            "2026-07-17 09:30:00": [report_row(number="PLAYER-ABC-77")],
            "2026-07-17 10:30:00": [],
        })
        with tempfile.TemporaryDirectory() as tmp:
            provider = ThreeAbillyProvider(session=session)
            records = list(provider.iter_records(make_context(Path(tmp))))
        identifiers = records[0].raw_payload["reconciliation_identifiers"]
        self.assertEqual({"external_target": "PLAYER-ABC-77"}, identifiers)

    def test_unknown_customer_response_fails_without_guessing(self) -> None:
        session = FakeThreeAbillySession({
            "2026-07-17 09:30:00": [report_row(response="رسالة جديدة غير موثقة")],
            "2026-07-17 10:30:00": [],
        })
        with tempfile.TemporaryDirectory() as tmp:
            provider = ThreeAbillyProvider(session=session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp))))

    def test_unknown_operation_type_fails_without_silent_exclusion(self) -> None:
        session = FakeThreeAbillySession({
            "2026-07-17 09:30:00": [report_row(operation_type="عملية غير معروفة")],
            "2026-07-17 10:30:00": [],
        })
        with tempfile.TemporaryDirectory() as tmp:
            provider = ThreeAbillyProvider(session=session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp))))

    def test_report_must_be_an_array(self) -> None:
        session = FakeThreeAbillySession({
            "2026-07-17 09:30:00": {"message": "unexpected"},
            "2026-07-17 10:30:00": [],
        })
        with tempfile.TemporaryDirectory() as tmp:
            provider = ThreeAbillyProvider(session=session)
            with self.assertRaises(ProviderDataError):
                list(provider.iter_records(make_context(Path(tmp))))


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