"""
Endpoints de sincronización y gestión de productos.
"""
import asyncio
import logging
import time

from fastapi import APIRouter, Depends, HTTPException, Query, status

from ..models import SyncProductsResponse, SearchProductItem, Neo4jSearchResponse
from ..services.sync_service import sync_products
from ..auth import verify_api_key, verify_token
from agent.conversation_utils import parse_neo4j_products

logger = logging.getLogger(__name__)

router = APIRouter(prefix="/products", tags=["products"])


@router.get("/search", response_model=Neo4jSearchResponse, dependencies=[Depends(verify_token)])
async def search_products_neo4j(
    q: str = Query(..., description="Texto de búsqueda"),
    limit: int = Query(10, ge=1, le=50, description="Número máximo de resultados"),
    mode: str = Query("vector", description="Modo de búsqueda: 'vector' o 'fulltext'"),
):
    """
    Busca productos en Neo4j directamente a partir de un texto.
    - mode=vector  → búsqueda semántica por embeddings (default)
    - mode=fulltext → búsqueda por texto completo
    """
    from rag_service.neo4j_client import neo4j_client

    logger.info(f"🔍 [search_products_neo4j] q='{q}' limit={limit} mode={mode}")
    t0 = time.time()

    try:
        if mode == "fulltext":
            raw = await asyncio.to_thread(neo4j_client.fulltext_search_products_full, q, limit)
        else:
            raw = await asyncio.to_thread(neo4j_client.vector_search_products_full, q, limit)
    except Exception as e:
        logger.error(f"❌ [search_products_neo4j] Error: {e}", exc_info=True)
        raise HTTPException(status_code=500, detail=str(e))

    elapsed = round(time.time() - t0, 3)
    logger.info(f"✅ [search_products_neo4j] {len(raw)} resultados en {elapsed}s")
    for i, p in enumerate(raw, 1):
        logger.info(
            f"   [{i}] id={p.get('id')} | sku={p.get('sku_id')} | "
            f"nombre='{p.get('name')}' | precio={p.get('price')} | "
            f"marca={p.get('brand')} | score={p.get('score', 'N/A')}"
        )

    return Neo4jSearchResponse(query=q, total=len(raw), elapsed_s=elapsed, products=raw)


@router.get("/{product_id}", response_model=SearchProductItem, dependencies=[Depends(verify_token)])
async def get_product_by_id(product_id: str):
    """
    Retorna el detalle completo de un producto buscándolo por su ID en Neo4j.
    Devuelve 404 si el producto no existe.
    """
    from rag_service.neo4j_client import neo4j_client

    logger.info(f"🔍 [get_product_by_id] product_id='{product_id}'")
    t0 = time.time()

    try:
        raw = await asyncio.to_thread(neo4j_client.get_product_context, product_id)
    except Exception as e:
        logger.error(f"❌ [get_product_by_id] Error: {e}", exc_info=True)
        raise HTTPException(status_code=500, detail=str(e))

    if not raw:
        raise HTTPException(status_code=404, detail=f"Producto con id '{product_id}' no encontrado")

    elapsed = round(time.time() - t0, 3)
    logger.info(f"✅ [get_product_by_id] product_id='{product_id}' encontrado en {elapsed}s")

    return parse_neo4j_products([raw])[0]


@router.post("/sync", response_model=SyncProductsResponse)
async def sync_products_to_neo4j(_: str = Depends(verify_api_key)):
    """
    Sincroniza productos desde XML a Neo4j.

    - Si la BD está vacía: sube todos los productos con estado 'nuevo'
    - Si ya hay datos: sincronización incremental
    """
    try:
        return await sync_products()
    except Exception as e:
        logger.error(f"❌ Error en sincronización: {str(e)}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error en sincronización: {str(e)}",
        )


@router.delete("/all", dependencies=[Depends(verify_token)])
async def delete_all_products(confirm: bool = False):
    """
    Elimina todos los productos de Neo4j.
    ADVERTENCIA: operación destructiva e irreversible.
    """
    from rag_service.neo4j_client import neo4j_client

    if not confirm:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Debes pasar confirm=true para confirmar la eliminación de todos los productos",
        )

    logger.info(f"🗄️ Eliminando productos de: {neo4j_client.get_current_database()}")

    try:
        result = neo4j_client.delete_all_products()
        logger.info(f"🗑️ {result['message']}")
        return result
    except Exception as e:
        logger.error(f"❌ Error eliminando productos: {str(e)}")
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error eliminando productos: {str(e)}",
        )