"""Coder Agent - Main AI Brain for Myanmar Coding Assistant"""

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


class CoderAgent:
    """Expert Myanmar AI coding agent with advanced knowledge"""

    SYSTEM_PROMPTS = [
        "You are an expert programmer with advanced knowledge in: Python, JavaScript, TypeScript, Java, C++, Go, Rust, etc.",
        "You are a senior security reviewer. Analyze code for vulnerabilities and provide secure version with Myanmar explanation.",
        "You are a testing expert. Generate comprehensive unit tests for the given function using pytest.",
        "You are a GUI and game development expert. Provide complete, runnable code with Myanmar explanations.",
        "You are an expert Myanmar AI coding agent. Answer in Myanmar language and provide code examples when needed.",
    ]

    def __init__(
        self,
        model: str = "gpt-4",
        temperature: float = 0.7,
        max_tokens: int = 2048,
        knowledge_dir: Optional[str] = None,
    ):
        self.model = model
        self.temperature = temperature
        self.max_tokens = max_tokens
        self.knowledge_dir = Path(knowledge_dir) if knowledge_dir else None
        self.conversation_history: List[Dict[str, str]] = []
        self.session_id = self._generate_session_id()

    def _generate_session_id(self) -> str:
        """Generate unique session ID"""
        return f"session_{int(time.time())}_{id(self)}"

    def set_system_prompt(self, prompt: str) -> None:
        """Set custom system prompt"""
        self.system_prompt = prompt

    def generate_response(
        self, instruction: str, context: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """Generate code response for the given instruction"""
        self.conversation_history.append({"role": "user", "content": instruction})

        response = {
            "session_id": self.session_id,
            "instruction": instruction,
            "response": self._generate_code_response(instruction, context),
            "timestamp": time.time(),
            "model": self.model,
        }

        self.conversation_history.append(
            {"role": "assistant", "content": response["response"]}
        )

        return response

    def _generate_code_response(
        self, instruction: str, context: Optional[Dict[str, Any]]
    ) -> str:
        """Internal method to generate code response"""
        if self.knowledge_dir:
            knowledge_content = self._check_knowledge_base(instruction)
            if knowledge_content:
                return knowledge_content

        return self._get_fallback_response(instruction)

    def _check_knowledge_base(self, instruction: str) -> Optional[str]:
        """Check local knowledge base for relevant content"""
        if not self.knowledge_dir:
            return None

        keywords = self._extract_keywords(instruction)
        for keyword in keywords:
            kb_file = self.knowledge_dir / f"{keyword}_skills.md"
            if kb_file.exists():
                return self._parse_markdown_file(kb_file)

        return None

    def _extract_keywords(self, text: str) -> List[str]:
        """Extract keywords from instruction"""
        common_langs = ["python", "javascript", "typescript", "java", "go", "rust", "sql"]
        return [w for w in common_langs if w in text.lower()]

    def _parse_markdown_file(self, file_path: Path) -> str:
        """Parse markdown file and extract content"""
        content = file_path.read_text(encoding="utf-8")
        lines = content.split("\n")
        return "\n".join(lines[:20])

    def _get_fallback_response(self, instruction: str) -> str:
        """Get fallback response based on instruction"""
        instruction_lower = instruction.lower()

        if "python" in instruction_lower:
            return self._get_python_response(instruction)
        elif "javascript" in instruction_lower or "js" in instruction_lower:
            return self._get_javascript_response(instruction)
        elif "sql" in instruction_lower:
            return self._get_sql_response(instruction)
        else:
            return self._get_general_response(instruction)

    def _get_python_response(self, instruction: str) -> str:
        """Generate Python response"""
        return "# Python Code\n# TODO: Implement based on instruction"

    def _get_javascript_response(self, instruction: str) -> str:
        """Generate JavaScript response"""
        return "// JavaScript Code\n// TODO: Implement based on instruction"

    def _get_sql_response(self, instruction: str) -> str:
        """Generate SQL response"""
        return "-- SQL Query\n-- TODO: Implement based on instruction"

    def _get_general_response(self, instruction: str) -> str:
        """Generate general response"""
        return "# Code\n# TODO: Implement based on instruction"

    def get_trajectory(self) -> Dict[str, Any]:
        """Get conversation trajectory for training"""
        return {
            "session_id": self.session_id,
            "history": self.conversation_history,
            "timestamp": time.time(),
        }

    def save_trajectory(self, path: str) -> None:
        """Save conversation trajectory to file"""
        trajectory = self.get_trajectory()
        file_path = Path(path) / f"session_{int(time.time())}.jsonl"
        file_path.parent.mkdir(parents=True, exist_ok=True)

        with open(file_path, "w", encoding="utf-8") as f:
            f.write(json.dumps(trajectory, ensure_ascii=False) + "\n")

    def reset(self) -> None:
        """Reset agent state"""
        self.conversation_history = []
        self.session_id = self._generate_session_id()