"""Polars-backed query layer over the cve_diff parquet shards."""

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
from typing import Any

import polars as pl

PARQUET_GLOB = str(Path(__file__).resolve().parent.parent / "dataset" / "parquet" / "cve_diff-part*.parquet")

SEVERITIES = ["CRITICAL", "HIGH", "MEDIUM", "LOW", "NONE"]


@dataclass(frozen=True)
class SearchFilters:
    q: str = ""
    cwe: str = ""
    year: int | None = None
    severity: str = ""
    host: str = ""
    language: str = ""
    patch: str = ""  # "" = any, "yes" = has patch, "no" = no patch
    page: int = 1
    page_size: int = 25


def _load() -> pl.DataFrame:
    return pl.read_parquet(PARQUET_GLOB)


_DF: pl.DataFrame | None = None


def df() -> pl.DataFrame:
    global _DF
    if _DF is None:
        _DF = _load()
    return _DF


def facets() -> dict[str, list[Any]]:
    """Distinct values to populate filter dropdowns."""
    d = df()
    years = sorted(d["year"].unique().to_list(), reverse=True)
    cwes = (
        d.lazy()
        .select(pl.col("cwes").explode().struct.field("id"))
        .drop_nulls()
        .unique()
        .sort("id")
        .collect()["id"]
        .to_list()
    )
    hosts = (
        d.lazy()
        .select(pl.col("patch_hosts").explode().alias("host"))
        .drop_nulls()
        .unique()
        .sort("host")
        .collect()["host"]
        .to_list()
    )
    languages = (
        d.lazy()
        .select(pl.col("patch_languages").explode().alias("language"))
        .drop_nulls()
        .unique()
        .sort("language")
        .collect()["language"]
        .to_list()
    )
    return {
        "years": years,
        "cwes": cwes,
        "hosts": hosts,
        "languages": languages,
        "severities": SEVERITIES,
    }


def _apply_filters(lf: pl.LazyFrame, f: SearchFilters) -> pl.LazyFrame:
    if f.q:
        needle = f.q.strip()
        lf = lf.filter(
            pl.col("cve_id").str.contains(needle, literal=True)
            | pl.col("description").str.contains(f"(?i){needle}")
        )
    if f.cwe:
        cwe = f.cwe
        lf = lf.filter(
            pl.col("cwes").list.eval(pl.element().struct.field("id") == cwe).list.any()
        )
    if f.year is not None:
        lf = lf.filter(pl.col("year") == f.year)
    if f.severity:
        lf = lf.filter(pl.col("cvss_base_severity") == f.severity)
    if f.host:
        lf = lf.filter(pl.col("patch_hosts").list.contains(f.host))
    if f.language:
        lf = lf.filter(pl.col("patch_languages").list.contains(f.language))
    if f.patch == "yes":
        lf = lf.filter(pl.col("has_patch"))
    elif f.patch == "no":
        lf = lf.filter(~pl.col("has_patch"))
    return lf


def search(f: SearchFilters) -> tuple[list[dict], int]:
    """Return (page rows, total matching)."""
    lf = _apply_filters(df().lazy(), f)
    total = lf.select(pl.len()).collect().item()
    offset = max(0, (f.page - 1) * f.page_size)
    rows = (
        lf.sort("cve_id", descending=True)
        .slice(offset, f.page_size)
        .select(
            "cve_id",
            "year",
            "description",
            "cwes",
            "cvss_base_score",
            "cvss_base_severity",
            "patch_hosts",
            "patch_languages",
            "has_patch",
        )
        .collect()
        .to_dicts()
    )
    return rows, total


def get_cve(cve_id: str) -> dict | None:
    rows = (
        df()
        .lazy()
        .filter(pl.col("cve_id") == cve_id)
        .collect()
        .to_dicts()
    )
    return rows[0] if rows else None