"""
Search API routes.
"""

from fastapi import APIRouter, HTTPException, Query, Request
from typing import Optional
import uuid
import hashlib
import json
import logging

from ..models import (
    SearchRequest,
    ImageSearchRequest,
    SearchResponse,
    SearchSuggestResponse,
    DocumentResponse,
    ErrorResponse
)
from context.request_context import create_request_context, set_current_request_context, clear_current_request_context
from indexer.mapping_generator import get_tenant_index_name

router = APIRouter(prefix="/search", tags=["search"])
backend_verbose_logger = logging.getLogger("backend.verbose")


def _log_backend_verbose(payload: dict) -> None:
    if not backend_verbose_logger.handlers:
        return
    backend_verbose_logger.info(
        json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
    )


def extract_request_info(request: Request) -> tuple[str, str]:
    """Extract request ID and user ID from HTTP request"""
    # Try to get request ID from headers
    reqid = request.headers.get('X-Request-ID') or str(uuid.uuid4())[:8]

    # Try to get user ID from headers; if not found, use "-1" for correlation
    uid = request.headers.get('X-User-ID') or request.headers.get('User-ID') or "-1"

    return reqid, uid


@router.post("/", response_model=SearchResponse)
async def search(request: SearchRequest, http_request: Request):
    """
    Execute text search query (外部友好格式).

    Supports:
    - Multi-language query processing
    - Unified text retrieval strategy (no boolean AST parsing)
    - Semantic search with embeddings
    - Custom ranking functions
    - Exact match filters and range filters
    - Faceted search
    
    Requires tenant_id in header (X-Tenant-ID) or query parameter (tenant_id).
    """
    reqid, uid = extract_request_info(http_request)
    http_request.state.reqid = reqid
    http_request.state.uid = uid

    # Extract tenant_id (required)
    tenant_id = http_request.headers.get('X-Tenant-ID')
    if not tenant_id:
        # Try to get from query string
        from urllib.parse import parse_qs
        query_string = http_request.url.query
        if query_string:
            params = parse_qs(query_string)
            tenant_id = params.get('tenant_id', [None])[0]
    
    if not tenant_id:
        raise HTTPException(
            status_code=400,
            detail="tenant_id is required. Provide it via header 'X-Tenant-ID' or query parameter 'tenant_id'"
        )

    # Create request context
    context = create_request_context(reqid=reqid, uid=uid)

    # Set context in thread-local storage
    set_current_request_context(context)

    try:
        # Log request start (English logs, with key search parameters)
        client_ip = http_request.client.host if http_request.client else "unknown"
        user_agent = http_request.headers.get("User-Agent", "unknown")[:200]
        context.logger.info(
            "Received search request | "
            f"Tenant: {tenant_id} | "
            f"Query: {request.query} | "
            f"IP: {client_ip} | "
            f"User agent: {user_agent} | "
            f"size: {request.size} | from: {request.from_} | "
            f"sort_by: {request.sort_by} | sort_order: {request.sort_order} | "
            f"min_score: {request.min_score} | "
            f"language: {request.language} | "
            f"debug: {request.debug} | "
            f"enable_rerank: {request.enable_rerank} | "
            f"rerank_query_template: {request.rerank_query_template} | "
            f"rerank_doc_template: {request.rerank_doc_template} | "
            f"sku_filter_dimension: {request.sku_filter_dimension} | "
            f"filters: {request.filters} | "
            f"range_filters: {request.range_filters} | "
            f"facets: {request.facets}",
            extra={'reqid': context.reqid, 'uid': context.uid}
        )

        # Get searcher from app state
        from api.app import get_searcher
        searcher = get_searcher()

        # Execute search with context (using backend defaults from config)
        result = searcher.search(
            query=request.query,
            tenant_id=tenant_id,
            size=request.size,
            from_=request.from_,
            filters=request.filters,
            range_filters=request.range_filters,
            facets=request.facets,
            min_score=request.min_score,
            context=context,
            sort_by=request.sort_by,
            sort_order=request.sort_order,
            debug=request.debug,
            language=request.language,
            sku_filter_dimension=request.sku_filter_dimension,
            enable_rerank=request.enable_rerank,
            rerank_query_template=request.rerank_query_template,
            rerank_doc_template=request.rerank_doc_template,
        )

        # Include performance summary in response
        performance_summary = context.get_summary() if context else None
        stage_timings = {
            k: round(v, 2) for k, v in context.performance_metrics.stage_timings.items()
        }
        total_ms = round(float(context.performance_metrics.total_duration or result.took_ms), 2)
        context.logger.info(
            "Before response | total_ms: %s | stage_timings_ms: %s",
            total_ms,
            stage_timings,
            extra={'reqid': context.reqid, 'uid': context.uid}
        )

        # Convert to response model
        response = SearchResponse(
            results=result.results,
            total=result.total,
            max_score=result.max_score,
            took_ms=result.took_ms,
            facets=result.facets,
            query_info=result.query_info,
            suggestions=result.suggestions,
            related_searches=result.related_searches,
            performance_info=performance_summary,
            debug_info=result.debug_info
        )

        response_payload = response.model_dump(mode="json")
        response_json = json.dumps(response_payload, ensure_ascii=False, separators=(",", ":"))
        response_digest = hashlib.sha256(response_json.encode("utf-8")).hexdigest()[:16]
        max_score = float(response.max_score or 0.0)

        context.logger.info(
            "Search response | Total results: %s | Max score: %.4f | Time: %sms | payload_size: %s chars | digest: %s",
            response.total,
            max_score,
            response.took_ms,
            len(response_json),
            response_digest,
            extra={'reqid': context.reqid, 'uid': context.uid}
        )
        _log_backend_verbose({
            "event": "search_response",
            "reqid": context.reqid,
            "uid": context.uid,
            "tenant_id": tenant_id,
            "total_results": response.total,
            "max_score": max_score,
            "took_ms": response.took_ms,
            "payload_size_chars": len(response_json),
            "sha256_16": response_digest,
            "response": response_payload,
        })

        return response

    except Exception as e:
        # Log error in context
        if context:
            context.set_error(e)
            context.logger.error(
                f"Search request failed | error: {str(e)}",
                extra={'reqid': context.reqid, 'uid': context.uid}
            )
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        # Clear thread-local context
        clear_current_request_context()


