"""
skills/task_plan_skill.py - 任务规划技能
========================================
将任务计划管理作为独立工具，替代原有的 XML <task_plan> 标签输出。
"""
from __future__ import annotations

from typing import Dict, Any, Optional
from core.logger import get_logger
from aiskills.base import Skill, SkillResult, SkillParameter

logger = get_logger("myagent.skills.task_plan")


class TaskPlanSkill(Skill):
    """任务计划管理工具 - 用于创建、更新和查询任务计划"""
    name = "task_plan"
    description = "管理任务计划，包括创建任务列表、更新任务完成状态、查询当前计划"
    category = "planning"
    parameters = [
        SkillParameter(
            "action",
            "string",
            "操作类型: create(创建计划) | update(更新进度) | get(获取当前计划) | clear(清空计划)",
            required=True,
            enum=["create", "update", "get", "clear"]
        ),
        SkillParameter(
            "plan",
            "string",
            "Markdown 格式的任务列表（create/update 时需要）",
            required=False,
            default=""
        ),
        SkillParameter(
            "task_index",
            "integer",
            "要更新的任务索引（从0开始，update 时使用）",
            required=False,
            default=-1
        ),
        SkillParameter(
            "completed",
            "boolean",
            "标记任务是否完成（update 时使用）",
            required=False,
            default=True
        ),
    ]

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # 存储当前任务计划（在 MainAgent 的上下文中共享）
        self._current_plan: str = ""
        self._plan_history: list = []

    async def execute(
        self,
        action: str = "get",
        plan: str = "",
        task_index: int = -1,
        completed: bool = True,
        **kwargs
    ) -> SkillResult:
        """
        执行任务计划操作

        Args:
            action: 操作类型
            plan: Markdown 格式的任务列表
            task_index: 要更新的任务索引
            completed: 是否标记为完成

        Returns:
            SkillResult 执行结果
        """
        try:
            if action == "create":
                return self._create_plan(plan)
            elif action == "update":
                return self._update_plan(task_index, completed)
            elif action == "get":
                return self._get_plan()
            elif action == "clear":
                return self._clear_plan()
            else:
                return SkillResult(
                    success=False,
                    error=f"未知操作: {action}。支持的操作: create, update, get, clear"
                )
        except Exception as e:
            logger.error(f"TaskPlanSkill 执行失败: {e}")
            return SkillResult(success=False, error=str(e))

    def _create_plan(self, plan: str) -> SkillResult:
        """创建新的任务计划"""
        if not plan or not plan.strip():
            return SkillResult(
                success=False,
                error="创建计划需要提供 plan 参数（Markdown 格式的任务列表）"
            )

        self._current_plan = plan.strip()
        self._plan_history.append({
            "action": "create",
            "plan": self._current_plan,
        })

        logger.info(f"TaskPlan: 创建新计划 ({len(self._current_plan.splitlines())} 个任务)")
        return SkillResult(
            success=True,
            data={"plan": self._current_plan, "task_count": len(self._current_plan.splitlines())},
            message=f"任务计划已创建，共 {len(self._current_plan.splitlines())} 个任务"
        )

    def _update_plan(self, task_index: int, completed: bool) -> SkillResult:
        """更新任务完成状态"""
        if not self._current_plan:
            return SkillResult(
                success=False,
                error="当前没有任务计划，请先使用 action='create' 创建计划"
            )

        if task_index < 0:
            return SkillResult(
                success=False,
                error="更新任务需要指定 task_index 参数（从0开始的索引）"
            )

        # 解析任务列表
        lines = self._current_plan.splitlines()
        if task_index >= len(lines):
            return SkillResult(
                success=False,
                error=f"任务索引 {task_index} 超出范围（共 {len(lines)} 个任务）"
            )

        # 更新任务状态
        line = lines[task_index]
        if completed:
            # 标记为完成: "- [ ]" → "- [x]"
            if "- [ ]" in line:
                lines[task_index] = line.replace("- [ ]", "- [x]", 1)
            elif "- [x]" not in line:
                lines[task_index] = f"- [x] {line.lstrip('- ').lstrip()}"
        else:
            # 标记为未完成: "- [x]" → "- [ ]"
            if "- [x]" in line:
                lines[task_index] = line.replace("- [x]", "- [ ]", 1)
            else:
                lines[task_index] = f"- [ ] {line.lstrip('- ').lstrip()}"

        self._current_plan = "\n".join(lines)
        self._plan_history.append({
            "action": "update",
            "index": task_index,
            "completed": completed,
        })

        logger.info(f"TaskPlan: 更新任务 {task_index} -> {'完成' if completed else '未完成'}")
        return SkillResult(
            success=True,
            data={"plan": self._current_plan, "updated_index": task_index, "completed": completed},
            message=f"任务 {task_index} 已标记为{'完成' if completed else '未完成'}"
        )

    def _get_plan(self) -> SkillResult:
        """获取当前任务计划"""
        if not self._current_plan:
            return SkillResult(
                success=True,
                data={"plan": "", "task_count": 0},
                message="当前没有任务计划"
            )

        task_count = len(self._current_plan.splitlines())
        completed_count = sum(1 for line in self._current_plan.splitlines() if "- [x]" in line)

        return SkillResult(
            success=True,
            data={
                "plan": self._current_plan,
                "task_count": task_count,
                "completed_count": completed_count,
                "progress": f"{completed_count}/{task_count}" if task_count > 0 else "0/0"
            },
            message=f"当前计划: {completed_count}/{task_count} 已完成"
        )

    def _clear_plan(self) -> SkillResult:
        """清空任务计划"""
        old_plan = self._current_plan
        self._current_plan = ""
        self._plan_history.append({"action": "clear"})

        logger.info("TaskPlan: 清空任务计划")
        return SkillResult(
            success=True,
            data={"cleared": True},
            message="任务计划已清空"
        )

    # ── 供 MainAgent 访问当前计划 ──
    def get_current_plan(self) -> str:
        """获取当前任务计划文本"""
        return self._current_plan

    def set_plan(self, plan: str):
        """设置任务计划（从 XML 解析器迁移）"""
        self._current_plan = plan.strip() if plan else ""