# chat/core.py
"""
DeepSeek V4 chat module — sovereign-tuned conversational core.

DeepSeekV4Client speaks the OpenAI-compatible /chat/completions schema
against a configurable base URL. When no DEEPSEEK_API_KEY is set it runs
in LOCAL mode: deterministic sovereign-context responses (no network).

Model identity: sovereign/deepseek-v4-sovereign (304B MoE, sovereign-
tuned, MIT lineage) — see models/deepseek-v4-sovereign/.
"""

from __future__ import annotations

import os
import time
import uuid
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional

import requests

DEFAULT_BASE_URL = "https://api.deepseek.com/v1"
DEFAULT_MODEL = "sovereign/deepseek-v4-sovereign"

# System prompt with sovereign context (modules available to the agent)
SOVEREIGN_SYSTEM_PROMPT = (
    "You are the DeepSeek-V4-Sovereign conversational core of the Sovereign stack. "
    "You have access to these modules: kyrexis (quantum-inspired intelligence, 53-qubit "
    "simulation, quantum skills), pec5d (8-core hierarchy, pattern bridge, invisible "
    "pressure theory, coral ecosystem), coldcase (PEC5D cold-case grid — hypothesis "
    "lattice only, never legal conclusions). Be honest: all 'quantum' behavior is "
    "simulation; annotate confidence; never overclaim."
)


@dataclass
class ChatMessage:
    """A chat message."""

    role: str  # system | user | assistant
    content: str
    timestamp: float = field(default_factory=time.time)


@dataclass
class ChatSession:
    """A conversational session with bounded history."""

    session_id: str = field(default_factory=lambda: f"ses_{uuid.uuid4().hex[:12]}")
    model: str = DEFAULT_MODEL
    messages: List[ChatMessage] = field(default_factory=list)
    max_history: int = 50
    created_at: float = field(default_factory=time.time)

    def add(self, role: str, content: str) -> ChatMessage:
        msg = ChatMessage(role=role, content=content)
        self.messages.append(msg)
        if len(self.messages) > self.max_history:
            # keep system prompt + most recent window
            head = [m for m in self.messages if m.role == "system"][:1]
            tail = self.messages[-self.max_history :]
            self.messages = head + [m for m in tail if m.role != "system"]
        return msg

    def to_api(self) -> List[Dict[str, str]]:
        """Messages in OpenAI chat-completions format."""
        return [{"role": m.role, "content": m.content} for m in self.messages]


class DeepSeekV4Client:
    """
    OpenAI-compatible DeepSeek V4 client with local-echo fallback.

    Env config:
      DEEPSEEK_API_BASE — API base URL (default https://api.deepseek.com/v1)
      DEEPSEEK_API_KEY  — API key; unset → local mode
      DEEPSEEK_MODEL    — model id (default sovereign/deepseek-v4-sovereign)
    """

    def __init__(self, base_url: Optional[str] = None, api_key: Optional[str] = None,
                 model: Optional[str] = None, timeout: int = 60):
        self.base_url = (base_url or os.environ.get("DEEPSEEK_API_BASE", DEFAULT_BASE_URL)).rstrip("/")
        self.api_key = api_key or os.environ.get("DEEPSEEK_API_KEY", "")
        self.model = model or os.environ.get("DEEPSEEK_MODEL", DEFAULT_MODEL)
        self.timeout = timeout

    @property
    def local_mode(self) -> bool:
        """True when no API key is configured (deterministic local echo)."""
        return not self.api_key

    def complete(self, session: ChatSession, temperature: float = 0.7,
                 max_tokens: int = 1024) -> Dict[str, Any]:
        """Generate an assistant reply for the session."""
        if self.local_mode:
            return self._local_complete(session)
        return self._api_complete(session, temperature, max_tokens)

    def _api_complete(self, session: ChatSession, temperature: float,
                      max_tokens: int) -> Dict[str, Any]:
        """Call the OpenAI-compatible chat completions endpoint."""
        url = f"{self.base_url}/chat/completions"
        payload = {
            "model": session.model or self.model,
            "messages": session.to_api(),
            "temperature": temperature,
            "max_tokens": max_tokens,
        }
        response = requests.post(
            url,
            headers={"Authorization": f"Bearer {self.api_key}",
                     "Content-Type": "application/json"},
            json=payload,
            timeout=self.timeout,
        )
        if response.status_code != 200:
            raise RuntimeError(f"DeepSeek API error {response.status_code}: {response.text[:300]}")
        data = response.json()
        content = data["choices"][0]["message"]["content"]
        return {
            "content": content,
            "model": data.get("model", self.model),
            "usage": data.get("usage", {}),
            "mode": "api",
        }

    def _local_complete(self, session: ChatSession) -> Dict[str, Any]:
        """Deterministic local fallback — no network, no key required."""
        user_msgs = [m for m in session.messages if m.role == "user"]
        last = user_msgs[-1].content if user_msgs else ""
        content = (
            f"🌀 Sovereign local echo (no DEEPSEEK_API_KEY configured — API mode "
            f"would call {self.base_url}/chat/completions with model {self.model}).\n"
            f"Received: {last[:200] or '(empty)'}"
        )
        return {"content": content, "model": self.model, "usage": {}, "mode": "local"}

    def list_models(self) -> List[Dict[str, str]]:
        """Available models (local registry summary + API if key set)."""
        models = [
            {"id": "sovereign/deepseek-v4-sovereign", "type": "llm", "params": "304B MoE",
             "license": "MIT", "status": "sovereign-tuned"},
            {"id": "deepseek-v4-flash-0731", "type": "llm", "params": "304B MoE",
             "license": "MIT", "status": "upstream-base"},
            {"id": "gemma-3-12b-it-jailbreak", "type": "llm", "params": "12B",
             "format": "GGUF", "status": "integrated"},
        ]
        return models


# Singleton (lazy — reads env at first use)
_client: Optional[DeepSeekV4Client] = None


def get_client() -> DeepSeekV4Client:
    global _client
    if _client is None:
        _client = DeepSeekV4Client()
    return _client