"""RAGFlow-compatible chunk search over Elasticsearch (BM25 + vector RRF).

Mirrors ``POST /api/v1/datasets/search`` request shape: metadata filtering,
lexical retrieval via ``query_string``, vector kNN, and client-side RRF fusion.
When ``rerank_id`` is set, kNN candidates are rescored via
``rerank_vector_hits`` (reranker scores only).
"""

from __future__ import annotations

import asyncio
import re
from typing import TYPE_CHECKING, Any

from loguru import logger
from pydantic import BaseModel, Field

from ragext.base.es.rrf import fuse_hits
from ragext.base.es.search import Hit
from ragext.ragflow.bm25_search import bm25_search_ragflow
from ragext.ragflow.knn_search import knn_search_ragflow
from ragext.ragflow.query import prepare_ragflow_query

from .meta_filter import (
    UnsupportedMetaFilter,
    build_chunk_metadata_filter_clauses,
    is_pushdown_supported,
)

if TYPE_CHECKING:
    from aiomysql import Pool
    from elasticsearch import AsyncElasticsearch

    from ragext.base.model.embedding import EmbeddingClient, RerankClient

CHUNK_SOURCE_FIELDS = [
    "docnm_kwd",
    "content_ltks",
    "content_with_weight",
    "kb_id",
    "img_id",
    "title_tks",
    "important_kwd",
    "tag_kwd",
    "position_int",
    "doc_id",
    "doc_type_kwd",
    "mom_id",
    "available_int",
    "metadata",
]


class ChunkMetadataCondition(BaseModel):
    field: str
    operator: str = "="
    value: str


class ChunkMetadataFilter(BaseModel):
    conditions: list[ChunkMetadataCondition] = Field(default_factory=list)
    logic: str = "and"


class SearchChunkRequest(BaseModel):
    """Request body aligned with RAGFlow ``/api/v1/datasets/search``."""

    dataset_ids: list[str]
    question: str
    similarity_threshold: float = Field(default=0.2, ge=0.0, le=1.0)
    vector_similarity_weight: float = Field(default=0.3, ge=0.0, le=1.0)
    top_k: int = Field(default=1024, ge=1, le=2048)
    use_kg: bool = False
    chunk_metadata_filter: ChunkMetadataFilter | None = None
    doc_ids: list[str] | None = None
    page: int = Field(default=1, ge=1)
    size: int = Field(default=10, ge=1, le=100)
    highlight: bool = False
    # Non-empty enables model rerank over kNN hits (``rerank_vector_hits``).
    # Value may be a model name or ``model@Factory``; empty keeps RRF ranking.
    rerank_id: str | None = None


class SearchChunk(BaseModel):
    chunk_id: str
    content_ltks: str = ""
    content_with_weight: str = ""
    doc_id: str = ""
    doc_type_kwd: str = ""
    docnm_kwd: str = ""
    image_id: str = ""
    important_kwd: list[str] | str = Field(default_factory=list)
    kb_id: str = ""
    metadata: dict[str, str] = Field(default_factory=dict)
    mom_id: str = ""
    positions: list[list[int]] = Field(default_factory=list)
    row_id: int | str | None = None
    similarity: float = 0.0
    tag_kwd: list[str] | str = Field(default_factory=list)


class DocAgg(BaseModel):
    count: int
    doc_id: str
    doc_name: str


class SearchChunkResponse(BaseModel):
    chunks: list[SearchChunk]
    doc_aggs: list[DocAgg] = Field(default_factory=list)
    labels: dict[str, float] | None = None
    total: int


class RagflowApiResponse(BaseModel):
    """RAGFlow HTTP envelope: ``{"code": 0, "data": {...}}``."""

    code: int = 0
    data: SearchChunkResponse | None = None
    message: str | None = None


def chunk_index_name(tenant_id: str) -> str:
    return f"ragflow_{tenant_id}"


