"""
Genesis V2 Agent
================
Main conversational agent powered by Google ADK / Gemini.
"""

import os
import sys
import asyncio
import logging
from typing import Optional

logger = logging.getLogger("genesis_v2.agent")

# Ensure environment is set
root_dir = os.path.dirname(os.path.dirname(__file__))
lib_dir = os.path.join(root_dir, "lib")
if lib_dir not in sys.path:
    sys.path.insert(0, lib_dir)
if root_dir not in sys.path:
    sys.path.insert(0, root_dir)


class GenesisAgent:
    """Conversational agent wrapping Google ADK."""

    def __init__(self, model: str = "gemini-2.0-flash", system_instruction: str = ""):
        self._agent = None
        self._runner = None
        self._session_service = None
        self.model = model
        self.system_instruction = system_instruction
        self._tools = []
        self._init_error = None
        self._initialize()

    def _initialize(self):
        """Initialize the Google ADK agent."""
        try:
            from google.adk.agents import Agent
            from google.adk.sessions import InMemorySessionService
            from google.adk.runners import Runner

            self._session_service = InMemorySessionService()

            self._agent = Agent(
                name="genesis_v2",
                model=self.model,
                instruction=self.system_instruction or (
                    "You are Genesis, a powerful AI assistant. "
                    "Help the user with coding, system management, and research tasks."
                ),
                tools=self._tools,
            )

            self._runner = Runner(
                agent=self._agent,
                app_name="genesis-v2",
                session_service=self._session_service,
            )

            logger.info(f"Agent initialized: model={self.model}")
        except ImportError as e:
            self._init_error = f"Google ADK not available: {e}"
            logger.error(self._init_error)
            self._agent = None
            self._runner = None
        except Exception as e:
            self._init_error = f"Agent init error: {e}"
            logger.error(self._init_error)
            self._agent = None
            self._runner = None

    async def chat(self, message: str, user_id: str = "user") -> str:
        """Send a message and get a response."""
        if not self._runner:
            return f"Agent not initialized. Error: {self._init_error or 'Unknown error. Check logs.'}"

        session_id = f"session_{user_id}"

        # Get or create session
        session = await self._session_service.get_session(
            app_name="genesis-v2",
            user_id=user_id,
            session_id=session_id
        )
        if not session:
            session = await self._session_service.create_session(
                app_name="genesis-v2",
                user_id=user_id,
                session_id=session_id
            )

        # Run agent
        from google.genai.types import Content, Part
        user_content = Content(role="user", parts=[Part(text=message)])

        response_text = ""
        async for event in self._runner.run_async(
            user_id=user_id,
            session_id=session_id,
            new_message=user_content,
        ):
            if hasattr(event, 'content') and event.content:
                for part in event.content.parts:
                    if hasattr(part, 'text') and part.text:
                        response_text += part.text

        return response_text or "No response generated."

    def chat_sync(self, message: str, user_id: str = "user") -> str:
        """Synchronous wrapper for chat."""
        try:
            loop = asyncio.get_event_loop()
            if loop.is_running():
                import concurrent.futures
                with concurrent.futures.ThreadPoolExecutor() as pool:
                    future = pool.submit(asyncio.run, self.chat(message, user_id))
                    return future.result(timeout=120)
            else:
                return loop.run_until_complete(self.chat(message, user_id))
        except RuntimeError:
            return asyncio.run(self.chat(message, user_id))


def create_agent(model: str = "gemini-2.0-flash", system_instruction: str = "") -> GenesisAgent:
    """Factory function to create a Genesis agent."""
    from genesis_v2.core.config import get_api_key
    os.environ["GOOGLE_API_KEY"] = get_api_key()
    return GenesisAgent(model=model, system_instruction=system_instruction)