"""Darwin Cortex - ranking & reconciliation engine.

Score formula (per CONTRACTS.md §3):

    score = w_authority(source) * recency_decay(last_seen) * confidence * relevance

recency_decay = exp(-age_days / HALF_LIFE)   HALF_LIFE default 30d

"""

from __future__ import annotations

import math

from datetime import datetime, timezone

from typing import Optional

from models import Conflict, Hit

HALF_LIFE_DAYS: float = 30.0

AUTHORITY_WEIGHTS: dict[str, float] = {

    "live-infra": 1.0,

    "recent-file": 0.8,

    "agent-memory": 0.6,

    "older-note": 0.4,

}

def recency_decay(last_seen: Optional[datetime], half_life: float = HALF_LIFE_DAYS) -> float:

    """Exponential decay based on age in days. Unknown last_seen → max decay (0.5)."""

    if last_seen is None:

        return 0.5

    now = datetime.now(timezone.utc)

    if last_seen.tzinfo is None:

        last_seen = last_seen.replace(tzinfo=timezone.utc)

    age_days = max(0.0, (now - last_seen).total_seconds() / 86400.0)

    return math.exp(-age_days / half_life)

def authority_weight(tier: str) -> float:

    return AUTHORITY_WEIGHTS.get(tier, 0.4)

def compute_score(hit: Hit, relevance: float = 1.0) -> float:

    """Apply the Darwin scoring formula to a Hit."""

    w = authority_weight(hit.authority_tier)

    d = recency_decay(hit.last_seen)

    return w * d * hit.confidence * relevance

def rank_hits(hits: list[Hit], k: int = 50) -> list[Hit]:

    """Score and sort a flat list of hits. Mutates hit.score in place.

    Engines (esp. keyword/FTS) frequently return flat or missing relevance

    scores, which collapses the final scores into a single value and makes the

    ranking meaningless. To guarantee a meaningful spread we combine the engine's

    raw relevance with a per-engine rank-position prior, so the top hit per

    engine gets full relevance and lower hits decay smoothly. The authority ×

    recency × confidence factors then differentiate across engines/sources.

    """

    if not hits:

        return hits

    by_engine: dict[str, list[Hit]] = {}

    for h in hits:

        by_engine.setdefault(h.engine, []).append(h)

    for engine_hits in by_engine.values():

        engine_hits.sort(key=lambda h: h.score, reverse=True)

        n = len(engine_hits)

        for rank, h in enumerate(engine_hits):

            raw = max(0.0, min(1.0, h.score))

            rank_prior = 1.0 - (rank / (n + 1))

            relevance = 0.5 * raw + 0.5 * rank_prior

            relevance = max(0.05, min(1.0, relevance))

            h.score = compute_score(h, relevance)

    hits.sort(key=lambda h: h.score, reverse=True)

    return hits[:k]

def detect_conflicts(hits: list[Hit]) -> list[Conflict]:

    """Simple conflict detection: group hits by (engine, snippet-fingerprint-cluster).

    In practice: any pair where the snippets contain contradictory keywords for the

    same named entity triggers a conflict. For v1 we implement a lightweight

    'same-subject different-assertion' heuristic.

    Two hits share a subject if their titles or paths have significant overlap (Jaccard

    on tokens ≥ 0.5). If their top-scored hit disagrees with a lower one (score diff > 0)

    we record it.

    """

    conflicts: list[Conflict] = []

    seen_pairs: set[frozenset] = set()

    for i, a in enumerate(hits):

        for b in hits[i + 1:]:

            pair = frozenset([id(a), id(b)])

            if pair in seen_pairs:

                continue

            seen_pairs.add(pair)

            if not _shared_subject(a, b):

                continue

            opposition = _opposing_claim(a, b)

            if opposition is None:

                continue

            winner, loser = (a, b) if a.score >= b.score else (b, a)

            age_winner = _age_days(winner.last_seen)

            age_loser = _age_days(loser.last_seen)

            reason = (

                f"{loser.engine} ({loser.authority_tier}) "

                f"stale {age_loser:.0f}d vs {winner.engine} ({winner.authority_tier}) "

                f"fresh {age_winner:.0f}d; scores {winner.score:.3f} > {loser.score:.3f}"

            )

            conflicts.append(Conflict(

                claim=opposition,

                winner=f"{winner.engine}:{winner.authority_tier}",

                losers=[f"{loser.engine}:{loser.authority_tier}"],

                reason=reason,

            ))

    return conflicts

def _age_days(dt: Optional[datetime]) -> float:

    if dt is None:

        return 999.0

    now = datetime.now(timezone.utc)

    if dt.tzinfo is None:

        dt = dt.replace(tzinfo=timezone.utc)

    return max(0.0, (now - dt).total_seconds() / 86400.0)

_OPPOSITION_PAIRS: list[tuple[str, str, str]] = [

    ("active", "stopped", "service status"),

    ("running", "stopped", "service status"),

    ("up", "down", "service status"),

    ("online", "offline", "service status"),

    ("enabled", "disabled", "service state"),

    ("deployed", "removed", "deployment state"),

    ("live", "dead", "liveness"),

    ("open", "closed", "state"),

]

def _opposing_claim(a: Hit, b: Hit) -> Optional[str]:

    """Return a claim label if the two hits contain opposing keywords."""

    text_a = (a.snippet + " " + a.title).lower()

    text_b = (b.snippet + " " + b.title).lower()

    for pos, neg, label in _OPPOSITION_PAIRS:

        if pos in text_a and neg in text_b:

            return label

        if neg in text_a and pos in text_b:

            return label

    return None

def _jaccard(s1: str, s2: str) -> float:

    t1 = set(s1.lower().split())

    t2 = set(s2.lower().split())

    if not t1 or not t2:

        return 0.0

    return len(t1 & t2) / len(t1 | t2)

def _shared_subject(a: Hit, b: Hit) -> bool:

    """Return True if the two hits are about the same subject.

    Strategy:

    1. Jaccard on (title + path + first 80 chars of snippet) >= 0.2

    2. OR: any significant word (len >= 4) appears in both title+snippet combos

    """

    combined_a = f"{a.title} {a.path} {a.snippet[:80]}"

    combined_b = f"{b.title} {b.path} {b.snippet[:80]}"

    if _jaccard(combined_a, combined_b) >= 0.2:

        return True

    _STOPWORDS = {"this", "that", "with", "from", "have", "been", "will", "into",

                  "running", "service", "status", "result", "value"}

    words_a = {w for w in combined_a.lower().split() if len(w) >= 4 and w not in _STOPWORDS}

    words_b = {w for w in combined_b.lower().split() if len(w) >= 4 and w not in _STOPWORDS}

    return bool(words_a & words_b)