async def resolve_tenant_ids(pool: Pool, dataset_ids: list[str]) -> dict[str, str]:
    if not dataset_ids:
        return {}
    placeholders = ", ".join(["%s"] * len(dataset_ids))
    sql = f"SELECT id, tenant_id FROM knowledgebase WHERE id IN ({placeholders})"
    async with pool.acquire() as conn, conn.cursor() as cur:
        await cur.execute(sql, dataset_ids)
        rows = await cur.fetchall()
    return {str(row[0]): str(row[1]) for row in rows}


def _chunk_meta_filters(meta: ChunkMetadataFilter) -> list[dict[str, Any]]:
    return [
        {"key": c.field, "op": c.operator, "value": c.value}
        for c in meta.conditions
    ]


def build_chunk_filter(
    kb_ids: list[str],
    doc_ids: list[str] | None = None,
    metadata_clauses: list[dict[str, Any]] | None = None,
) -> dict[str, Any]:
    # Match RAGFlow ES: exclude disabled chunks (available_int < 1), keep missing field.
    clauses: list[dict[str, Any]] = [
        {"terms": {"kb_id": kb_ids}},
        {"bool": {"must_not": [{"range": {"available_int": {"lt": 1}}}]}},
    ]
    if doc_ids:
        clauses.append({"terms": {"doc_id": doc_ids}})
    if metadata_clauses:
        clauses.extend(metadata_clauses)
    return {"bool": {"filter": clauses}}


def _as_str_list(value: Any) -> list[str]:
    if value is None:
        return []
    if isinstance(value, str):
        return [value] if value else []
    if isinstance(value, list):
        return [str(v) for v in value]
    return [str(value)]


def _metadata(src: dict[str, Any]) -> dict[str, str]:
    raw = src.get("metadata")
    if not isinstance(raw, dict):
        return {}
    return {str(k): str(v) for k, v in raw.items() if k is not None}


def _round2(value: float) -> float:
    return round(float(value), 2)


def _positions(src: dict[str, Any]) -> list[list[int]]:
    raw = src.get("position_int") or src.get("positions") or []
    if not isinstance(raw, list):
        return []
    out: list[list[int]] = []
    for item in raw:
        if isinstance(item, list):
            out.append([int(x) for x in item])
    return out


def _blended_similarity(
    hits: list[Hit],
    term_scores: dict[str, float],
    vector_scores: dict[str, float],
    vec_w: float,
) -> list[Hit]:
    """One ``[0, 1]`` score from normalized BM25 and kNN similarity.

    ``term_norm`` is the hit's BM25 score divided by the maximum BM25 in this
    batch (hits missing from lexical retrieval are 0). kNN scores are clamped
    to ``[0, 1]``; hits missing from vector retrieval are 0.

    ``similarity = (1 - vec_w) * term_norm + vec_w * vector``.
    """

    peak = max((term_scores.get(hit.id, 0.0) for hit in hits), default=0.0)
    if peak <= 0.0:
        peak = 1.0
    blended: list[Hit] = []
    for hit in hits:
        term_norm = max(0.0, term_scores.get(hit.id, 0.0)) / peak
        vector = vector_scores.get(hit.id, 0.0)
        vector = max(0.0, min(1.0, vector))
        sim = (1.0 - vec_w) * term_norm + vec_w * vector
        blended.append(Hit(id=hit.id, score=sim, source=hit.source))
    blended.sort(key=lambda item: item.score, reverse=True)
    return blended


def _to_chunk(hit: Hit) -> SearchChunk:
    src = hit.source
    kb_id = str(src.get("kb_id", "") or "")
    image_id = str(src.get("img_id") or src.get("image_id") or "")
    if not image_id and kb_id:
        image_id = f"{kb_id}-{hit.id}"
    mom_id = src.get("mom_id")
    return SearchChunk(
        chunk_id=hit.id,
        content_ltks=src.get("content_ltks", "") or "",
        content_with_weight=src.get("content_with_weight", "") or "",
        doc_id=str(src.get("doc_id", "") or ""),
        doc_type_kwd=str(src.get("doc_type_kwd", "") or ""),
        docnm_kwd=str(src.get("docnm_kwd", "") or ""),
        image_id=image_id,
        important_kwd=_as_str_list(src.get("important_kwd")),
        kb_id=kb_id,
        metadata=_metadata(src),
        mom_id="" if mom_id is None else str(mom_id),
        positions=_positions(src),
        row_id=src.get("row_id"),
        similarity=_round2(hit.score),
        tag_kwd=_as_str_list(src.get("tag_kwd")),
    )


