main.py

"""FastAPI backend over DuckDB - ICMR + HITEK combined dataset (2.5B rows, 11 cols).

Index-aware routing:
  - idx_phone.parquet  (sorted by phoneNumber)  -> fast exact phone/other lookups
  - idx_aadhar.parquet (sorted by aadharNumber) -> fast exact aadhar lookups
  - idx_name.parquet   (sorted by name)         -> fast name prefix/exact
  - Falls back to full scans of raw parquet while indexes are still building.
Dedup: max 2 rows per person. source column included (icmr / inddata "connected docs").
"""
import asyncio
import glob
import json
import os
import threading
from concurrent.futures import ThreadPoolExecutor
from typing import Any

import duckdb
from fastapi import FastAPI, HTTPException, Query, Response
from pydantic import BaseModel

BASE = os.path.dirname(os.path.abspath(__file__))
# data files may live in BASE or BASE/data (setup scripts download into data/)
_DATA_DIR = os.environ.get("ICMR_DATA_DIR") or \
    (os.path.join(BASE, "data") if os.path.isdir(os.path.join(BASE, "data")) else BASE)
PARQUET_FILES = [os.path.join(_DATA_DIR, f) for f in
                 ["part1.parquet", "part2a.parquet", "part2b_new.parquet"]]
IDX_PHONE = os.path.join(_DATA_DIR, "idx_phone.parquet")
IDX_AADHAR = os.path.join(_DATA_DIR, "idx_aadhar.parquet")
IDX_NAME = os.path.join(_DATA_DIR, "idx_name.parquet")
PARALLELISM = int(os.environ.get("ICMR_PARALLEL", "15"))
THREADS_PER_CONN = int(os.environ.get("ICMR_THREADS_PER_CONN", "8"))
DUPLICATE_CAP = 2  # max 2 copies of the same person in results

SEARCH_FIELDS = [
    "name", "fathersName", "phoneNumber", "aadharNumber", "otherNumber",
    "address", "district", "pincode", "state", "town", "source",
]
NUMBER_FIELDS = ["phoneNumber", "aadharNumber", "otherNumber"]

app = FastAPI(title="ICMR + HITEK Search API",
              description="DuckDB-backed search over 2.5B records (11 cols, dedup max 2)")

# ---- DuckDB connection pool (one connection per worker thread) ----
_conns: list[duckdb.DuckDBPyConnection] = []
_conns_lock = threading.Lock()
_thread_local = threading.local()
pool = ThreadPoolExecutor(max_workers=PARALLELISM, thread_name_prefix="duck")

_MISSING = [f for f in PARQUET_FILES if not os.path.exists(f)]


def _idx_files(path: str) -> list[str]:
    """Index may be a single file or split into sorted parts (idx_phone.0.parquet...)."""
    base, ext = os.path.splitext(path)  # idx_phone.parquet -> idx_phone / .parquet
    parts = sorted(glob.glob(f"{base}.*{ext}"))
    if parts and all(os.path.getsize(p) > 0 for p in parts):
        return parts
    return [path] if os.path.exists(path) and os.path.getsize(path) > 0 else []


def _idx_ready(path: str) -> bool:
    # index is usable when: file(s) exist+non-empty AND not caught mid-build
    # (build writes in place, so a START without DONE in the log = partial file)
    if not _idx_files(path):
        return False
    try:
        with open(os.path.join(BASE, "build_index.log"), encoding="utf-8",
                  errors="ignore") as f:
            log = f.read()
    except OSError:
        log = ""  # no log (fresh download) -> trust the downloaded file
    name = os.path.basename(path)
    if f"DONE {name}" in log:
        return True
    if f"START {name}" in log:
        return False  # build in progress / was interrupted -> partial
    return True  # no build ever started here -> file was downloaded whole


def _new_conn() -> duckdb.DuckDBPyConnection:
    con = duckdb.connect()  # in-memory
    con.execute("INSTALL parquet; LOAD parquet;")
    files = ", ".join(f"'{f}'" for f in PARQUET_FILES if os.path.exists(f))
    con.execute(f"CREATE VIEW people AS SELECT * FROM read_parquet([{files}])")
    # sorted index views (only if built) - zone-map pruning makes lookups fast
    for idx_path, view in [(IDX_PHONE, "people_phone"),
                           (IDX_AADHAR, "people_aadhar"),
                           (IDX_NAME, "people_name")]:
        files = _idx_files(idx_path)
        if files and _idx_ready(idx_path):
            lst = ", ".join(f"'{f}'" for f in files)
            con.execute(f"CREATE VIEW {view} AS SELECT * FROM read_parquet([{lst}])")
    con.execute(f"SET threads = {THREADS_PER_CONN}")
    return con


