"""
Shop2TopUp source-activity adapter.

Documented API used by this adapter:
- GET /orders
- Bearer authentication
- page / limit pagination (limit <= 100)
- created_after / created_before ISO-8601 filters

The adapter never creates orders and never calls purchase endpoints.
It retrieves all orders in the requested period, verifies pagination totals,
and emits one deterministic record per provider order_id.
"""
from __future__ import annotations

import math
import time
from collections import Counter
from datetime import datetime, timedelta, timezone
from decimal import Decimal, InvalidOperation
from pathlib import Path
from typing import Any, Callable, Iterable, Mapping
from urllib.parse import urljoin

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

from source_activity_runtime.exceptions import ProviderDataError
from source_activity_runtime.models import ExtractionContext, ProviderRecord
from source_activity_runtime.provider import SourceActivityProvider
from source_activity_runtime.utils import atomic_write_json, sanitize


_DEFAULT_BASE_URL = "https://v2sandbox.shop2topup.com/api/endpoints/v1"
_ORDERS_PATH = "/orders"
_DEFAULT_CONNECT_TIMEOUT = 30
_DEFAULT_READ_TIMEOUT = 120
_DEFAULT_PAGE_LIMIT = 100
_DEFAULT_MAX_PAGES = 10000
_DEFAULT_MAX_RETRIES = 3

_DOCUMENTED_STATUSES = {
    "pending",
    "completed",
    "refunded",
    "partial",
    # The existing project already handles this status from GET /orders/:orderId.
    "failed",
}

_STATUS_MAP = {
    "completed": "completed",
    "pending": "pending",
    "refunded": "failed",
    "partial": "partial",
    "failed": "failed",
}