def _build_doc_aggs(hits: list[Hit]) -> list[DocAgg]:
    counts: dict[str, list[Any]] = {}
    for hit in hits:
        doc_id = str(hit.source.get("doc_id", "") or "")
        doc_name = str(hit.source.get("docnm_kwd", "") or "")
        if doc_id not in counts:
            counts[doc_id] = [0, doc_name]
        counts[doc_id][0] += 1
        if not counts[doc_id][1] and doc_name:
            counts[doc_id][1] = doc_name
    aggs = [
        DocAgg(count=int(count), doc_id=doc_id, doc_name=str(doc_name))
        for doc_id, (count, doc_name) in counts.items()
    ]
    aggs.sort(key=lambda a: (-a.count, a.doc_name, a.doc_id))
    return aggs


def _remove_redundant_spaces(txt: str) -> str:
    """Match RAGFlow ``common.string_utils.remove_redundant_spaces``."""

    txt = re.sub(r"([^a-z0-9.,\)>]) +([^ ])", r"\1\2", txt, flags=re.IGNORECASE)
    return re.sub(r"([^ ]) +([^a-z0-9.,\(<])", r"\1\2", txt, flags=re.IGNORECASE)


def _as_token_list(value: Any) -> list[str]:
    if value is None:
        return []
    if isinstance(value, str):
        return [t for t in value.split() if t]
    if isinstance(value, list):
        out: list[str] = []
        for item in value:
            if isinstance(item, str):
                out.extend(t for t in item.split() if t)
            elif item is not None:
                out.append(str(item))
        return out
    return [str(value)]


def _chunk_rerank_tokens(src: dict[str, Any], *, cfield: str = "content_ltks") -> list[str]:
    """Build token list for model rerank docs (RAGFlow ``rerank_by_model``)."""

    content_ltks = _as_token_list(src.get(cfield))
    title_tks = _as_token_list(src.get("title_tks"))
    important_kwd = _as_token_list(src.get("important_kwd"))
    return content_ltks + title_tks + important_kwd


def _token_similarity(query_tokens: list[str], docs_tokens: list[list[str]]) -> list[float]:
    """Lightweight token coverage similarity (RAGFlow ``token_similarity`` spirit).

    Uses equal per-token weights: matched query-token mass / total query-token mass.
    """

    if not query_tokens:
        return [0.0] * len(docs_tokens)
    q_counts: dict[str, float] = {}
    for t in query_tokens:
        q_counts[t] = q_counts.get(t, 0.0) + 1.0
    q_total = sum(q_counts.values()) + 1e-9
    out: list[float] = []
    for dtks in docs_tokens:
        d_set = set(dtks)
        hit = sum(w for t, w in q_counts.items() if t in d_set)
        out.append(hit / q_total)
    return out