@router.post("/image", response_model=SearchResponse)
async def search_by_image(request: ImageSearchRequest, http_request: Request):
    """
    Search by image similarity (外部友好格式).

    Uses image embeddings to find visually similar products.
    Supports exact match filters and range filters.
    
    Requires tenant_id in header (X-Tenant-ID) or query parameter (tenant_id).
    """
    reqid, uid = extract_request_info(http_request)
    http_request.state.reqid = reqid
    http_request.state.uid = uid

    # Extract tenant_id (required)
    tenant_id = http_request.headers.get('X-Tenant-ID')
    if not tenant_id:
        from urllib.parse import parse_qs
        query_string = http_request.url.query
        if query_string:
            params = parse_qs(query_string)
            tenant_id = params.get('tenant_id', [None])[0]
    
    if not tenant_id:
        raise HTTPException(
            status_code=400,
            detail="tenant_id is required. Provide it via header 'X-Tenant-ID' or query parameter 'tenant_id'"
        )

    # Create request context
    context = create_request_context(reqid=reqid, uid=uid)

    # Set context in thread-local storage
    set_current_request_context(context)

    try:
        # Log request start for image search (English)
        client_ip = http_request.client.host if http_request.client else "unknown"
        context.logger.info(
            "Received image search request | "
            f"Tenant: {tenant_id} | "
            f"Image URL: {request.image_url} | "
            f"IP: {client_ip}",
            extra={'reqid': context.reqid, 'uid': context.uid}
        )

        from api.app import get_searcher
        searcher = get_searcher()

        # Execute image search
        result = searcher.search_by_image(
            image_url=request.image_url,
            tenant_id=tenant_id,
            size=request.size,
            filters=request.filters,
            range_filters=request.range_filters
        )

        # Include performance summary in response
        performance_summary = context.get_summary() if context else None

        response = SearchResponse(
            results=result.results,
            total=result.total,
            max_score=result.max_score,
            took_ms=result.took_ms,
            facets=result.facets,
            query_info=result.query_info,
            suggestions=result.suggestions,
            related_searches=result.related_searches,
            performance_info=performance_summary
        )

        response_payload = response.model_dump(mode="json")
        response_json = json.dumps(response_payload, ensure_ascii=False, separators=(",", ":"))
        response_digest = hashlib.sha256(response_json.encode("utf-8")).hexdigest()[:16]
        max_score = float(response.max_score or 0.0)

        context.logger.info(
            "Image search response | Total results: %s | Max score: %.4f | Time: %sms | payload_size: %s chars | digest: %s",
            response.total,
            max_score,
            response.took_ms,
            len(response_json),
            response_digest,
            extra={'reqid': context.reqid, 'uid': context.uid}
        )
        _log_backend_verbose({
            "event": "image_search_response",
            "reqid": context.reqid,
            "uid": context.uid,
            "tenant_id": tenant_id,
            "total_results": response.total,
            "max_score": max_score,
            "took_ms": response.took_ms,
            "payload_size_chars": len(response_json),
            "sha256_16": response_digest,
            "response": response_payload,
        })

        return response

    except ValueError as e:
        if context:
            context.set_error(e)
            context.logger.error(
                f"Image search request parameter error | error: {str(e)}",
                extra={'reqid': context.reqid, 'uid': context.uid}
            )
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        if context:
            context.set_error(e)
            context.logger.error(
                f"Image search request failed | error: {str(e)}",
                extra={'reqid': context.reqid, 'uid': context.uid}
            )
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        # Clear thread-local context
        clear_current_request_context()


