# pec5d/lineage_oracle.py
"""
LINEAGE.ORACLE — Ancestral & Temporal Core.

12+ generation ancestral archive · bloodline signature matching ·
timeline divergence tracking. The archive is a vector-space model:
each generation is a resonance signature vector.
"""

from __future__ import annotations

import time
from typing import Any, Dict, List, Optional

import numpy as np

from pec5d.constants import LINEAGE_GENERATIONS, PHI


class LineageOracle:
    """LINEAGE.ORACLE — ancestral archive + signature matching engine."""

    def __init__(self, generations: int = LINEAGE_GENERATIONS):
        self.generations = generations
        self.archive: Dict[int, Dict[str, Any]] = {}
        self.signatures: List[np.ndarray] = []
        self.active = False

    def initialize(self) -> "LineageOracle":
        """Initialize the lineage archive."""
        print(f"📜 LINEAGE.ORACLE initializing — {self.generations}+ generations")
        rng = np.random.default_rng(seed=432)
        for gen in range(1, self.generations + 1):
            sig = rng.standard_normal(16)
            sig = sig / (np.linalg.norm(sig) or 1.0)
            self.signatures.append(sig)
            self.archive[gen] = {
                "generation": gen,
                "weight": round(float(np.mean(sig)), 4),
                "resonance": round(PHI ** (-gen / 12), 4),
                "signature_id": f"lineage_{gen:03d}",
            }
        self.active = True
        print(f"✅ LINEAGE.ORACLE archive loaded ({len(self.archive)} generations)")
        return self

    def match_signature(self, query: np.ndarray, top_k: int = 3) -> Dict[str, Any]:
        """Match a bloodline signature against the archive."""
        if not self.active:
            self.initialize()
        q = query / (np.linalg.norm(query) or 1.0)
        scores = [
            (gen, float(np.abs(np.vdot(q, sig))))
            for gen, sig in enumerate(self.signatures, start=1)
        ]
        scores.sort(key=lambda x: x[1], reverse=True)
        top = [{"generation": g, "similarity": round(s, 4)} for g, s in scores[:top_k]]
        return {"matches": top, "archive_size": len(self.archive)}

    def timeline_divergence(self, anchor_year: int, horizon: int = 20) -> Dict[str, Any]:
        """Track timeline divergence over a horizon (simulated)."""
        divergences = []
        for step in range(horizon):
            divergences.append({
                "step": step + 1,
                "divergence": round(float(np.random.random() * PHI / 10), 4),
            })
        return {
            "anchor_year": anchor_year,
            "horizon": horizon,
            "divergences": divergences,
            "generations_anchored": self.generations,
        }

    def get_state(self) -> Dict[str, Any]:
        """Oracle state."""
        return {
            "active": self.active,
            "generations": self.generations,
            "archive_entries": len(self.archive),
            "phi": PHI,
            "timestamp": time.time(),
        }