from typing import Any

from api.errors import semantic_error
from core.device_manager import DEFAULT_MANAGER, DeviceManager
from core.models import Task
from runtime.executor import Executor, default_tool_registry
from runtime.task import TaskRunner
from storage.task_metadata import TaskMetadataStore
from tools.launch_app import launch_app
from tools.screenshot import take_screenshot
from tools.tap import tap


def create_app(
    *,
    manager: DeviceManager | None = None,
    task_runner: TaskRunner | None = None,
    metadata_store: TaskMetadataStore | None = None,
) -> Any:
    from fastapi import BackgroundTasks, FastAPI, HTTPException
    from pydantic import BaseModel

    device_manager = manager or DEFAULT_MANAGER
    store = metadata_store or TaskMetadataStore()
    runner = task_runner or TaskRunner(
        metadata_store=store,
        executor=Executor(tools=default_tool_registry(manager=device_manager)),
    )
    app = FastAPI(title="Apex Agent API")

    class TapRequest(BaseModel):
        x: float
        y: float

    class ScreenshotResponse(BaseModel):
        image_base64: str
        mime_type: str = "image/png"

    class LaunchRequest(BaseModel):
        app_id: str

    class AgentTaskRequest(BaseModel):
        goal: str
        device_id: str

    @app.get("/devices")
    def devices() -> list[dict[str, Any]]:
        return [device.to_dict() for device in device_manager.list_devices()]

    @app.post("/devices/{device_id}/tap")
    def tap_device(device_id: str, request: TapRequest) -> dict[str, Any]:
        return _raise_semantic(
            lambda: tap(
                request.x,
                request.y,
                device_id=device_id,
                manager=device_manager,
            )
        )

    @app.post("/devices/{device_id}/screenshot")
    def screenshot_device(device_id: str) -> dict[str, str]:
        import base64

        image = _raise_semantic(
            lambda: take_screenshot(device_id, manager=device_manager)
        )
        response = ScreenshotResponse(
            image_base64=base64.b64encode(image).decode("ascii")
        )
        return response.model_dump()

    @app.post("/devices/{device_id}/launch")
    def launch_device(device_id: str, request: LaunchRequest) -> dict[str, Any]:
        return _raise_semantic(
            lambda: launch_app(
                request.app_id,
                device_id=device_id,
                manager=device_manager,
            )
        )

    @app.post("/agent/task")
    def start_task(
        request: AgentTaskRequest,
        background_tasks: BackgroundTasks,
    ) -> dict[str, str]:
        task = Task(goal=request.goal, device_id=request.device_id)
        store.create_task(task)
        background_tasks.add_task(runner.run, task)
        return {"task_id": task.id, "status": task.status}

    @app.get("/task/{task_id}")
    def get_task(task_id: str) -> dict[str, Any]:
        task = store.get_task(task_id)
        if task is None:
            raise HTTPException(status_code=404, detail="task not found")
        return task

    return app


def _raise_semantic(func: Any) -> Any:
    from fastapi import HTTPException

    try:
        return func()
    except Exception as exc:
        raise HTTPException(status_code=400, detail=semantic_error(exc)) from exc