"""Term detection over text using term_registry.words[] aliases.

Builds one compiled regex from all aliases (case-insensitive, word-bounded).
Maps matches back to canonical slugs. Supports 1-hop expansion via depends_on.
"""
from __future__ import annotations
import re


def build_regex(registry: dict) -> re.Pattern:
    """Compile a single regex matching any alias in registry.terms[*].words[].

    Aliases are sorted longest-first so 'elasticity of demand' matches
    before 'elasticity'. Word boundaries enforced. Case-insensitive.
    """
    aliases: list[tuple[str, str]] = []  # (alias, canonical_slug)
    for slug, term in registry.get("terms", {}).items():
        for word in term.get("words", []) or []:
            aliases.append((word, slug))
    # Longest first to prevent shorter aliases shadowing longer ones
    aliases.sort(key=lambda p: len(p[0]), reverse=True)
    if not aliases:
        return re.compile(r"$^")  # never matches
    pattern = r"\b(" + "|".join(re.escape(a[0]) for a in aliases) + r")\b"
    return re.compile(pattern, re.IGNORECASE)


def find_terms(text: str, regex: re.Pattern, registry: dict) -> list[str]:
    """Return list of canonical slugs whose aliases appear in text.

    Deduped, ordered by first appearance.
    """
    # Build alias -> slug lookup (case-folded)
    alias_to_slug: dict[str, str] = {}
    for slug, term in registry.get("terms", {}).items():
        for word in term.get("words", []) or []:
            alias_to_slug[word.lower()] = slug
    seen: list[str] = []
    for m in regex.finditer(text):
        slug = alias_to_slug.get(m.group(0).lower())
        if slug and slug not in seen:
            seen.append(slug)
    return seen


def expand_one_hop(seed_slugs: list[str], registry: dict) -> list[str]:
    """Return 1-hop neighbors (via depends_on) of seed_slugs, excluding seeds.

    Output is deterministic: deduped, sorted alphabetically.
    """
    seeds = set(seed_slugs)
    neighbors: set[str] = set()
    terms = registry.get("terms", {})
    for seed in seeds:
        for n in terms.get(seed, {}).get("depends_on", []) or []:
            if n not in seeds:
                neighbors.add(n)
    return sorted(neighbors)