async def rerank_by_model(
    rerank: RerankClient,
    hits: list[Hit],
    query: str,
    *,
    tkweight: float,
    vtweight: float,
    similarity_threshold: float,
) -> tuple[list[Hit], dict[str, float], dict[str, float]]:
    """Rescore candidates like RAGFlow ``Dealer.rerank_by_model``.

    ``sim = tkweight * tksim + vtweight * vtsim`` where ``vtsim`` comes from the
    reranker (normalized to ``[0, 1]``). Results are sorted by ``sim`` descending
    and filtered by ``similarity_threshold``.
    """

    if not hits:
        return [], {}, {}

    docs_tokens = [_chunk_rerank_tokens(h.source) for h in hits]
    docs = [_remove_redundant_spaces(" ".join(tks)) for tks in docs_tokens]
    # Prefer raw text when token fields are empty so the reranker still sees content.
    for i, doc in enumerate(docs):
        if not doc.strip():
            docs[i] = str(hits[i].source.get("content_with_weight") or "")

    query_tokens = prepare_ragflow_query(query).split()
    tksim = _token_similarity(query_tokens, docs_tokens)
    vtsim = await rerank.similarity(query, docs)

    scored: list[tuple[float, float, float, Hit]] = []
    for i, hit in enumerate(hits):
        sim = tkweight * tksim[i] + vtweight * vtsim[i]
        scored.append((sim, tksim[i], vtsim[i], hit))
    # Stable sort by similarity descending (RAGFlow uses argsort kind='stable').
    scored.sort(key=lambda x: x[0], reverse=True)

    post_threshold = 0.0 if vtweight <= 0 else similarity_threshold
    term_scores: dict[str, float] = {}
    vector_scores: dict[str, float] = {}
    out: list[Hit] = []
    for sim, tsim, vsim, hit in scored:
        if sim < post_threshold:
            continue
        out.append(Hit(id=hit.id, score=float(sim), source=hit.source))
        term_scores[hit.id] = float(tsim)
        vector_scores[hit.id] = float(vsim)
    return out, term_scores, vector_scores


async def rerank_vector_hits(
    rerank: RerankClient,
    hits: list[Hit],
    query: str,
    *,
    similarity_threshold: float,
) -> tuple[list[Hit], dict[str, float], dict[str, float]]:
    """Rerank vector (kNN) candidates with model scores only.

    Simpler than ``rerank_by_model``: no token-similarity blend. Expects
    ``hits`` from vector retrieval. ``hit.score`` is the normalized reranker
    score and is returned as the chunk ``similarity``.
    """

    if not hits:
        return [], {}, {}

    docs: list[str] = []
    for h in hits:
        tks = _chunk_rerank_tokens(h.source)
        doc = _remove_redundant_spaces(" ".join(tks))
        if not doc.strip():
            doc = str(h.source.get("content_with_weight") or "")
        docs.append(doc)

    vtsim = await rerank.similarity(query, docs)
    scored = sorted(
        ((vtsim[i], hits[i]) for i in range(len(hits))),
        key=lambda x: x[0],
        reverse=True,
    )

    term_scores: dict[str, float] = {}
    vector_scores: dict[str, float] = {}
    out: list[Hit] = []
    for score, hit in scored:
        if score < similarity_threshold:
            continue
        out.append(Hit(id=hit.id, score=float(score), source=hit.source))
        term_scores[hit.id] = 0.0
        vector_scores[hit.id] = float(score)
    return out, term_scores, vector_scores


async def _bm25_hits(
    es: AsyncElasticsearch,
    indices: list[str],
    question: str,
    *,
    es_filter: dict[str, Any],
    top_k: int,
) -> list[Hit]:
    hits = await bm25_search_ragflow(
        es,
        indices,
        question,
        es_filter=es_filter,
        size=top_k,
        source=CHUNK_SOURCE_FIELDS,
    )
    if hits:
        return hits
    return await bm25_search_ragflow(
        es,
        indices,
        question,
        es_filter=es_filter,
        size=top_k,
        source=CHUNK_SOURCE_FIELDS,
        min_match="10%",
    )


