"""Cart app data endpoints.

Exposes read-only JSON queries at ``/internal/data/<query_name>`` for
cross-app callers via the internal data client.
"""
from __future__ import annotations

from quart import Blueprint, g, jsonify, request

from shared.infrastructure.data_client import DATA_HEADER
from shared.contracts.dtos import dto_to_dict
from shared.services.registry import services


def register() -> Blueprint:
    bp = Blueprint("data", __name__, url_prefix="/internal/data")

    @bp.before_request
    async def _require_data_header():
        if not request.headers.get(DATA_HEADER):
            return jsonify({"error": "forbidden"}), 403

    _handlers: dict[str, object] = {}

    @bp.get("/<query_name>")
    async def handle_query(query_name: str):
        handler = _handlers.get(query_name)
        if handler is None:
            return jsonify({"error": "unknown query"}), 404
        result = await handler()
        return jsonify(result)

    # --- cart-summary ---
    async def _cart_summary():
        user_id = request.args.get("user_id", type=int)
        session_id = request.args.get("session_id")
        page_slug = request.args.get("page_slug")
        summary = await services.cart.cart_summary(
            g.s, user_id=user_id, session_id=session_id, page_slug=page_slug,
        )
        return dto_to_dict(summary)

    _handlers["cart-summary"] = _cart_summary

    # --- page-config-ensure ---
    async def _page_config_ensure():
        """Get or create a PageConfig for a container_type + container_id."""
        from sqlalchemy import select
        from shared.models.page_config import PageConfig

        container_type = request.args.get("container_type", "page")
        container_id = request.args.get("container_id", type=int)
        if container_id is None:
            return {"error": "container_id required"}, 400

        row = (await g.s.execute(
            select(PageConfig).where(
                PageConfig.container_type == container_type,
                PageConfig.container_id == container_id,
            )
        )).scalar_one_or_none()

        if row is None:
            row = PageConfig(
                container_type=container_type,
                container_id=container_id,
                features={},
            )
            g.s.add(row)
            await g.s.flush()

        return {
            "id": row.id,
            "container_type": row.container_type,
            "container_id": row.container_id,
        }

    _handlers["page-config-ensure"] = _page_config_ensure

    return bp