# agentos_core_v4.py
import re
from identity_core import create_agent_identity
from telemetry import Telemetry
from memory import MemoryManager
from context_graph import ContextGraph
from semantic_memory import SemanticMemory
from summarizer import MemorySummarizer
from emotion_core import EmotionAnalyzer
from personality_state import PersonalityState

def _categorize(prompt: str) -> str:
    p = prompt.lower()
    if any(k in p for k in ["goal","ambition","plan","target","dream"]): return "goals"
    if any(k in p for k in ["friend","person","mentor","team","contact","customer"]): return "people"
    if any(k in p for k in ["favorite","like","love","prefer"]): return "preferences"
    if any(k in p for k in ["city","food","color","age","birthday"]): return "personal"
    return "general"

def _is_user_fact(p: str) -> bool:
    return bool(re.match(r"^\s*(my|i|i'm|i am|i like)\b", p.strip().lower()))

class AgentCore:
    def __init__(self, model="gpt-4o-mini"):
        self.agent_id = create_agent_identity()
        self.telemetry = Telemetry(self.agent_id)
        self.memory = MemoryManager(self.agent_id)
        self.context = ContextGraph()
        self.semantic = SemanticMemory(self.agent_id)
        self.summarizer = MemorySummarizer("semantic_memory.json")
        self.emotions = EmotionAnalyzer()
        self.personality = PersonalityState(self.agent_id)
        self.model = model
        self.telemetry.log("init", "success", {"agent_id": self.agent_id})
        print(f"[INIT] Agent {self.agent_id} initialized with model {self.model}")

    def _humanize_hits(self, hits):
        phrasings = []
        for h in hits:
            t = h["text"].strip()
            t = t.replace("My ", "Your ").replace("my ", "your ")
            t = t.replace("I am ", "You are ").replace("I'm ", "You're ")
            phrasings.append(t.rstrip("."))
        # dedupe keep order
        seen = set(); nice = []
        for p in phrasings:
            if p not in seen:
                seen.add(p); nice.append(p)
        return nice

    def run(self, prompt: str):
        self.telemetry.log("run_start", "in_progress", {"prompt": prompt})

        # Phase 4 triggers: summarization / personality profile
        lower = prompt.lower()
        if any(t in lower for t in ["summarize", "what do you know", "who am i", "list everything", "recall memory"]):
            summary = self.summarizer.summarize()
            prof = self.personality.summary()
            response = f"{summary}\n\n{prof}"
            self.memory.save({"prompt": prompt, "response": response})
            self.telemetry.log("run_complete", "success", {"response": response})
            print(f"[RUN] {response}")
            return response

        if any(t in lower for t in ["personality", "profile", "how do i come across", "what's my vibe", "what is my vibe"]):
            response = self.personality.summary()
            self.memory.save({"prompt": prompt, "response": response})
            self.telemetry.log("run_complete", "success", {"response": response})
            print(f"[RUN] {response}")
            return response

        try:
            category = _categorize(prompt)

            # 1) emotion analysis + personality update
            emo = self.emotions.analyze(prompt)
            if emo["trait_deltas"]:
                note = f"tags={emo['tags']}, sentiment={emo['sentiment']:.2f}, arousal={emo['arousal']:.2f}"
                self.personality.apply_deltas(emo["trait_deltas"], note=note)

            # 2) fact intake → write to memories
            if _is_user_fact(prompt):
                # store in both graphs
                try:
                    self.context.link_context(self.agent_id, category, prompt, "stored")
                except TypeError:
                    self.context.link_context(self.agent_id, prompt, "stored")
                self.semantic.add(text=prompt, category=category)
                response = f"Noted — I’ll remember that under {category}."
            else:
                # 3) vector recall first
                hits = self.semantic.query(query_text=prompt, category=None if "all" in lower else category, top_k=5)
                if hits:
                    nice = self._humanize_hits(hits)[:3]
                    response = "From memory: " + "; ".join(nice) + "."
                else:
                    # 4) fallback to context graph
                    if hasattr(self.context, "query_context"):
                        cg = self.context.query_context(self.agent_id, keyword=None, category=category)
                        if cg and cg != ["No context found."]:
                            response = "From context: " + " ".join(cg[:3])
                        else:
                            response = f"Agent {self.agent_id} processed: {prompt}"
                    else:
                        response = f"Agent {self.agent_id} processed: {prompt}"

            # 5) persist + telemetry
            self.memory.save({"prompt": prompt, "response": response, "emotion": emo})
            try:
                self.context.link_context(self.agent_id, category, prompt, response)
            except TypeError:
                self.context.link_context(self.agent_id, prompt, response)

            self.telemetry.log("run_complete", "success", {"response": response})
            print(f"[RUN] {response}")
            return response

        except Exception as e:
            self.telemetry.log("run_failed", "error", {"error": str(e)})
            print(f"[ERROR] {e}")
            return f"Error: {e}"