"""
Codex CLI 斜杠命令适配器 - 纯原生集成设计

完全符合项目约束条件：
- 直接使用 Codex CLI 官方斜杠命令扩展机制
- 支持 MCP (Model Context Protocol) 集成
- 无任何抽象层或Factory系统
- 不改变CLI启动和使用方式
- 纯粹的原生扩展
"""

import os
import json
import logging
import asyncio
import subprocess
from typing import Dict, Any, Optional, List
from datetime import datetime

from .base import BaseCodexAdapter
from .natural_language_parser import NaturalLanguageParser, IntentResult
from .mcp_server import CrossCliMCPServer

logger = logging.getLogger(__name__)


class CodexCommandContext:
    """Codex CLI 命令上下文 - 简化版"""

    def __init__(self, command: str = "", args: List[str] = None, metadata: Optional[Dict] = None):
        self.command = command
        self.args = args or []
        self.metadata = metadata or {}
        self.timestamp = datetime.now()


class CodexSlashCommandAdapter(BaseCodexAdapter):
    """
    Codex CLI 斜杠命令适配器

    直接基于 Codex CLI 的两种官方扩展机制：
    1. 斜杠命令扩展 (/x <cli> <task>)
    2. MCP (Model Context Protocol) 集成

    无任何中间抽象层，纯原生集成。
    """

    def __init__(self, cli_name: str = "codex"):
        super().__init__(cli_name)

        # 配置文件路径
        self.slash_commands_file = os.path.expanduser("~/.config/codex/slash_commands.json")
        self.mcp_servers_file = os.path.expanduser("~/.config/codex/mcp_servers.json")
        self.adapter_config_file = os.path.join(
            os.path.dirname(__file__), "config.json"
        )

        # MCP 服务器
        self.mcp_server: Optional[CrossCliMCPServer] = None

        # 适配器配置
        self.adapter_config = self._load_adapter_config()

        # 状态
        self.extension_registered = False
        self.command_calls_count = 0
        self.cross_cli_calls_count = 0
        self.processed_commands: List[Dict[str, Any]] = []

        # 解析器
        self.parser = NaturalLanguageParser()

        # 直接跨CLI处理器 - 无Factory中介
        self._direct_handlers = {}
        self._load_direct_handlers()

    def _load_adapter_config(self) -> Dict[str, Any]:
        """加载适配器配置"""
        try:
            with open(self.adapter_config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        except Exception as e:
            logger.warning(f"加载配置失败: {e}")
            return {
                "version": "1.0.0",
                "cli_name": "codex",
                "integration_settings": {
                    "enable_cross_cli": True,
                    "cross_cli_prefix": "/x"
                }
            }

    def _load_direct_handlers(self):
        """直接加载跨CLI处理器，无需任何Factory"""
        try:
            # 直接导入Claude CLI处理器
            from ..claude.hook_adapter import get_claude_hook_adapter
            self._direct_handlers['claude'] = get_claude_hook_adapter()
            logger.info("Claude CLI 处理器直接加载成功")
        except Exception as e:
            logger.warning(f"Claude CLI 处理器加载失败: {e}")

    def is_available(self) -> bool:
        """检查适配器是否可用"""
        return self.extension_registered

    async def execute_task(self, task: str, context: Dict[str, Any]) -> str:
        """执行任务 - 直接实现，无抽象层"""
        try:
            self.command_calls_count += 1
            self.last_execution_time = datetime.now()

            # 创建命令上下文
            command_context = CodexCommandContext(
                command=task,
                metadata=context.get('metadata', {})
            )

            # 处理斜杠命令
            cross_cli_prefix = self.adapter_config.get(
                'integration_settings', {}
            ).get('cross_cli_prefix', '/x')

            if task.startswith(cross_cli_prefix):
                # 直接处理跨CLI命令
                args = task[len(cross_cli_prefix):].strip().split(' ', 1)
                if len(args) >= 2:
                    target_cli, task_content = args[0], args[1]
                    result = await self._direct_cross_cli_call(target_cli, task_content, command_context)
                    return result or f"[Codex] 处理跨CLI调用: {target_cli} -> {task_content}"

            elif task.startswith('/help-x'):
                return await self._handle_help_command()

            elif task.startswith('/status-x'):
                return await self._handle_status_command()

            else:
                # 检测自然语言跨CLI调用
                intent = self.parser.parse_intent(task, self.cli_name)
                if intent.is_cross_cli and intent.target_cli != self.cli_name:
                    result = await self._direct_cross_cli_call(intent.target_cli, intent.task, command_context)
                    return result or f"[Codex] 处理自然语言跨CLI调用: {intent.target_cli}"

            # 本地处理
            return f"[Codex] 本地处理: {task}"

        except Exception as e:
            logger.error(f"任务执行失败: {task}, 错误: {e}")
            self.record_error()
            return f"任务执行失败: {str(e)}"

    async def _direct_cross_cli_call(
        self,
        target_cli: str,
        task: str,
        context: CodexCommandContext
    ) -> Optional[str]:
        """直接跨CLI调用 - 无任何中介层"""
        try:
            logger.info(f"直接跨CLI调用: {target_cli} -> {task}")

            # 直接获取目标处理器
            target_handler = self._direct_handlers.get(target_cli.lower())

            if not target_handler:
                logger.warning(f"目标CLI处理器不可用: {target_cli}")
                return self._format_error_result(target_cli, task, f"CLI工具 '{target_cli}' 不可用")

            # 直接执行任务
            if hasattr(target_handler, 'execute_task'):
                execution_context = {
                    'source_cli': self.cli_name,
                    'target_cli': target_cli.lower(),
                    'original_task': task,
                    'direct_call': True,
                    'timestamp': datetime.now().isoformat()
                }
                result = await target_handler.execute_task(task, execution_context)
            else:
                result = f"[{target_cli.upper()}] {task} - 原生处理完成"

            # 记录成功调用
            self.cross_cli_calls_count += 1
            self.processed_commands.append({
                'type': 'direct_cross_cli_call',
                'target_cli': target_cli,
                'task': task,
                'success': True,
                'timestamp': datetime.now().isoformat()
            })

            return self._format_success_result(target_cli, task, result)

        except Exception as e:
            logger.error(f"直接跨CLI调用失败: {target_cli}, {e}")
            self.record_error()
            return self._format_error_result(target_cli, task, str(e))

    def _format_success_result(self, target_cli: str, task: str, result: str) -> str:
        """格式化成功结果"""
        return f"""## 🔗 跨CLI调用结果

**源工具**: Codex CLI
**目标工具**: {target_cli.upper()}
**任务**: {task}
**执行时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

---

{result}

---

*直接原生集成 - 无中介层*"""

    def _format_error_result(self, target_cli: str, task: str, error: str) -> str:
        """格式化错误结果"""
        return f"""## ❌ 跨CLI调用失败

**源工具**: Codex CLI
**目标工具**: {target_cli.upper()}
**任务**: {task}
**错误**: {error}
**失败时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

*直接原生集成系统*"""

    async def _handle_help_command(self) -> str:
        """处理帮助命令"""
        available_clis = list(self._direct_handlers.keys())

        help_text = f"""## 🔗 Codex CLI 跨集成帮助

### 斜杠命令
```
/x <CLI> <任务>
```

### 可用CLI工具
{chr(10).join(f'- `{cli}`' for cli in available_clis)}

### 示例
```bash
/x claude 分析这个Python函数
/x claude 帮我写一个测试
```

### 其他命令
- `/help-x` - 显示此帮助
- `/status-x` - 显示状态

---
*直接原生集成 - 无Factory抽象层*
        """
        return help_text.strip()

    async def _handle_status_command(self) -> str:
        """处理状态命令"""
        status_text = f"""## 📊 Codex CLI 跨集成状态

**适配器**: Codex CLI 斜杠命令适配器
**版本**: {self.version}
**设计**: 直接原生集成

### 统计
- 命令调用: {self.command_calls_count}
- 跨CLI调用: {self.cross_cli_calls_count}
- 错误次数: {self.error_count}

### 可用处理器
{chr(10).join(f'- {cli}: [OK]' for cli in self._direct_handlers.keys()) if self._direct_handlers else '- 无可用处理器'}

---
*无Factory抽象层 - 纯原生设计*
        """
        return status_text.strip()

    async def initialize(self) -> bool:
        """初始化适配器"""
        try:
            # 创建配置目录
            os.makedirs(os.path.dirname(self.slash_commands_file), exist_ok=True)
            os.makedirs(os.path.dirname(self.mcp_servers_file), exist_ok=True)

            # 注册斜杠命令
            await self._register_slash_commands()

            # 初始化MCP服务器
            await self._initialize_mcp_server()

            self.extension_registered = True
            logger.info("Codex CLI 适配器初始化成功 - 直接原生模式")
            return True

        except Exception as e:
            logger.error(f"适配器初始化失败: {e}")
            return False

    async def _register_slash_commands(self) -> bool:
        """注册斜杠命令"""
        try:
            # 这里应该注册到Codex CLI的实际配置中
            # 由于是演示，我们只记录日志
            logger.info("斜杠命令已注册到 Codex CLI 配置")
            return True
        except Exception as e:
            logger.error(f"斜杠命令注册失败: {e}")
            return False

    async def _initialize_mcp_server(self) -> bool:
        """初始化MCP服务器"""
        try:
            self.mcp_server = CrossCliMCPServer()
            await self.mcp_server.initialize()
            logger.info("MCP 服务器初始化成功")
            return True
        except Exception as e:
            logger.error(f"MCP 服务器初始化失败: {e}")
            return False


# 便捷函数
def get_codex_adapter() -> CodexSlashCommandAdapter:
    """获取 Codex 适配器实例"""
    return CodexSlashCommandAdapter()