# -*- coding: utf-8 -*-
"""Tests for split-aware shared service clients."""

import pytest

from shared.client.control_client import ControlPlaneClient
from shared.client.openclaw_client import OpenClawServiceClient
from shared.client.runtime_client import RuntimeServiceClient


class _DummyResponse:
    def __init__(self, payload):
        self._payload = payload

    def raise_for_status(self):
        return None

    def json(self):
        return self._payload


class _DummyAsyncClient:
    def __init__(self):
        self.calls = []

    async def get(self, path, params=None):
        self.calls.append(("get", path, params))
        return _DummyResponse({"path": path, "params": params})

    async def post(self, path, json=None):
        self.calls.append(("post", path, json))
        return _DummyResponse({"path": path, "json": json})

    async def put(self, path, json=None):
        self.calls.append(("put", path, json))
        return _DummyResponse({"path": path, "json": json})

    async def aclose(self):
        return None


@pytest.mark.asyncio
async def test_control_plane_client_hits_current_workspace_and_guard_routes():
    client = ControlPlaneClient()
    client._client = _DummyAsyncClient()

    await client.list_workspaces()
    await client.get_workspace("demo")
    await client.list_agents("demo")
    await client.get_agent("demo", "risk_manager")
    await client.fetch_pending_approvals()
    await client.approve_pending_approval("ap-1")
    await client.deny_pending_approval("ap-2", reason="nope")

    assert client._client.calls == [
        ("get", "/workspaces", None),
        ("get", "/workspaces/demo", None),
        ("get", "/workspaces/demo/agents", None),
        ("get", "/workspaces/demo/agents/risk_manager", None),
        ("get", "/guard/pending", None),
        (
            "post",
            "/guard/approve",
            {
                "approval_id": "ap-1",
                "one_time": True,
                "expires_in_minutes": 30,
            },
        ),
        (
            "post",
            "/guard/deny",
            {
                "approval_id": "ap-2",
                "reason": "nope",
            },
        ),
    ]


@pytest.mark.asyncio
async def test_runtime_service_client_hits_current_runtime_routes():
    client = RuntimeServiceClient()
    client._client = _DummyAsyncClient()

    await client.fetch_context()
    await client.fetch_agents()
    await client.fetch_events()
    await client.fetch_gateway_port()
    await client.start_runtime({"tickers": ["AAPL"]})
    await client.stop_runtime(force=True)
    await client.restart_runtime({"tickers": ["MSFT"]})
    await client.fetch_current_runtime()
    await client.get_runtime_config()
    await client.update_runtime_config({"schedule_mode": "intraday"})

    assert client._client.calls == [
        ("get", "/context", None),
        ("get", "/agents", None),
        ("get", "/events", None),
        ("get", "/gateway/port", None),
        ("post", "/start", {"tickers": ["AAPL"]}),
        ("post", "/stop?force=true", None),
        ("post", "/restart", {"tickers": ["MSFT"]}),
        ("get", "/current", None),
        ("get", "/config", None),
        ("put", "/config", {"schedule_mode": "intraday"}),
    ]


@pytest.mark.asyncio
async def test_openclaw_service_client_hits_current_openclaw_routes():
    client = OpenClawServiceClient()
    client._client = _DummyAsyncClient()

    await client.fetch_status()
    await client.list_sessions()
    await client.get_session("main/session-1")
    await client.get_session_history("main/session-1", limit=5)
    await client.list_cron_jobs()
    await client.list_approvals()

    assert client._client.calls == [
        ("get", "/status", None),
        ("get", "/sessions", None),
        ("get", "/sessions/main/session-1", None),
        ("get", "/sessions/main/session-1/history", {"limit": 5}),
        ("get", "/cron", None),
        ("get", "/approvals", None),
    ]