def _thread_id() -> int:
    tid = getattr(_thread_local, "id", None)
    if tid is None:
        with _conns_lock:
            tid = len(_conns)
            _thread_local.id = tid
    return tid


def _get_conn() -> duckdb.DuckDBPyConnection:
    ident = _thread_id()
    with _conns_lock:
        while len(_conns) <= ident:
            _conns.append(_new_conn())
    return _conns[ident]


# ---- Dedup: max 2 copies per person ----
def _person_key(row: dict[str, Any]) -> tuple[str, ...]:
    ph = (row.get("phoneNumber") or "").strip()
    ad = (row.get("aadharNumber") or "").strip()
    if ph or ad:
        return (ph, ad)
    return (row.get("name") or "").strip(), (row.get("fathersName") or "").strip()


def _cap_duplicates(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
    """Keep at most DUPLICATE_CAP rows per person (same phone+aadhar identity)."""
    seen: dict[tuple[str, ...], int] = {}
    out: list[dict[str, Any]] = []
    for r in rows:
        k = _person_key(r)
        n = seen.get(k, 0)
        if n < DUPLICATE_CAP:
            seen[k] = n + 1
            out.append(r)
    return out


# ---- Query helpers ----
def _run_sql(sql: str) -> list[dict[str, Any]]:
    con = _get_conn()
    rows = con.execute(sql).fetchall()
    cols = [d[0] for d in con.description]
    return [dict(zip(cols, r)) for r in rows]


def _source_clause(source: str | None) -> str:
    if source and source in ("icmr", "hitek", "inddata"):
        src = "hitek" if source == "hitek" else source
        return f" AND source = '{src}'"
    return ""


def _exact_scan(field: str, value: str, limit: int, source: str | None = None) -> str:
    v = value.replace("'", "''")
    return (f"SELECT * FROM people WHERE {field} = '{v}'"
            f"{_source_clause(source)} LIMIT {limit * DUPLICATE_CAP + 20}")


def _run_field_search(field: str, value: str, mode: str, limit: int,
                      source: str | None = None) -> dict[str, Any]:
    if field not in SEARCH_FIELDS:
        raise ValueError(f"Unknown field: {field}")
    v = value.replace("'", "''")
    view = "people"
    # use sorted index view when available for the hot fields
    if mode == "exact":
        if field == "phoneNumber" and _idx_ready(IDX_PHONE):
            view = "people_phone"
        elif field == "aadharNumber" and _idx_ready(IDX_AADHAR):
            view = "people_aadhar"
        elif field == "name" and _idx_ready(IDX_NAME):
            view = "people_name"
        sql = (f"SELECT * FROM {view} WHERE {field} = '{v}'"
               f"{_source_clause(source)} LIMIT {limit * DUPLICATE_CAP + 20}")
    elif mode == "contains":
        if field == "name" and _idx_ready(IDX_NAME):
            view = "people_name"  # sorted helps prefix; contains still scans but cached
        v2 = v.replace("%", r"\%").replace("_", r"\_")
        sql = (f"SELECT * FROM {view} WHERE {field} ILIKE '%{v2}%' ESCAPE '\\'"
               f"{_source_clause(source)} LIMIT {limit * DUPLICATE_CAP + 20}")
    else:
        raise ValueError(f"Unknown mode: {mode}")
    con = _get_conn()
    rows = con.execute(sql).fetchall()
    cols = [d[0] for d in con.description]
    results = _cap_duplicates([dict(zip(cols, r)) for r in rows])[:limit]
    return {"field": field, "value": value, "mode": mode, "count": len(results),
            "results": results}


async def _parallel(queries: list[tuple[str, str, str, int]]) -> list[dict[str, Any]]:
    loop = asyncio.get_running_loop()

    async def one(t: tuple[str, str, str, int]) -> dict[str, Any]:
        field, value, mode, limit = t
        return await loop.run_in_executor(pool, _run_field_search, field, value, mode, limit)

    return await asyncio.gather(*[one(t) for t in queries])


async def _unified_search(q: str, limit: int, source: str | None = None) -> dict[str, Any]:
    """Smart unified search: uses sorted indexes per field, merges, dedups."""
    q = q.strip()
    is_num = q.isdigit() and len(q) >= 8
    loop = asyncio.get_running_loop()

    if is_num:
        # number-like -> exact match, phone index first (fast), then aadhar, then other
        all_rows: list[dict[str, Any]] = []
        searched: list[str] = []
        # phone index ready -> instant; else full scan (slow, skip if we already found hits)
        if _idx_ready(IDX_PHONE):
            r = await loop.run_in_executor(pool, _run_field_search, "phoneNumber", q,
                                           "exact", limit, source)
            all_rows.extend(r["results"])
            searched.append("phoneNumber")
        if not all_rows and _idx_ready(IDX_AADHAR):
            r = await loop.run_in_executor(pool, _run_field_search, "aadharNumber", q,
                                           "exact", limit, source)
            all_rows.extend(r["results"])
            searched.append("aadharNumber")
        if not all_rows and _idx_ready(IDX_NAME):
            r = await loop.run_in_executor(pool, _run_field_search, "otherNumber", q,
                                           "exact", limit, source)
            all_rows.extend(r["results"])
            searched.append("otherNumber")
        all_rows = _cap_duplicates(all_rows)[:limit]
        return {"query": q, "searched_fields": searched or list(NUMBER_FIELDS),
                "dedup": DUPLICATE_CAP, "count": len(all_rows), "results": all_rows}
    else:
        # text -> name + fathersName contains via name index, then address/district/etc.
        jobs = [loop.run_in_executor(pool, _run_field_search, "name", q, "contains",
                                     limit, source)]
        if _idx_ready(IDX_NAME):
            jobs.append(loop.run_in_executor(pool, _run_field_search, "fathersName", q,
                                             "contains", limit, source))
        # also check number fields exact (safety net, only if numbers typed)
        results = await asyncio.gather(*jobs)
        all_rows = []
        for r in results:
            all_rows.extend(r["results"])
        all_rows = _cap_duplicates(all_rows)[:limit]
        fields = ["name", "fathersName"] + NUMBER_FIELDS
        return {"query": q, "searched_fields": fields, "dedup": DUPLICATE_CAP,
                "count": len(all_rows), "results": all_rows}


def _pretty(data: dict[str, Any], pretty: bool) -> Response:
    if pretty:
        return Response(content=json.dumps(data, indent=2, ensure_ascii=False),
                        media_type="application/json")
    return Response(content=json.dumps(data, ensure_ascii=False),
                    media_type="application/json")


# ---- API ----
class BatchRequest(BaseModel):
    queries: list[dict[str, Any]]
    limit: int = 10


@app.get("/")
def root():
    return {"app": "ICMR + HITEK Search API", "records": 2_504_793_870,
            "files": [os.path.basename(f) for f in PARQUET_FILES],
            "indexes": {"phone": _idx_ready(IDX_PHONE), "aadhar": _idx_ready(IDX_AADHAR),
                        "name": _idx_ready(IDX_NAME)},
            "columns": SEARCH_FIELDS, "parallelism": PARALLELISM, "dedup": DUPLICATE_CAP,
            "docs": "/docs"}


@app.get("/health")
def health():
    return {"status": "ok", "files_ready": len(PARQUET_FILES) - len(_MISSING),
            "files_total": len(PARQUET_FILES),
            "indexes": {"phone": _idx_ready(IDX_PHONE), "aadhar": _idx_ready(IDX_AADHAR),
                        "name": _idx_ready(IDX_NAME)},
            "missing": [os.path.basename(f) for f in _MISSING]}


@app.get("/search")
async def search(
    q: str = Query(..., description="Search term - matches name, phone, aadhar, other, address, district, pincode, state, town"),
    field: str | None = Query(None, description=f"Restrict to one field: {SEARCH_FIELDS}"),
    mode: str = Query("contains", pattern="^(exact|contains)$"),
    limit: int = Query(10, ge=1, le=1000),
    source: str | None = Query(None, pattern="^(icmr|hitek|inddata)$",
                               description="Filter by source: icmr, hitek (=inddata), inddata"),
    pretty: bool = Query(True, description="Pretty-print JSON"),
):
    """Unified search across all 11 columns. Duplicates capped at 2 per person."""
    if field:
        try:
            data = _run_field_search(field, q, mode, limit, source)
        except ValueError as e:
            raise HTTPException(400, str(e))
        data = {"query": q, "field": field, "mode": mode, "dedup": DUPLICATE_CAP,
                "count": data["count"], "results": data["results"]}
    else:
        data = await _unified_search(q, limit, source)
    return _pretty(data, pretty)


@app.post("/search/parallel")
async def search_parallel(req: BatchRequest):
    """Run up to 50 searches in parallel across a pool of DuckDB connections."""
    if not req.queries:
        raise HTTPException(400, "queries must not be empty")
    if len(req.queries) > 50:
        raise HTTPException(400, "max 50 queries per batch")
    results = await _parallel([(item.get("field", "name"), item.get("value", ""),
                                item.get("mode", "contains"), int(item.get("limit", req.limit)))
                               for item in req.queries])
    out = [{"error": str(r)} if isinstance(r, Exception) else r for r in results]
    return _pretty({"searches": len(req.queries), "parallelism": PARALLELISM, "results": out}, True)