"""Shared, dependency-light helpers for the DeepResearch-9K pipeline."""

from __future__ import annotations

import ast
import hashlib
import json
import re
import unicodedata
from collections.abc import Iterable, Iterator
from pathlib import Path
from typing import Any
from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit


TOOL_CALL_RE = re.compile(r"<tool_call>\s*(.*?)\s*</tool_call>", re.DOTALL | re.IGNORECASE)
TRACKING_QUERY_KEYS = {
    "fbclid",
    "gclid",
    "mc_cid",
    "mc_eid",
}


def normalize_question(text: str) -> str:
    """Normalize a question for duplicate detection without rewriting content."""
    return re.sub(r"\s+", " ", unicodedata.normalize("NFKC", text or "")).strip()


def question_key(text: str) -> str:
    return normalize_question(text).casefold()


def stable_qid(question: str) -> str:
    digest = hashlib.sha256(question_key(question).encode("utf-8")).hexdigest()[:16]
    return f"dr9k-{digest}"


def to_plain(value: Any) -> Any:
    """Recursively convert numpy/Arrow containers to JSON-compatible values."""
    if hasattr(value, "tolist"):
        return to_plain(value.tolist())
    if isinstance(value, dict):
        return {str(key): to_plain(item) for key, item in value.items()}
    if isinstance(value, (list, tuple)):
        return [to_plain(item) for item in value]
    if hasattr(value, "item"):
        try:
            return value.item()
        except (TypeError, ValueError):
            pass
    return value


def trajectory_fingerprint(row: dict[str, Any]) -> str:
    """Fingerprint the complete public row so DeepResearch-Hard matches exactly."""
    payload = {
        "question": normalize_question(str(row["question"])),
        "difficulty": int(row["difficulty"]),
        "search trajectory": to_plain(row["search trajectory"]),
        "final answer": str(row["final answer"]).strip(),
    }
    encoded = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()


def parse_tool_call_block(block: str) -> dict[str, Any]:
    """Parse one JSON-ish tool-call block.

    The public data contains a small number of Python-literal or fenced blocks,
    so JSON is attempted first and ``literal_eval`` is a conservative fallback.
    """
    value = block.strip()
    if value.startswith("```") and value.endswith("```"):
        value = re.sub(r"^```(?:json)?\s*|\s*```$", "", value, flags=re.DOTALL | re.IGNORECASE).strip()
    errors: list[str] = []
    for parser in (json.loads, ast.literal_eval):
        try:
            result = parser(value)
            if not isinstance(result, dict):
                raise ValueError(f"tool call is {type(result).__name__}, not an object")
            name = result.get("name")
            arguments = result.get("arguments", {})
            if not isinstance(name, str) or not name.strip():
                raise ValueError("tool call has no string name")
            if not isinstance(arguments, dict):
                raise ValueError("tool-call arguments are not an object")
            return {"name": name.strip(), "arguments": arguments}
        except (SyntaxError, ValueError, TypeError, json.JSONDecodeError) as exc:
            errors.append(str(exc))
    raise ValueError("; ".join(errors))


def iter_tool_calls(trajectory: Iterable[dict[str, Any]]) -> Iterator[tuple[int, int, dict[str, Any], str]]:
    """Yield ``(message_index, block_index, call, raw_block)`` from a trajectory."""
    for message_index, message in enumerate(trajectory):
        if message.get("role") != "assistant":
            continue
        content = str(message.get("content") or "")
        for block_index, match in enumerate(TOOL_CALL_RE.finditer(content)):
            raw = match.group(1)
            yield message_index, block_index, parse_tool_call_block(raw), raw


def as_string_list(value: Any) -> list[str]:
    if isinstance(value, str):
        return [value.strip()] if value.strip() else []
    if isinstance(value, (list, tuple)):
        return [str(item).strip() for item in value if str(item).strip()]
    return []


def unwrap_jina_url(url: str) -> tuple[str, bool]:
    """Return the underlying URL for an observed r.jina.ai reader URL."""
    value = url.strip()
    match = re.match(r"^https?://r\.jina\.ai/(https?://.+)$", value, flags=re.IGNORECASE)
    return (match.group(1), True) if match else (value, False)


def canonicalize_url(url: str) -> str:
    """Canonicalize an HTTP(S) URL for corpus deduplication."""
    value, _ = unwrap_jina_url(url)
    parsed = urlsplit(value.strip())
    scheme = parsed.scheme.lower()
    if scheme not in {"http", "https"} or not parsed.hostname:
        raise ValueError("only absolute HTTP(S) URLs are supported")
    hostname = parsed.hostname.encode("idna").decode("ascii").lower()
    port = parsed.port
    netloc = hostname
    if port and not ((scheme == "http" and port == 80) or (scheme == "https" and port == 443)):
        netloc = f"{hostname}:{port}"
    if parsed.username or parsed.password:
        raise ValueError("credential-bearing URLs are not supported")
    path = re.sub(r"/{2,}", "/", parsed.path or "/")
    if path != "/":
        path = path.rstrip("/")
    query_items = []
    for key, item in parse_qsl(parsed.query, keep_blank_values=True):
        lowered = key.casefold()
        if lowered.startswith("utm_") or lowered in TRACKING_QUERY_KEYS:
            continue
        query_items.append((key, item))
    query = urlencode(sorted(query_items))
    return urlunsplit((scheme, netloc, path, query, ""))


def url_id(canonical_url: str) -> str:
    return "url-" + hashlib.sha256(canonical_url.encode("utf-8")).hexdigest()[:24]


def write_jsonl(path: Path, records: Iterable[dict[str, Any]]) -> int:
    path.parent.mkdir(parents=True, exist_ok=True)
    count = 0
    with path.open("w", encoding="utf-8") as handle:
        for record in records:
            handle.write(json.dumps(record, ensure_ascii=False, sort_keys=True) + "\n")
            count += 1
    return count


def read_jsonl(path: Path) -> Iterator[dict[str, Any]]:
    with path.open(encoding="utf-8") as handle:
        for line_number, line in enumerate(handle, start=1):
            if not line.strip():
                continue
            try:
                yield json.loads(line)
            except json.JSONDecodeError as exc:
                raise ValueError(f"invalid JSON in {path}:{line_number}: {exc}") from exc