"""owsclient testing utils."""
from __future__ import annotations

from typing import Any
from unittest.mock import Mock
from urllib.parse import urljoin

import respx

from owsclient import ImpersonationM2MTokenManager
from owsclient.m2m.base import AsyncM2MTokenManager, M2MTokenManager
from owsclient.services import discover_service_url


class OwsClientMock:
    """OwsClientMock can be used as a mock for owsclient requests."""

    def __init__(
        self,
        environment: str = "test",
        assert_all_called: bool = True,
        assert_all_mocked: bool = True,
    ) -> None:
        """Initialize an OwsClientMock."""
        self.environment = environment
        self.mock = respx.MockRouter(
            assert_all_mocked=assert_all_mocked,
            assert_all_called=assert_all_called,
        )

        # Configure mocks
        self.mock_m2m_token_manager: M2MTokenManager = Mock(spec=M2MTokenManager)
        self.mock_m2m_token_manager.get_token_string.return_value = "mock_token_123"

        self.mock_async_m2m_token_manager: AsyncM2MTokenManager = Mock(
            spec=AsyncM2MTokenManager
        )
        self.mock_async_m2m_token_manager.get_token_string.return_value = (
            "async_mock_token_123"
        )

        self.mock_impersonation_m2m_token_manager: ImpersonationM2MTokenManager = Mock(
            spec=ImpersonationM2MTokenManager
        )
        self.mock_impersonation_m2m_token_manager.get_token_string.return_value = (
            "mock_impersonated_token_123"
        )

    def request(
        self,
        service_name: str,
        method: str,
        path: str,
        *,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a request."""
        environment, service_url = discover_service_url(
            environment=self.environment, service_name=service_name
        )
        return self.mock.request(
            method=method, url=urljoin(service_url, path), name=name, **lookups
        )

    def head(
        self,
        service_name: str,
        path: str,
        *,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a HEAD request."""
        return self.request(
            service_name, method="HEAD", path=path, name=name, **lookups
        )

    def get(
        self,
        service_name: str,
        path: str,
        *,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a GET request."""
        return self.request(service_name, method="GET", path=path, name=name, **lookups)

    def post(
        self,
        service_name: str,
        path: str,
        *,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a POST request."""
        return self.request(
            service_name, method="POST", path=path, name=name, **lookups
        )

    def put(
        self,
        service_name: str,
        path: str,
        *,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a PUT request."""
        return self.request(service_name, method="PUT", path=path, name=name, **lookups)

    def patch(
        self,
        service_name: str,
        path: str,
        *,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a PATCH request."""
        return self.request(
            service_name, method="PATCH", path=path, name=name, **lookups
        )

    def delete(
        self,
        service_name: str,
        path: str,
        *,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a DELETE request."""
        return self.request(
            service_name, method="DELETE", path=path, name=name, **lookups
        )

    def graphql_query(
        self,
        service_name: str,
        *,
        query: str,
        operation_name: str | None = None,
        variables: dict[str, Any] | None = None,
        name: str | None = None,
        **lookups: Any,
    ) -> respx.Route:
        """Create a graphql request."""
        lookups["json"] = {
            "operationName": operation_name,
            "query": query.strip(),
            "variables": variables or {},
        }
        return self.post(service_name, "/graphql", name=name, **lookups)