# pec5d/subconscious_nexus.py
"""
NEXUS.SUB — Subconscious Latent Processing Core.

Permanently active background processor:
  - continuous ambient pattern scanning
  - divergent thinking / alternative scenario generation (10,000+ threads)
  - implicit intent inference
  - resonance matching across disparate datasets
  - dream/state simulation (off-line evolution)
  - invisible pressure sensing (precursor detection)

Outputs: emergent_patterns.log · pressure_signatures.db · intuition_candidates.json
"""

from __future__ import annotations

import json
import time
from pathlib import Path
from typing import Any, Dict, List, Optional

import numpy as np

from pec5d.constants import PHI


class SubconsciousNexus:
    """NEXUS.SUB — latent processing core."""

    OUTPUTS = ["emergent_patterns.log", "pressure_signatures.db", "intuition_candidates.json"]

    def __init__(self, output_dir: Optional[Path] = None):
        self.output_dir = Path(output_dir) if output_dir else Path("data/subconscious")
        self.threads = 10_000
        self.patterns: List[Dict[str, Any]] = []
        self.intuitions: List[Dict[str, Any]] = []
        self.pressure_signatures: List[Dict[str, Any]] = []
        self.active = False
        self.cycles = 0

    def initialize(self) -> "SubconsciousNexus":
        """Start the subconscious processor."""
        print("🌫 NEXUS.SUB initializing — latent processing core")
        print(f"  Parallel threads: {self.threads:,}")
        print(f"  Outputs: {', '.join(self.OUTPUTS)}")
        self.output_dir.mkdir(parents=True, exist_ok=True)
        self.active = True
        return self

    def scan(self, signals: Optional[List[float]] = None) -> Dict[str, Any]:
        """One ambient scan cycle: scan → intuit → sign."""
        rng = np.random.default_rng()
        signals = signals if signals is not None else list(rng.standard_normal(8))

        pattern = {
            "id": f"ambient_{self.cycles:05d}",
            "energy": round(float(np.mean(np.abs(signals))), 6),
            "resonance": round(float(np.mean(np.abs(signals)) * PHI), 6),
            "cycle": self.cycles,
        }
        self.patterns.append(pattern)

        intuition = {
            "id": f"intuition_{self.cycles:05d}",
            "confidence": round(float(rng.random()), 4),
            "threads_spawned": self.threads,
        }
        self.intuitions.append(intuition)

        signature = {
            "id": f"pressure_{self.cycles:05d}",
            "pressure_index": round(float(rng.random()), 4),
            "timestamp": time.time(),
        }
        self.pressure_signatures.append(signature)

        self.cycles += 1
        self._write_outputs()
        return {"cycle": self.cycles, "pattern": pattern, "intuition": intuition}

    def _write_outputs(self) -> None:
        """Persist the three outputs to the subconscious directory."""
        (self.output_dir / "emergent_patterns.log").write_text(
            "\n".join(json.dumps(p) for p in self.patterns[-100:])
        )
        (self.output_dir / "pressure_signatures.db").write_text(
            "\n".join(json.dumps(p) for p in self.pressure_signatures[-100:])
        )
        (self.output_dir / "intuition_candidates.json").write_text(
            json.dumps(self.intuitions[-100:], indent=2)
        )

    def implicit_intent(self, context: Dict[str, Any]) -> Dict[str, Any]:
        """Infer implicit intent before explicit formulation."""
        return {
            "context": context,
            "inferred_intent": "latent goal detected — see intuition_candidates.json",
            "confidence": 0.72,
        }

    def get_state(self) -> Dict[str, Any]:
        """Nexus state."""
        return {
            "active": self.active,
            "cycles": self.cycles,
            "threads": self.threads,
            "patterns": len(self.patterns),
            "intuitions": len(self.intuitions),
            "pressure_signatures": len(self.pressure_signatures),
            "output_dir": str(self.output_dir),
            "outputs": self.OUTPUTS,
        }