class Shop2TopupProvider(SourceActivityProvider):
    def __init__(
        self,
        session: requests.Session | None = None,
        *,
        sleeper: Callable[[float], None] = time.sleep,
        clock: Callable[[], float] = time.time,
    ) -> None:
        self._session = session or self._build_session()
        self._sleep = sleeper
        self._clock = clock
        self._metadata: dict[str, Any] = {
            "coverage_verified": False,
            "zero_records_authoritative": False,
            "coverage_policy": None,
            "endpoint": _ORDERS_PATH,
            "authentication": "bearer",
            "pagination_verified": False,
            "pages_fetched": 0,
            "provider_total_results": 0,
            "unique_orders": 0,
            "rows_seen": 0,
            "rows_in_period": 0,
            "rows_outside_period": 0,
            "records_emitted": 0,
            "status_counts": {},
            "provider_status_counts": {},
            "rate_limit_waits": 0,
            "rate_limit_wait_seconds": 0,
            "http_retries": 0,
            "boundary_expansion_seconds": 1,
            "exact_period_filter_applied_locally": True,
            "provider_has_order_id": True,
            "provider_has_created_at": True,
            "provider_list_has_player_id": "optional",
            "response_envelope_paths": [],
            "response_orders_keys": [],
            "pagination_total_pages_sources": [],
        }

    def iter_records(self, context: ExtractionContext) -> Iterable[ProviderRecord]:
        token = self._required(
            context.source.credentials,
            ("api_token", "token", "bearer_token", "access_token"),
            "API token",
        )

        options = context.source.provider_options
        request_options = options.get("request_options") or {}
        if not isinstance(request_options, Mapping):
            raise ProviderDataError("Shop2TopUp request_options must be an object")

        base_url = self._normalize_base_url(
            str(options.get("base_url") or options.get("api_url") or _DEFAULT_BASE_URL)
        )
        connect_timeout = self._positive_int(
            request_options.get("connect_timeout", _DEFAULT_CONNECT_TIMEOUT),
            "connect_timeout",
            minimum=1,
            maximum=300,
        )
        read_timeout = self._positive_int(
            request_options.get("read_timeout", request_options.get("timeout", _DEFAULT_READ_TIMEOUT)),
            "read_timeout",
            minimum=1,
            maximum=1800,
        )
        page_limit = self._positive_int(
            request_options.get("page_limit", _DEFAULT_PAGE_LIMIT),
            "page_limit",
            minimum=1,
            maximum=100,
        )
        max_pages = self._positive_int(
            request_options.get("max_pages", _DEFAULT_MAX_PAGES),
            "max_pages",
            minimum=1,
            maximum=100000,
        )
        max_retries = self._positive_int(
            request_options.get("max_retries", _DEFAULT_MAX_RETRIES),
            "max_retries",
            minimum=1,
            maximum=10,
        )
        verify_tls = self._boolean(request_options.get("verify_tls", True), "verify_tls")
        currency_default = str(options.get("currency_code") or "USD").strip().upper() or "USD"

        self._require_aware_period(context)
        period_from_utc = context.period_from.astimezone(timezone.utc)
        period_to_utc = context.period_to.astimezone(timezone.utc)

        # The API parameter is named created_after. Query one second earlier so an
        # order exactly on the requested lower boundary cannot be omitted by strict
        # "after" semantics. The exact half-open [from,to) filter is enforced locally.
        query_after = period_from_utc - timedelta(seconds=1)
        query_before = period_to_utc

        self._metadata.update({
            "base_url": base_url,
            "connect_timeout_seconds": connect_timeout,
            "read_timeout_seconds": read_timeout,
            "page_limit": page_limit,
            "max_pages": max_pages,
            "max_retries": max_retries,
            "verify_tls": verify_tls,
            "currency_default": currency_default,
            "requested_from": period_from_utc.isoformat(),
            "requested_to_exclusive": period_to_utc.isoformat(),
            "query_created_after": self._iso_z(query_after),
            "query_created_before": self._iso_z(query_before),
        })

        raw_dir = context.source_directory / "raw"
        raw_dir.mkdir(parents=True, exist_ok=True)
        orders_url = urljoin(base_url.rstrip("/") + "/", _ORDERS_PATH.lstrip("/"))
        timeout = (connect_timeout, read_timeout)
        headers = {
            "Accept": "application/json",
            "Authorization": f"Bearer {token}",
        }

        all_orders: list[Mapping[str, Any]] = []
        seen_order_ids: set[str] = set()
        expected_total: int | None = None
        expected_total_pages: int | None = None
        page = 1

        while True:
            if page > max_pages:
                raise ProviderDataError(
                    f"Shop2TopUp pagination exceeded max_pages={max_pages}"
                )

            params = {
                "page": page,
                "limit": page_limit,
                "created_after": self._iso_z(query_after),
                "created_before": self._iso_z(query_before),
            }
            response = self._get_with_retry(
                orders_url,
                headers=headers,
                params=params,
                timeout=timeout,
                verify_tls=verify_tls,
                max_retries=max_retries,
                page=page,
            )
            payload = self._json_object(response, f"Shop2TopUp orders page {page}")

            # Persist the provider response before structural validation. This keeps
            # a private, token-free diagnostic artifact even when the provider wraps
            # the documented payload in an additional data envelope or changes shape.
            raw_path = raw_dir / f"orders.page-{page:06d}.json"
            atomic_write_json(
                raw_path,
                sanitize({
                    "request": params,
                    "response": payload,
                    "response_shape": self._shape_summary(payload),
                    "rate_limit": self._rate_limit_metadata(response),
                }),
            )

            orders, pagination, envelope_path, orders_key = self._extract_orders_page(
                payload,
                page,
            )
            self._metadata["response_envelope_paths"].append(envelope_path)
            self._metadata["response_orders_keys"].append(orders_key)

            page_number = self._non_negative_int(pagination.get("page"), "pagination.page")
            response_limit = self._positive_int(
                pagination.get("limit"),
                "pagination.limit",
                minimum=1,
                maximum=100,
            )
            total = self._non_negative_int(pagination.get("total"), "pagination.total")
            calculated_pages = math.ceil(total / response_limit) if total > 0 else 0
            raw_total_pages = pagination.get("total_pages")

            if raw_total_pages in (None, ""):
                # The live Shop2TopUp response may omit total_pages or return null.
                # Completeness is still deterministic because total and limit are
                # verified integers. Derive the page count mathematically instead
                # of treating the response as complete by assumption.
                total_pages = calculated_pages
                total_pages_source = "derived_from_total_and_limit"
            else:
                total_pages = self._non_negative_int(
                    raw_total_pages,
                    "pagination.total_pages",
                )
                total_pages_source = "provider"

            self._metadata.setdefault("pagination_total_pages_sources", []).append(
                total_pages_source
            )

            if page_number != page:
                raise ProviderDataError(
                    f"Shop2TopUp pagination page mismatch: requested={page}, returned={page_number}"
                )
            if response_limit != page_limit:
                raise ProviderDataError(
                    f"Shop2TopUp pagination limit mismatch: requested={page_limit}, returned={response_limit}"
                )
            if len(orders) > response_limit:
                raise ProviderDataError(
                    f"Shop2TopUp page {page} returned more rows than its limit"
                )

            if total > 0 and total_pages != calculated_pages:
                raise ProviderDataError(
                    "Shop2TopUp pagination total_pages is inconsistent with total/limit: "
                    f"total={total}, limit={response_limit}, total_pages={total_pages}"
                )
            if total == 0 and total_pages not in (0, 1):
                raise ProviderDataError(
                    "Shop2TopUp empty pagination must report total_pages as 0 or 1"
                )

            if expected_total is None:
                expected_total = total
                expected_total_pages = total_pages
            elif total != expected_total or total_pages != expected_total_pages:
                raise ProviderDataError(
                    "Shop2TopUp pagination totals changed while reading the fixed period"
                )

            self._metadata["pages_fetched"] += 1
            self._metadata["rows_seen"] += len(orders)

            for row in orders:
                if not isinstance(row, Mapping):
                    raise ProviderDataError(
                        f"Shop2TopUp page {page} contains a non-object order row"
                    )
                order_id = str(row.get("order_id") or "").strip()
                if not order_id:
                    raise ProviderDataError(
                        f"Shop2TopUp page {page} contains an order without order_id"
                    )
                if order_id in seen_order_ids:
                    raise ProviderDataError(
                        f"Shop2TopUp duplicate order_id across pagination: {order_id}"
                    )
                seen_order_ids.add(order_id)
                all_orders.append(dict(row))

            last_page = 1 if total == 0 and total_pages == 1 else total_pages
            if page >= last_page:
                break

            self._wait_if_rate_limited(response)
            page += 1

        expected_total = expected_total or 0
        expected_total_pages = expected_total_pages or 0
        if len(all_orders) != expected_total:
            raise ProviderDataError(
                "Shop2TopUp pagination was incomplete: "
                f"expected_total={expected_total}, unique_orders={len(all_orders)}"
            )

        self._metadata.update({
            "provider_total_results": expected_total,
            "provider_total_pages": expected_total_pages,
            "unique_orders": len(all_orders),
            "pagination_verified": True,
        })

        status_counts: Counter[str] = Counter()
        provider_status_counts: Counter[str] = Counter()

        for row in all_orders:
            order_id = str(row.get("order_id") or "").strip()
            provider_status = str(row.get("status") or "").strip().lower()
            if provider_status not in _DOCUMENTED_STATUSES:
                raise ProviderDataError(
                    f"Shop2TopUp order {order_id} has unsupported status: {provider_status or '[empty]'}"
                )

            created_at = self._parse_aware_datetime(row.get("created_at"), order_id)
            if not (period_from_utc <= created_at.astimezone(timezone.utc) < period_to_utc):
                self._metadata["rows_outside_period"] += 1
                continue

            charged_amount = self._decimal_or_none(row.get("charged_amount"), "charged_amount", order_id)
            quantity = self._decimal_or_none(row.get("quantity"), "quantity", order_id)
            currency = str(row.get("currency") or currency_default).strip().upper() or currency_default
            player_id = str(row.get("player_id") or "").strip() or None
            mapped_status = _STATUS_MAP[provider_status]

            provider_status_counts[provider_status] += 1
            status_counts[mapped_status] += 1
            self._metadata["rows_in_period"] += 1
            self._metadata["records_emitted"] += 1

            yield ProviderRecord(
                provider_record_key=f"order:{order_id}",
                occurred_at=created_at,
                record_type="shop2topup_order",
                provider_status=mapped_status,
                provider_transaction_id=order_id,
                provider_reference=order_id,
                subscriber_identifier=player_id,
                amount=None,
                cost_amount=charged_amount,
                commission_amount=None,
                currency=currency,
                balance_before=None,
                balance_after=None,
                description=str(row.get("subcategory_name") or "").strip() or None,
                raw_payload={
                    **dict(row),
                    "operation_id": order_id,
                    "external_id": order_id,
                    "provider_original_status": provider_status,
                    "provider_quantity": str(quantity) if quantity is not None else None,
                    "reconciliation_identifiers": {
                        "player_id": player_id,
                    },
                },
            )

        self._metadata["status_counts"] = dict(sorted(status_counts.items()))
        self._metadata["provider_status_counts"] = dict(sorted(provider_status_counts.items()))
        self._metadata.update({
            "coverage_verified": True,
            "zero_records_authoritative": True,
            "coverage_policy": "verified_complete_filtered_period",
        })

    def result_metadata(self) -> Mapping[str, Any]:
        return dict(self._metadata)

    def _get_with_retry(
        self,
        url: str,
        *,
        headers: Mapping[str, str],
        params: Mapping[str, Any],
        timeout: tuple[int, int],
        verify_tls: bool,
        max_retries: int,
        page: int,
    ) -> requests.Response:
        last_response: requests.Response | None = None
        last_exception: Exception | None = None

        for attempt in range(1, max_retries + 1):
            try:
                response = self._session.get(
                    url,
                    headers=dict(headers),
                    params=dict(params),
                    timeout=timeout,
                    verify=verify_tls,
                )
                last_response = response
            except requests.RequestException as exc:
                last_exception = exc
                if attempt >= max_retries:
                    raise ProviderDataError(
                        f"Shop2TopUp orders page {page} request failed: {exc}"
                    ) from exc
                self._metadata["http_retries"] += 1
                self._sleep(min(2 ** (attempt - 1), 10))
                continue

            if response.status_code == 429:
                if attempt >= max_retries:
                    raise ProviderDataError(
                        f"Shop2TopUp orders page {page} remained rate-limited after {max_retries} attempts"
                    )
                wait_seconds = self._retry_after_seconds(response)
                self._record_wait(wait_seconds)
                self._metadata["http_retries"] += 1
                self._sleep(wait_seconds)
                continue

            if response.status_code in (500, 502, 503, 504):
                if attempt >= max_retries:
                    raise ProviderDataError(
                        f"Shop2TopUp orders page {page} HTTP {response.status_code}"
                    )
                wait_seconds = min(2 ** (attempt - 1), 10)
                self._metadata["http_retries"] += 1
                self._sleep(wait_seconds)
                continue

            if response.status_code < 200 or response.status_code >= 300:
                excerpt = str(getattr(response, "text", "") or "")[:500]
                raise ProviderDataError(
                    f"Shop2TopUp orders page {page} HTTP {response.status_code}: {excerpt}"
                )

            return response

        if last_response is not None:
            raise ProviderDataError(
                f"Shop2TopUp orders page {page} failed with HTTP {last_response.status_code}"
            )
        raise ProviderDataError(
            f"Shop2TopUp orders page {page} request failed: {last_exception}"
        )

    def _wait_if_rate_limited(self, response: requests.Response) -> None:
        remaining_raw = self._header(response, "X-RateLimit-Remaining")
        if remaining_raw in (None, ""):
            return
        try:
            remaining = int(str(remaining_raw))
        except (TypeError, ValueError):
            raise ProviderDataError("Shop2TopUp X-RateLimit-Remaining is not an integer")
        if remaining > 0:
            return

        reset_raw = self._header(response, "X-RateLimit-Reset")
        if reset_raw in (None, ""):
            raise ProviderDataError(
                "Shop2TopUp rate limit reached without X-RateLimit-Reset"
            )
        try:
            reset_at = float(str(reset_raw))
        except (TypeError, ValueError) as exc:
            raise ProviderDataError("Shop2TopUp X-RateLimit-Reset is invalid") from exc
        wait_seconds = max(1.0, reset_at - self._clock() + 1.0)
        self._record_wait(wait_seconds)
        self._sleep(wait_seconds)

    def _retry_after_seconds(self, response: requests.Response) -> float:
        raw = self._header(response, "Retry-After")
        if raw in (None, ""):
            return 60.0
        try:
            return max(1.0, float(str(raw)))
        except (TypeError, ValueError) as exc:
            raise ProviderDataError("Shop2TopUp Retry-After is invalid") from exc

    def _record_wait(self, seconds: float) -> None:
        self._metadata["rate_limit_waits"] += 1
        self._metadata["rate_limit_wait_seconds"] += int(math.ceil(seconds))

    @staticmethod
    def _rate_limit_metadata(response: requests.Response) -> dict[str, Any]:
        return {
            "limit": Shop2TopupProvider._header(response, "X-RateLimit-Limit"),
            "remaining": Shop2TopupProvider._header(response, "X-RateLimit-Remaining"),
            "reset": Shop2TopupProvider._header(response, "X-RateLimit-Reset"),
            "retry_after": Shop2TopupProvider._header(response, "Retry-After"),
        }

    @staticmethod
    def _header(response: requests.Response, name: str) -> Any:
        headers = getattr(response, "headers", {}) or {}
        if hasattr(headers, "get"):
            return headers.get(name)
        return None

    @staticmethod
    def _json_object(response: requests.Response, label: str) -> Mapping[str, Any]:
        try:
            payload = response.json()
        except Exception as exc:
            excerpt = str(getattr(response, "text", "") or "")[:500]
            raise ProviderDataError(f"{label} is not JSON: {excerpt}") from exc
        if not isinstance(payload, Mapping):
            raise ProviderDataError(f"{label} must be a JSON object")
        return payload

    @classmethod
    def _extract_orders_page(
        cls,
        payload: Mapping[str, Any],
        page: int,
    ) -> tuple[list[Any], Mapping[str, Any], str, str]:
        """
        Accept the documented response and the nested ``data`` envelopes already
        observed from the same Shop2TopUp API in the deployed project.

        Supported collection locations are deliberately narrow:
        - $.orders + $.pagination
        - $.data (list) + $.pagination
        - any repeated $.data object containing one of the two forms above
        - $.data.orders with pagination beside that data object

        Every explicit ``success`` flag on the traversed envelope path must be the
        JSON boolean true. No unrelated keys or arbitrary recursive search are used.
        """
        current: Mapping[str, Any] = payload
        path = "$"
        success_seen = False

        for _depth in range(8):
            if "success" in current:
                success_seen = True
                if current.get("success") is not True:
                    raise ProviderDataError(
                        f"Shop2TopUp orders page {page} returned success!=true at {path}"
                    )

            pagination = current.get("pagination")
            orders = current.get("orders")
            if isinstance(orders, list) and isinstance(pagination, Mapping):
                if not success_seen:
                    raise ProviderDataError(
                        f"Shop2TopUp orders page {page} has no verified success=true envelope"
                    )
                return orders, pagination, path, "orders"

            data = current.get("data")
            if isinstance(data, list) and isinstance(pagination, Mapping):
                if not success_seen:
                    raise ProviderDataError(
                        f"Shop2TopUp orders page {page} has no verified success=true envelope"
                    )
                return data, pagination, path, "data"

            if isinstance(data, Mapping):
                nested_success_seen = success_seen
                if "success" in data:
                    nested_success_seen = True
                    if data.get("success") is not True:
                        raise ProviderDataError(
                            f"Shop2TopUp orders page {page} returned success!=true at {path}.data"
                        )

                # Some Shop2TopUp responses place the collection under data while
                # keeping pagination beside that data object.
                nested_orders = data.get("orders")
                if isinstance(nested_orders, list) and isinstance(pagination, Mapping):
                    if not nested_success_seen:
                        raise ProviderDataError(
                            f"Shop2TopUp orders page {page} has no verified success=true envelope"
                        )
                    return nested_orders, pagination, path + ".data", "orders"

                nested_data = data.get("data")
                if isinstance(nested_data, list) and isinstance(pagination, Mapping):
                    if not nested_success_seen:
                        raise ProviderDataError(
                            f"Shop2TopUp orders page {page} has no verified success=true envelope"
                        )
                    return nested_data, pagination, path + ".data", "data"

                current = data
                path += ".data"
                success_seen = nested_success_seen
                continue

            break

        shape = cls._shape_summary(payload)
        raise ProviderDataError(
            "Shop2TopUp orders page "
            f"{page} has no supported orders/pagination payload; shape={shape}"
        )

    @staticmethod
    def _shape_summary(payload: Mapping[str, Any]) -> dict[str, Any]:
        """Return keys and value types only; never include response values."""
        summary: dict[str, Any] = {}
        current: Any = payload
        path = "$"

        for _depth in range(8):
            if not isinstance(current, Mapping):
                break
            summary[path] = {
                str(key): type(value).__name__
                for key, value in current.items()
                if str(key) in {
                    "success",
                    "data",
                    "orders",
                    "pagination",
                    "message",
                    "error",
                }
            }
            data = current.get("data")
            if not isinstance(data, Mapping):
                break
            current = data
            path += ".data"

        return summary

    @staticmethod
    def _required(credentials: Mapping[str, Any], keys: tuple[str, ...], label: str) -> str:
        for key in keys:
            value = str(credentials.get(key) or "").strip()
            if value:
                return value
        raise ProviderDataError(f"Shop2TopUp {label} is required")

    @staticmethod
    def _normalize_base_url(raw: str) -> str:
        base = str(raw or "").strip().rstrip("/")
        if not base:
            raise ProviderDataError("Shop2TopUp base_url is required")
        for suffix in (
            "/orders/create",
            "/orders/batch",
            "/orders",
            "/account",
            "/catalog/big-categories",
            "/catalog/categories",
            "/catalog/subcategories",
        ):
            position = base.find(suffix)
            if position >= 0:
                base = base[:position]
                break
        if not base.endswith("/api/endpoints/v1"):
            # The supplied project base URL may be the host root. Normalize only
            # the documented API path; do not guess a different host.
            base = base + "/api/endpoints/v1"
        if not (base.startswith("https://") or base.startswith("http://")):
            raise ProviderDataError("Shop2TopUp base_url must be an absolute HTTP(S) URL")
        return base.rstrip("/")

    @staticmethod
    def _require_aware_period(context: ExtractionContext) -> None:
        for label, value in (("from", context.period_from), ("to", context.period_to)):
            if value.tzinfo is None or value.utcoffset() is None:
                raise ProviderDataError(f"Shop2TopUp period {label} must include timezone")

    @staticmethod
    def _parse_aware_datetime(value: Any, order_id: str) -> datetime:
        text = str(value or "").strip()
        if not text:
            raise ProviderDataError(f"Shop2TopUp order {order_id} has no created_at")
        normalized = text[:-1] + "+00:00" if text.endswith("Z") else text
        try:
            parsed = datetime.fromisoformat(normalized)
        except ValueError as exc:
            raise ProviderDataError(
                f"Shop2TopUp order {order_id} has invalid created_at: {text}"
            ) from exc
        if parsed.tzinfo is None or parsed.utcoffset() is None:
            raise ProviderDataError(
                f"Shop2TopUp order {order_id} created_at has no timezone: {text}"
            )
        return parsed

    @staticmethod
    def _decimal_or_none(value: Any, label: str, order_id: str) -> Decimal | None:
        if value in (None, ""):
            return None
        try:
            return Decimal(str(value))
        except (InvalidOperation, ValueError) as exc:
            raise ProviderDataError(
                f"Shop2TopUp order {order_id} has invalid {label}: {value}"
            ) from exc

    @staticmethod
    def _positive_int(
        value: Any,
        label: str,
        *,
        minimum: int,
        maximum: int,
    ) -> int:
        try:
            number = int(value)
        except (TypeError, ValueError) as exc:
            raise ProviderDataError(f"Shop2TopUp {label} must be an integer") from exc
        if number < minimum or number > maximum:
            raise ProviderDataError(
                f"Shop2TopUp {label} must be between {minimum} and {maximum}"
            )
        return number

    @staticmethod
    def _non_negative_int(value: Any, label: str) -> int:
        try:
            number = int(value)
        except (TypeError, ValueError) as exc:
            raise ProviderDataError(f"Shop2TopUp {label} must be an integer") from exc
        if number < 0:
            raise ProviderDataError(f"Shop2TopUp {label} must be non-negative")
        return number

    @staticmethod
    def _boolean(value: Any, label: str) -> bool:
        if isinstance(value, bool):
            return value
        normalized = str(value).strip().lower()
        if normalized in ("1", "true", "yes", "on"):
            return True
        if normalized in ("0", "false", "no", "off"):
            return False
        raise ProviderDataError(f"Shop2TopUp {label} must be boolean")

    @staticmethod
    def _iso_z(value: datetime) -> str:
        utc_value = value.astimezone(timezone.utc)
        return utc_value.isoformat(timespec="microseconds").replace("+00:00", "Z")

    @staticmethod
    def _build_session() -> requests.Session:
        session = requests.Session()
        retry = Retry(
            total=0,
            connect=0,
            read=0,
            status=0,
            allowed_methods=frozenset({"GET"}),
            raise_on_status=False,
        )
        adapter = HTTPAdapter(max_retries=retry)
        session.mount("https://", adapter)
        session.mount("http://", adapter)
        return session


def build_provider() -> SourceActivityProvider:
    return Shop2TopupProvider()
