#!/usr/bin/env python3
"""
dev-workflow 主编排器

负责协调整个9阶段开发流程。

Usage:
    python3 orchestrator.py --init "开始开发一个用户登录功能"
    python3 orchestrator.py --resume
    python3 orchestrator.py --status
"""

import argparse
import json
import subprocess
import sys
from datetime import datetime
from pathlib import Path
from typing import Any, Optional

# 添加 prompts 目录到路径
sys.path.insert(0, str(Path(__file__).parent))

from state_manager import (
    load_state,
    save_state,
    init_state,
    get_status,
    set_phase,
    complete_phase,
    update_phase_data,
    increment_retry,
    reset_retry
)


class DevWorkflowOrchestrator:
    """dev-workflow 主编排器"""
    
    def __init__(self, project_root: Path = None):
        self.project_root = project_root or Path.cwd()
        self.planning_dir = self.project_root / ".planning" / "dev-workflow"
        self.state = None
    
    def initialize(self, trigger_message: str, project_name: str = None):
        """初始化工作流"""
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► 初始化")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        # 创建目录结构
        self.planning_dir.mkdir(parents=True, exist_ok=True)
        (self.planning_dir / "solutions").mkdir(exist_ok=True)
        (self.planning_dir / "reviews").mkdir(exist_ok=True)
        (self.planning_dir / "development").mkdir(exist_ok=True)
        (self.planning_dir / "code-review").mkdir(exist_ok=True)
        
        # 初始化状态
        self.state = init_state(project_name, trigger_message)
        
        print(f"✅ 工作流已初始化")
        print(f"   触发消息: {trigger_message}")
        print(f"   工作目录: {self.planning_dir}")
        
        return self.state
    
    def load_state(self) -> dict:
        """加载当前状态"""
        self.state = load_state()
        return self.state
    
    def run_phase_1(self):
        """阶段1: 头脑风暴"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 1: 头脑风暴")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(1)
        
        print("\n开始需求收集问答...")
        print("提示: 您可以随时说'够了'结束问答\n")
        
        # 这里应该启动交互式问答
        # 由于这是编排器，实际问答由主Agent执行
        # 这里只记录状态
        
        questions = [
            "请描述您想要开发什么？",
            "这个项目解决什么问题？",
            "核心功能有哪些？",
            "技术栈偏好？",
            "有什么约束条件？"
        ]
        
        requirements = {
            "questions_asked": questions,
            "collected": False
        }
        
        update_phase_data(1, requirements)
        
        print("\n等待主Agent完成问答...")
        
        return {"phase": 1, "status": "waiting_for_input"}
    
    def run_phase_2(self, requirements_summary: str):
        """阶段2: 方案设计"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 2: 方案设计")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(2)
        
        print("\n◆ 启动3个方案设计子代理...")
        
        agents = [
            {"id": "A", "type": "general", "focus": "完整通用方案"},
            {"id": "B", "type": "practical", "focus": "实用快速方案"},
            {"id": "C", "type": "creative", "focus": "创新探索方案"}
        ]
        
        # 这里应该实际启动子代理
        # 由于编排器只负责协调，实际子代理由主Agent启动
        
        results = {
            "agents": agents,
            "output_files": [
                "solutions/solution-A.md",
                "solutions/solution-B.md",
                "solutions/solution-C.md"
            ],
            "status": "waiting_for_agents"
        }
        
        update_phase_data(2, results)
        
        print("  → Agent A: 通用型方案")
        print("  → Agent B: 实用型方案")
        print("  → Agent C: 创新型方案")
        
        return {"phase": 2, "status": "waiting_for_agents", "agents": agents}
    
    def run_phase_3(self):
        """阶段3: 方案审核"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 3: 方案审核")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(3)
        
        print("\n◆ 启动交叉审核...")
        print("  → Agent A 审核 B, C 的方案")
        print("  → Agent B 审核 A, C 的方案")
        print("  → Agent C 审核 A, B 的方案")
        
        results = {
            "review_files": [
                "reviews/review-A.md",
                "reviews/review-B.md",
                "reviews/review-C.md"
            ],
            "final_solution": "final-solution.md",
            "status": "waiting_for_agents"
        }
        
        update_phase_data(3, results)
        
        return {"phase": 3, "status": "waiting_for_agents"}
    
    def run_phase_4(self):
        """阶段4: 方案汇报"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 4: 方案汇报")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(4)
        
        print("\n等待用户决策...")
        print("  A. 批准方案 - 进入开发阶段")
        print("  B. 需要修改 - 调整方案")
        print("  C. 重新设计 - 重新方案")
        
        return {"phase": 4, "status": "waiting_for_user_decision"}
    
    def run_phase_5(self):
        """阶段5: Spec编排"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 5: Spec编排")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(5)
        
        print("\n◆ 生成开发规格...")
        print("◆ 分析任务依赖...")
        print("◆ 生成分波计划...")
        
        return {"phase": 5, "status": "processing"}
    
    def run_phase_6(self):
        """阶段6: 并行开发"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 6: 并行开发")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(6)
        
        print("\n◆ 按波次启动开发子代理...")
        
        return {"phase": 6, "status": "waiting_for_agents"}
    
    def run_phase_7(self):
        """阶段7: 测试"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 7: 测试")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(7)
        
        print("\n◆ 运行测试...")
        
        return {"phase": 7, "status": "running_tests"}
    
    def run_phase_8(self):
        """阶段8: 代码审查"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 8: 代码审查")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(8)
        
        print("\n◆ 启动3个代码审查子代理...")
        
        return {"phase": 8, "status": "waiting_for_agents"}
    
    def run_phase_9(self):
        """阶段9: 修复验证"""
        print("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        print(" DEV-WORKFLOW ► Phase 9: 修复验证")
        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
        
        set_phase(9)
        
        print("\n◆ 汇总问题...")
        print("◆ 安排修复...")
        print("◆ 验证完成...")
        
        return {"phase": 9, "status": "processing"}
    
    def get_status(self) -> str:
        """获取当前状态"""
        return get_status()
    
    def resume(self):
        """从当前状态恢复"""
        state = self.load_state()
        phase = state.get("current_phase", 1)
        
        print(f"\n恢复到阶段 {phase}: {state.get('current_stage', '未知')}")
        
        # 根据当前阶段调用对应方法
        method_name = f"run_phase_{phase}"
        if hasattr(self, method_name):
            return getattr(self, method_name)()
        else:
            print(f"❌ 未知阶段: {phase}")
            return None


def main():
    parser = argparse.ArgumentParser(description="dev-workflow 主编排器")
    
    parser.add_argument("--init", type=str, metavar="MESSAGE", 
                       help="初始化工作流，提供触发消息")
    parser.add_argument("--resume", action="store_true", 
                       help="从上次状态恢复")
    parser.add_argument("--status", action="store_true", 
                       help="显示当前状态")
    parser.add_argument("--project-name", type=str, 
                       help="项目名称")
    parser.add_argument("--phase", type=int, metavar="N",
                       help="执行指定阶段")
    
    args = parser.parse_args()
    
    orchestrator = DevWorkflowOrchestrator()
    
    if args.init:
        orchestrator.initialize(args.init, args.project_name)
        orchestrator.run_phase_1()
    elif args.resume:
        orchestrator.resume()
    elif args.status:
        print(orchestrator.get_status())
    elif args.phase:
        method_name = f"run_phase_{args.phase}"
        if hasattr(orchestrator, method_name):
            getattr(orchestrator, method_name)()
        else:
            print(f"❌ 无效的阶段: {args.phase}")
    else:
        parser.print_help()


if __name__ == "__main__":
    main()