"""Public widget endpoint'leri (api_key + session_token, JWT yok). Thin handler'lar."""
from decimal import Decimal

from fastapi import APIRouter, Depends, Query, Request

from app.auth.widget_deps import get_widget_by_key
from app.models.chat import ChatWidget
from app.schemas.chat import (
    CreateSessionRequest,
    NpsRequest,
    SendMessageRequest,
)
from app.schemas.visitor import IdentifyRequest, MergeIdentityRequest
from app.services.chat_service import ChatService
from app.services.product_service import ProductService
from app.services.visitor.visitor_service import VisitorService
from app.services.widget_service import WidgetService
from app.utils.responses import created, no_content, ok

router = APIRouter(prefix="/api/widget", tags=["widget-public"])


# ---------------- api_key gerektiren (path: {api_key}) ----------------


@router.get("/{api_key}/settings")
async def widget_settings(
    widget: ChatWidget = Depends(get_widget_by_key),
    service: WidgetService = Depends(),
):
    result = await service.get_public_settings(widget)
    return ok(result.model_dump(mode="json"))


@router.post("/{api_key}/session/create")
async def create_session(
    body: CreateSessionRequest,
    request: Request,
    widget: ChatWidget = Depends(get_widget_by_key),
    service: ChatService = Depends(),
):
    ip = request.client.host if request.client else None
    browser = request.headers.get("user-agent")
    result = await service.create_session(widget, body, ip=ip, browser=browser)
    return created(result.model_dump(mode="json"))


@router.get("/{api_key}/products/search")
async def widget_product_search(
    q: str | None = Query(default=None),
    category: str | None = Query(default=None),
    max_price: Decimal | None = Query(default=None, ge=0),
    widget: ChatWidget = Depends(get_widget_by_key),
    service: ProductService = Depends(),
):
    items = await service.search_products(
        widget.tenant_id, query=q, category_id=category, max_price=max_price
    )
    return ok(items)


# ---------------- visitor (moat) — api_key ----------------


@router.post("/{api_key}/visitor/identify")
async def visitor_identify(
    body: IdentifyRequest,
    request: Request,
    widget: ChatWidget = Depends(get_widget_by_key),
    service: VisitorService = Depends(),
):
    ip = request.client.host if request.client else None
    ua = request.headers.get("user-agent")
    result = await service.identify(widget.tenant_id, body, ip=ip, user_agent=ua)
    return ok(result.model_dump(mode="json"))


@router.post("/{api_key}/visitor/{visitor_id}/contact")
async def visitor_contact(
    visitor_id: str,
    body: MergeIdentityRequest,
    widget: ChatWidget = Depends(get_widget_by_key),
    service: VisitorService = Depends(),
):
    result = await service.merge_identity(
        visitor_id,
        widget.tenant_id,
        email=body.email,
        phone=body.phone,
        name=body.name,
        kvkk_consent=body.kvkk_consent,
    )
    return ok(result.model_dump(mode="json"))


@router.post("/{api_key}/visitor/{visitor_id}/forget")
async def visitor_forget(
    visitor_id: str,
    widget: ChatWidget = Depends(get_widget_by_key),
    service: VisitorService = Depends(),
):
    await service.forget(visitor_id, widget.tenant_id)
    return no_content()


# ---------------- session_token ile (body/query) ----------------


@router.post("/message/send")
async def send_message(body: SendMessageRequest, service: ChatService = Depends()):
    result = await service.send_visitor_message(body.session_token, body.message)
    return created(result.model_dump(mode="json"))


@router.get("/message/history")
async def message_history(
    session_token: str = Query(..., min_length=1, max_length=64),
    limit: int = Query(default=100, ge=1, le=200),
    service: ChatService = Depends(),
):
    return ok(await service.get_history(session_token, limit))


@router.post("/session/close")
async def close_session(
    session_token: str = Query(..., min_length=1, max_length=64),
    service: ChatService = Depends(),
):
    await service.close_session_by_token(session_token)
    return no_content()


@router.post("/nps")
async def submit_nps(body: NpsRequest, service: ChatService = Depends()):
    await service.submit_nps(body.session_token, body.score, body.comment)
    return no_content()


@router.post("/idle-ping")
async def idle_ping(
    session_token: str = Query(..., min_length=1, max_length=64),
    service: ChatService = Depends(),
):
    await service.idle_ping(session_token)
    return no_content()