import asyncio
import os
from uuid import uuid4

import pytest
from fastapi import FastAPI
from httpx import ASGITransport, AsyncClient

import memory_gateway.api_v2 as api_v2
from memory_gateway.everos_client import EverOSClient
from memory_gateway.openviking_client import OpenVikingClient
from memory_gateway.repositories import InMemoryRepository
from memory_gateway.schemas_v2 import BackendRefStatus, BackendType, IngestRequest, IngestResponse, OperationStatus
from memory_gateway.server_auth import verify_api_key_compat
from memory_gateway.services_v2 import MemoryGatewayV2Service


pytestmark = pytest.mark.skipif(
    os.environ.get("RUN_REAL_BACKEND_TESTS") != "1",
    reason="real backend ingest test is opt-in; set RUN_REAL_BACKEND_TESTS=1",
)


def _env(name: str) -> str:
    value = os.environ.get(name)
    if not value:
        pytest.skip(f"{name} is required for real backend ingest test")
    return value


def test_real_openviking_and_everos_ingest_writes_memory_refs():
    openviking_base_url = _env("OPENVIKING_BASE_URL")
    everos_base_url = _env("EVEROS_BASE_URL")
    openviking_api_key = os.environ.get("OPENVIKING_API_KEY", "")
    everos_api_key = os.environ.get("EVEROS_API_KEY", "")
    openviking_ingest_path = os.environ.get("OPENVIKING_INGEST_PATH")
    everos_ingest_path = os.environ.get("EVEROS_INGEST_PATH")

    async def openviking_factory():
        return OpenVikingClient(
            mode="real",
            base_url=openviking_base_url,
            api_key=openviking_api_key,
            ingest_path=openviking_ingest_path,
        )

    repo = InMemoryRepository()
    service = MemoryGatewayV2Service(
        repo=repo,
        openviking_client_factory=openviking_factory,
        everos_client=EverOSClient(
            mode="real",
            base_url=everos_base_url,
            api_key=everos_api_key,
            ingest_path=everos_ingest_path,
        ),
    )
    run_id = uuid4().hex[:12]

    response = asyncio.run(post_ingest(service, run_id))

    refs = repo.list_memory_refs(session_id=f"real_ingest_sess_{run_id}", limit=10)
    assert {ref.backend_type for ref in refs} == {BackendType.OPENVIKING, BackendType.EVEROS}
    assert all(ref.content_hash for ref in refs)
    openviking_ref = next(ref for ref in refs if ref.backend_type == BackendType.OPENVIKING)
    everos_ref = next(ref for ref in refs if ref.backend_type == BackendType.EVEROS)

    assert openviking_ref.status == BackendRefStatus.SUCCESS
    if everos_ref.status == BackendRefStatus.SUCCESS:
        assert response.status == OperationStatus.SUCCESS
        assert everos_ref.native_id
        assert everos_ref.native_uri
    else:
        assert everos_ref.status == BackendRefStatus.FAILED
        assert response.status == OperationStatus.PARTIAL_SUCCESS
        assert everos_ref.error_message


async def post_ingest(service: MemoryGatewayV2Service, run_id: str):
    api_v2.v2_service = service
    app = FastAPI()
    app.dependency_overrides[verify_api_key_compat] = lambda: None
    app.include_router(api_v2.router)
    request = IngestRequest(
        workspace_id=os.environ.get("REAL_BACKEND_WORKSPACE_ID", "ws_real_ingest"),
        user_id=os.environ.get("REAL_BACKEND_USER_ID", "user_real_ingest"),
        agent_id=os.environ.get("REAL_BACKEND_AGENT_ID", "agent_real_ingest"),
        session_id=f"real_ingest_sess_{run_id}",
        turn_id=f"real_ingest_turn_{run_id}",
        request_id=f"real_ingest_req_{run_id}",
        idempotency_key=f"real_ingest_idem_{run_id}",
        namespace=os.environ.get("REAL_BACKEND_NAMESPACE", "workspace/ws_real_ingest/user/user_real_ingest"),
        source_type="integration_test",
        source_event_id=f"real_ingest_evt_{run_id}",
        role="user",
        content=f"Memory Gateway real ingest smoke test {run_id}",
        metadata={"source_channel": "integration_test"},
    )
    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
        response = await client.post("/v2/conversations/ingest", json=request.model_dump(mode="json"))
    response.raise_for_status()
    return IngestResponse.model_validate(response.json())