"""Tiny FastAPI app implementing the Items skeleton in openapi.yaml.

In-memory store, one resource, error responses shaped like the
Error schema in the YAML: {"code": ..., "message": ...}.
"""

from __future__ import annotations

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field


class ItemCreate(BaseModel):
    name: str = Field(min_length=1)
    quantity: int = Field(ge=0)


class ItemUpdate(BaseModel):
    name: str | None = Field(default=None, min_length=1)
    quantity: int | None = Field(default=None, ge=0)


class Item(BaseModel):
    id: int
    name: str
    quantity: int


class Error(BaseModel):
    code: str
    message: str
    details: dict | None = None


ERROR_RESPONSES = {
    400: {"model": Error, "description": "Malformed request"},
    404: {"model": Error, "description": "Resource does not exist"},
    409: {"model": Error, "description": "Name already in use"},
    422: {"model": Error, "description": "Validation failed"},
    500: {"model": Error, "description": "Unexpected server error"},
}


def error(status: int, code: str, message: str) -> JSONResponse:
    return JSONResponse(status_code=status, content={"code": code, "message": message})


def create_app() -> FastAPI:
    app = FastAPI(title="Items API", version="1.0.0")
    store: dict[int, Item] = {}
    next_id = {"value": 1}

    @app.exception_handler(HTTPException)
    async def http_error_handler(request: Request, exc: HTTPException):
        detail = exc.detail if isinstance(exc.detail, dict) else {}
        return error(
            exc.status_code,
            detail.get("code", "error"),
            detail.get("message", str(exc.detail)),
        )

    def name_taken(name: str, exclude_id: int | None = None) -> bool:
        return any(
            item.name == name and item.id != exclude_id for item in store.values()
        )

    @app.get("/items", response_model=list[Item], responses={500: ERROR_RESPONSES[500]})
    def list_items():
        return list(store.values())

    @app.post(
        "/items",
        response_model=Item,
        status_code=201,
        responses={k: ERROR_RESPONSES[k] for k in (400, 409, 422, 500)},
    )
    def create_item(body: ItemCreate):
        if name_taken(body.name):
            raise HTTPException(
                status_code=409,
                detail={"code": "conflict", "message": f"An item named {body.name} already exists."},
            )
        item = Item(id=next_id["value"], name=body.name, quantity=body.quantity)
        next_id["value"] += 1
        store[item.id] = item
        return item

    @app.get(
        "/items/{item_id}",
        response_model=Item,
        responses={k: ERROR_RESPONSES[k] for k in (404, 500)},
    )
    def get_item(item_id: int):
        item = store.get(item_id)
        if item is None:
            raise HTTPException(
                status_code=404,
                detail={"code": "not_found", "message": f"Item {item_id} does not exist."},
            )
        return item

    @app.patch(
        "/items/{item_id}",
        response_model=Item,
        responses={k: ERROR_RESPONSES[k] for k in (400, 404, 409, 422, 500)},
    )
    def update_item(item_id: int, body: ItemUpdate):
        item = store.get(item_id)
        if item is None:
            raise HTTPException(
                status_code=404,
                detail={"code": "not_found", "message": f"Item {item_id} does not exist."},
            )
        if body.name is not None and name_taken(body.name, exclude_id=item_id):
            raise HTTPException(
                status_code=409,
                detail={"code": "conflict", "message": f"An item named {body.name} already exists."},
            )
        if body.name is not None:
            item.name = body.name
        if body.quantity is not None:
            item.quantity = body.quantity
        return item

    @app.delete(
        "/items/{item_id}",
        status_code=204,
        responses={k: ERROR_RESPONSES[k] for k in (404, 500)},
    )
    def delete_item(item_id: int):
        if item_id not in store:
            raise HTTPException(
                status_code=404,
                detail={"code": "not_found", "message": f"Item {item_id} does not exist."},
            )
        del store[item_id]
        return None

    return app


app = create_app()