async def search_chunks(
    req: SearchChunkRequest,
    *,
    es: AsyncElasticsearch,
    embedding: EmbeddingClient,
    rerank: RerankClient | None = None,
    mysql_pool: Pool | None = None,
) -> SearchChunkResponse:
    """Hybrid BM25 + vector search with client-side RRF over RAGFlow chunk indices.

    Each chunk carries a single ``similarity`` in ``[0, 1]``. Without rerank
    that score blends batch-normalized BM25 with kNN similarity. When
    ``req.rerank_id`` is non-empty, kNN candidates are rescored by
    ``rerank_vector_hits`` and ``similarity`` is the model content score.
    """

    if not req.question.strip():
        return SearchChunkResponse(chunks=[], doc_aggs=[], labels=None, total=0)
    if not req.dataset_ids:
        raise ValueError("dataset_ids must not be empty")

    if mysql_pool is not None:
        tenant_map = await resolve_tenant_ids(mysql_pool, req.dataset_ids)
        missing = [d for d in req.dataset_ids if d not in tenant_map]
        if missing:
            raise ValueError(f"dataset(s) not found: {', '.join(missing)}")
        tenant_ids = list(dict.fromkeys(tenant_map.values()))
    else:
        tenant_ids = list(dict.fromkeys(req.dataset_ids))

    indices = [chunk_index_name(tid) for tid in tenant_ids]

    doc_ids = list(req.doc_ids) if req.doc_ids else []
    metadata_clauses: list[dict[str, Any]] = []
    if req.chunk_metadata_filter and req.chunk_metadata_filter.conditions:
        filters = _chunk_meta_filters(req.chunk_metadata_filter)
        if not is_pushdown_supported(filters):
            raise ValueError("unsupported chunk_metadata_filter operator or field")
        try:
            metadata_clauses = build_chunk_metadata_filter_clauses(
                filters,
                req.chunk_metadata_filter.logic,
            )
        except UnsupportedMetaFilter as exc:
            raise ValueError(f"invalid chunk_metadata_filter: {exc.reason}") from exc

    es_filter = build_chunk_filter(
        req.dataset_ids,
        doc_ids or None,
        metadata_clauses or None,
    )
    vec_w = req.vector_similarity_weight

    query_vector = await embedding.embed_query(req.question)
    bm25_hits, knn_hits = await asyncio.gather(
        _bm25_hits(es, indices, req.question, es_filter=es_filter, top_k=req.top_k),
        knn_search_ragflow(
            es,
            indices,
            query_vector,
            dim=len(query_vector),
            top_k=req.top_k,
            es_filter=es_filter,
            similarity_threshold=req.similarity_threshold,
            source=CHUNK_SOURCE_FIELDS,
        ),
    )

    if vec_w <= 0.0:
        hits = bm25_hits[: req.top_k]
    elif vec_w >= 1.0:
        hits = knn_hits[: req.top_k]
    else:
        hits = fuse_hits(
            [bm25_hits, knn_hits],
            weights=[1.0 - vec_w, vec_w],
            top_n=req.top_k,
        )

    term_scores = {h.id: h.score for h in bm25_hits}
    vector_scores = {h.id: h.score for h in knn_hits}

    rerank_id = (req.rerank_id or "").strip()
    if rerank_id:
        # hits, term_scores, vector_scores = await rerank_by_model(
        #     rerank,
        #     hits,
        #     req.question,
        #     tkweight=1.0 - vec_w,
        #     vtweight=vec_w,
        #     similarity_threshold=req.similarity_threshold,
        # )
        try:
            if rerank is None:
                raise ValueError("rerank_id is set but rerank client is not configured")
            hits, _, _ = await rerank_vector_hits(
                rerank,
                knn_hits,
                req.question,
                similarity_threshold=req.similarity_threshold,
            )
        except Exception:
            logger.warning(
                "rerank_vector_hits failed; falling back to knn hits "
                "(rerank_id={!r})",
                rerank_id,
            )
            hits = knn_hits[: req.top_k]
    else:
        hits = _blended_similarity(hits, term_scores, vector_scores, vec_w)

    total = len(hits)
    offset = (req.page - 1) * req.size
    chunks = [_to_chunk(hit) for hit in hits[offset : offset + req.size]]
    return SearchChunkResponse(
        chunks=chunks,
        doc_aggs=_build_doc_aggs(hits),
        labels=None,
        total=total,
    )