@router.get("/suggestions", response_model=SearchSuggestResponse)
async def search_suggestions(
    q: str = Query(..., min_length=1, description="搜索查询"),
    size: int = Query(10, ge=1, le=50, description="建议数量（1-50）"),
    language: str = Query("en", description="请求语言，如 zh/en/ar/ru"),
    debug: bool = Query(False, description="是否返回调试信息"),
    http_request: Request = None,
):
    """
    获取搜索建议（自动补全）。
    
    获取搜索建议（自动补全，支持多语言）。
    """
    # Extract tenant_id (required)
    tenant_id = http_request.headers.get("X-Tenant-ID") if http_request else None
    if not tenant_id and http_request:
        from urllib.parse import parse_qs
        query_string = http_request.url.query
        if query_string:
            params = parse_qs(query_string)
            tenant_id = params.get("tenant_id", [None])[0]

    if not tenant_id:
        raise HTTPException(
            status_code=400,
            detail="tenant_id is required. Provide it via header 'X-Tenant-ID' or query parameter 'tenant_id'",
        )

    try:
        from api.app import get_suggestion_service

        service = get_suggestion_service()
        result = service.search(
            tenant_id=tenant_id,
            query=q,
            language=language,
            size=size,
        )
        response = SearchSuggestResponse(
            query=result["query"],
            language=result.get("language"),
            resolved_language=result.get("resolved_language"),
            suggestions=result["suggestions"],
            took_ms=result["took_ms"],
        )
        if debug:
            # keep response_model stable; debug info stays inside suggestions payload for now
            return response
        return response
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/instant", response_model=SearchResponse)
async def instant_search(
    q: str = Query(..., min_length=2, description="搜索查询"),
    size: int = Query(5, ge=1, le=20, description="结果数量"),
):
    """
    即时搜索（Instant Search）。
    
    功能说明：
    - 边输入边搜索，无需点击搜索按钮
    - 返回简化的搜索结果
    
    注意：此功能暂未开放，当前明确返回 501。
    """
    # 明确暴露当前接口尚未完成实现，避免调用不完整逻辑导致隐式运行时错误。
    raise HTTPException(
        status_code=501,
        detail=(
            "/search/instant is not implemented yet. "
            "Use POST /search/ for production traffic."
        ),
    )


@router.get("/{doc_id}", response_model=DocumentResponse)
async def get_document(doc_id: str, http_request: Request):
    """
    Get a single document by ID.
    
    Requires tenant_id in header (X-Tenant-ID) or query parameter (tenant_id).
    """
    try:
        # Extract tenant_id (required)
        tenant_id = http_request.headers.get('X-Tenant-ID')
        if not tenant_id:
            # Try to get from query string
            from urllib.parse import parse_qs
            query_string = http_request.url.query
            if query_string:
                params = parse_qs(query_string)
                tenant_id = params.get('tenant_id', [None])[0]
        
        if not tenant_id:
            raise HTTPException(
                status_code=400,
                detail="tenant_id is required. Provide it via header 'X-Tenant-ID' or query parameter 'tenant_id'"
            )
        
        from api.app import get_searcher
        searcher = get_searcher()

        doc = searcher.get_document(tenant_id=tenant_id, doc_id=doc_id)

        if doc is None:
            raise HTTPException(status_code=404, detail=f"Document {doc_id} not found for tenant {tenant_id}")

        return DocumentResponse(id=doc_id, source=doc)

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/es-doc/{spu_id}")
async def get_es_raw_document(spu_id: str, http_request: Request):
    """
    Get raw Elasticsearch document(s) for a given SPU ID.

    This is intended for debugging in the test frontend:
    it queries the tenant-specific ES index with a term filter on spu_id
    and returns the raw ES search response.
    """
    # Extract tenant_id (required)
    tenant_id = http_request.headers.get("X-Tenant-ID")
    if not tenant_id:
        from urllib.parse import parse_qs
        query_string = http_request.url.query
        if query_string:
            params = parse_qs(query_string)
            tenant_id = params.get("tenant_id", [None])[0]

    if not tenant_id:
        raise HTTPException(
            status_code=400,
            detail="tenant_id is required. Provide it via header 'X-Tenant-ID' or query parameter 'tenant_id'",
        )

    try:
        from api.app import get_searcher

        searcher = get_searcher()
        es_client = searcher.es_client
        index_name = get_tenant_index_name(tenant_id)

        body = {
            "query": {
                "bool": {
                    "filter": [
                        {
                            "term": {
                                "spu_id": spu_id,
                            }
                        }
                    ]
                }
            },
        }

        es_response = es_client.search(index_name=index_name, body=body, size=5, from_=0)
        return es_response
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))