"""
Neural Sync - Auto Merge Service

自动合并服务 - 严格模式
- 审计评分 >= 98 分
- 全量测试通过
- 二次人工确认
- 熔断机制
"""

import asyncio
import logging
from typing import Optional, Dict, List, Any, Tuple
from pydantic import BaseModel, Field
from datetime import datetime, timedelta
from enum import Enum
from ..events import Event, EventType

logger = logging.getLogger(__name__)


class MergeStatus(str, Enum):
    """合并状态"""
    PENDING = "pending"
    WAITING_CONFIRMATION = "waiting_confirmation"
    APPROVED = "approved"
    REJECTED = "rejected"
    FAILED = "failed"
    COOLDOWN = "cooldown"


class MergeRequest(BaseModel):
    """合并请求"""
    signal_id: str
    commit_sha: str
    task_name: str
    audit_score: float = Field(ge=0.0, le=100.0)
    test_results: Dict[str, Any]
    requester: Optional[str] = None


class MergeResponse(BaseModel):
    """合并响应"""
    status: MergeStatus
    success: bool
    merge_sha: Optional[str] = None
    reason: Optional[str] = None
    requires_human_confirmation: bool = False
    confirmation_token: Optional[str] = None
    cooldown_remaining: Optional[float] = None
    details: Dict[str, Any] = Field(default_factory=dict)


class ConfirmationRequest(BaseModel):
    """人工确认请求"""
    token: str
    merge_request: MergeRequest
    created_at: float
    expires_at: float


class AutoMergeService:
    """
    自动合并服务 - 严格模式

    条件：
    1. 审计评分 >= 98 分
    2. 全量测试通过
    3. 二次人工确认
    4. 不在熔断期内

    特性：
    - 熔断机制（连续失败后暂停）
    - 人工确认流程
    - 回滚支持
    - 事件通知
    """

    # 严格模式阈值
    AUDIT_SCORE_THRESHOLD = 98.0
    HUMAN_CONFIRMATION_REQUIRED = True
    CONFIRMATION_TIMEOUT = 300  # 5 minutes

    # 熔断机制
    MAX_CONSECUTIVE_FAILURES = 3
    FAILURE_COOLDOWN_SECONDS = 3600  # 1 hour

    def __init__(self, git_service=None, plane_service=None, lark_service=None, event_bus=None):
        self.git = git_service
        self.plane = plane_service
        self.lark = lark_service
        self.event_bus = event_bus

        # 状态跟踪
        self._failure_count = 0
        self._last_failure_time: Optional[datetime] = None
        self._successful_merges = 0

        # 待确认的请求
        self._pending_confirmations: Dict[str, ConfirmationRequest] = {}

    async def try_auto_merge(self, request: MergeRequest) -> MergeResponse:
        """
        尝试自动合并
        """
        # 1. 检查熔断状态
        if self._is_in_cooldown():
            return MergeResponse(
                status=MergeStatus.COOLDOWN,
                success=False,
                reason=f"系统处于熔断期，请在 {self._get_cooldown_remaining()}s 后重试",
                requires_human_confirmation=True,
                cooldown_remaining=self._get_cooldown_remaining(),
            )

        # 2. 验证审计评分
        if request.audit_score < self.AUDIT_SCORE_THRESHOLD:
            return MergeResponse(
                status=MergeStatus.REJECTED,
                success=False,
                reason=f"审计评分 {request.audit_score} 低于阈值 {self.AUDIT_SCORE_THRESHOLD}",
                requires_human_confirmation=True,
            )

        # 3. 验证测试结果
        if not self._all_tests_passed(request.test_results):
            return MergeResponse(
                status=MergeStatus.REJECTED,
                success=False,
                reason="测试未全部通过",
                requires_human_confirmation=True,
                details={
                    "test_results": request.test_results,
                    "failed_tests": self._get_failed_tests(request.test_results),
                },
            )

        # 4. 创建人工确认请求
        if self.HUMAN_CONFIRMATION_REQUIRED:
            confirmation_token = self._generate_confirmation_token()
            expires_at = datetime.utcnow().timestamp() + self.CONFIRMATION_TIMEOUT

            confirmation = ConfirmationRequest(
                token=confirmation_token,
                merge_request=request,
                created_at=datetime.utcnow().timestamp(),
                expires_at=expires_at,
            )
            self._pending_confirmations[confirmation_token] = confirmation

            # 发送确认请求事件
            await self._notify_confirmation_request(confirmation)

            return MergeResponse(
                status=MergeStatus.WAITING_CONFIRMATION,
                success=False,
                reason="等待人工二次确认",
                requires_human_confirmation=True,
                confirmation_token=confirmation_token,
                details={
                    "expires_at": expires_at,
                    "timeout_seconds": self.CONFIRMATION_TIMEOUT,
                },
            )

        # 5. 直接执行自动合并（不需要确认）
        return await self._execute_merge(request)

    async def confirm_merge(self, confirmation_token: str, requester: str) -> MergeResponse:
        """
        人工确认合并
        """
        confirmation = self._pending_confirmations.get(confirmation_token)
        if not confirmation:
            return MergeResponse(
                status=MergeStatus.REJECTED,
                success=False,
                reason="确认令牌无效或已过期",
            )

        # 检查是否过期
        if datetime.utcnow().timestamp() > confirmation.expires_at:
            del self._pending_confirmations[confirmation_token]
            return MergeResponse(
                status=MergeStatus.REJECTED,
                success=False,
                reason="确认请求已过期",
            )

        # 执行合并
        result = await self._execute_merge(confirmation.merge_request)

        # 清理确认请求
        if result.success:
            del self._pending_confirmations[confirmation_token]

        return result

    async def reject_merge(self, confirmation_token: str, reason: str) -> MergeResponse:
        """
        拒绝合并
        """
        confirmation = self._pending_confirmations.get(confirmation_token)
        if not confirmation:
            return MergeResponse(
                status=MergeStatus.REJECTED,
                success=False,
                reason="确认令牌无效",
            )

        # 清理确认请求
        del self._pending_confirmations[confirmation_token]

        return MergeResponse(
            status=MergeStatus.REJECTED,
            success=False,
            reason=f"合并被拒绝: {reason}",
        )

    async def _execute_merge(self, request: MergeRequest) -> MergeResponse:
        """
        执行实际的合并操作
        """
        try:
            # 1. 执行 Git 合并
            merge_sha = await self._perform_git_merge(request.commit_sha)

            # 2. 推送到远程
            await self._push_to_remote()

            # 3. 更新 Plane 任务状态
            if self.plane:
                await self._update_plane_status(request.signal_id, merge_sha)

            # 4. 发送飞书通知
            if self.lark:
                await self._send_lark_notification(request, merge_sha)

            # 5. 发送成功事件
            await self._publish_merge_success_event(request, merge_sha)

            # 重置失败计数
            self._reset_failure_count()
            self._successful_merges += 1

            return MergeResponse(
                status=MergeStatus.APPROVED,
                success=True,
                merge_sha=merge_sha,
                reason="自动合并成功",
                details={
                    "successful_merges": self._successful_merges,
                },
            )

        except Exception as e:
            logger.error(f"Merge failed: {e}", exc_info=True)
            self._record_failure()

            await self._publish_merge_failed_event(request, str(e))

            return MergeResponse(
                status=MergeStatus.FAILED,
                success=False,
                reason=f"合并失败: {str(e)}",
                requires_human_confirmation=True,
            )

    async def _perform_git_merge(self, commit_sha: str) -> str:
        """执行 Git 合并"""
        # 如果有 git 服务，使用它；否则使用 subprocess
        if self.git:
            return await self.git.merge(commit_sha)

        # 使用 subprocess 执行 git 命令
        import subprocess

        # 合并提交（不创建合并提交，直接快进）
        result = subprocess.run(
            ["git", "merge", "--ff", commit_sha],
            capture_output=True,
            text=True,
            timeout=30,
        )

        if result.returncode != 0:
            # 尝试 cherry-pick
            result = subprocess.run(
                ["git", "cherry-pick", commit_sha],
                capture_output=True,
                text=True,
                timeout=30,
            )
            if result.returncode != 0:
                raise Exception(f"Git merge/cherry-pick failed: {result.stderr}")

        # 获取合并后的 HEAD
        result = subprocess.run(
            ["git", "rev-parse", "HEAD"],
            capture_output=True,
            text=True,
            check=True,
        )
        return result.stdout.strip()

    async def _push_to_remote(self):
        """推送到远程仓库"""
        import subprocess

        result = subprocess.run(
            ["git", "push"],
            capture_output=True,
            text=True,
            timeout=60,
        )

        if result.returncode != 0:
            raise Exception(f"Git push failed: {result.stderr}")

    async def _update_plane_status(self, signal_id: str, merge_sha: str):
        """更新 Plane 任务状态"""
        if not self.plane:
            return

        try:
            # 这里应该根据 signal_id 找到对应的 Plane issue
            # 简化实现：假设任务 ID 已知
            await self.plane.update_issue_status(
                signal_id,  # 或提取的任务 ID
                status="Done"
            )
        except Exception as e:
            logger.warning(f"Failed to update Plane status: {e}")

    async def _send_lark_notification(self, request: MergeRequest, merge_sha: str):
        """发送飞书通知"""
        if not self.lark:
            return

        try:
            await self.lark.send_merge_notification(
                task_name=request.task_name,
                merge_sha=merge_sha,
                audit_score=request.audit_score,
            )
        except Exception as e:
            logger.warning(f"Failed to send Lark notification: {e}")

    async def _notify_confirmation_request(self, confirmation: ConfirmationRequest):
        """通知确认请求"""
        if self.event_bus:
            from .events import EventType
            await self.event_bus.publish(
                Event(
                    type=EventType.AUTO_MERGE_REQUESTED,
                    data={
                        "token": confirmation.token,
                        "task_name": confirmation.merge_request.task_name,
                        "commit_sha": confirmation.merge_request.commit_sha,
                        "audit_score": confirmation.merge_request.audit_score,
                        "expires_at": confirmation.expires_at,
                    },
                )
            )

    async def _publish_merge_success_event(self, request: MergeRequest, merge_sha: str):
        """发布合并成功事件"""
        if self.event_bus:
            from .events import EventType
            await self.event_bus.publish(
                Event(
                    type=EventType.AUTO_MERGE_SUCCESS,
                    data={
                        "signal_id": request.signal_id,
                        "commit_sha": request.commit_sha,
                        "merge_sha": merge_sha,
                        "task_name": request.task_name,
                        "audit_score": request.audit_score,
                    },
                )
            )

    async def _publish_merge_failed_event(self, request: MergeRequest, error: str):
        """发布合并失败事件"""
        if self.event_bus:
            from .events import EventType
            await self.event_bus.publish(
                Event(
                    type=EventType.AUTO_MERGE_FAILED,
                    data={
                        "signal_id": request.signal_id,
                        "commit_sha": request.commit_sha,
                        "task_name": request.task_name,
                        "error": error,
                    },
                )
            )

    def _is_in_cooldown(self) -> bool:
        """检查是否在熔断期"""
        if self._last_failure_time is None:
            return False

        elapsed = (datetime.utcnow() - self._last_failure_time).total_seconds()
        return elapsed < self.FAILURE_COOLDOWN_SECONDS

    def _get_cooldown_remaining(self) -> float:
        """获取熔断剩余时间"""
        if self._last_failure_time is None:
            return 0.0

        elapsed = (datetime.utcnow() - self._last_failure_time).total_seconds()
        return max(0, self.FAILURE_COOLDOWN_SECONDS - elapsed)

    def _all_tests_passed(self, test_results: Dict[str, Any]) -> bool:
        """检查所有测试是否通过"""
        if not test_results:
            return True  # 没有测试结果视为通过

        # 检查是否有失败的测试
        for test_name, result in test_results.items():
            if isinstance(result, dict):
                if result.get("status") == "failed":
                    return False
                if result.get("passed") is False:
                    return False
            elif isinstance(result, bool):
                if not result:
                    return False

        return True

    def _get_failed_tests(self, test_results: Dict[str, Any]) -> List[str]:
        """获取失败的测试列表"""
        failed = []
        for test_name, result in test_results.items():
            if isinstance(result, dict) and result.get("status") == "failed":
                failed.append(test_name)
            elif isinstance(result, bool) and not result:
                failed.append(test_name)
        return failed

    def _generate_confirmation_token(self) -> str:
        """生成确认令牌"""
        import uuid
        return str(uuid.uuid4())

    def _record_failure(self):
        """记录失败"""
        self._failure_count += 1
        self._last_failure_time = datetime.utcnow()

        # 检查是否需要进入熔断期
        if self._failure_count >= self.MAX_CONSECUTIVE_FAILURES:
            logger.warning(
                f"[AutoMerge] {self._failure_count} consecutive failures. "
                f"Entering cooldown for {self.FAILURE_COOLDOWN_SECONDS}s"
            )
            if self.event_bus:
                import asyncio
                asyncio.create_task(
                    self.event_bus.publish(
                        Event(
                            type=EventType.AUTO_MERGE_COOLDOWN,
                            data={
                                "failure_count": self._failure_count,
                                "cooldown_seconds": self.FAILURE_COOLDOWN_SECONDS,
                            },
                        )
                    )
                )

    def _reset_failure_count(self):
        """重置失败计数"""
        self._failure_count = 0
        self._last_failure_time = None

    async def get_pending_confirmations(self) -> List[ConfirmationRequest]:
        """获取待确认的请求"""
        # 清理过期的确认请求
        now = datetime.utcnow().timestamp()
        expired = [
            token for token, conf in self._pending_confirmations.items()
            if now > conf.expires_at
        ]
        for token in expired:
            del self._pending_confirmations[token]

        return list(self._pending_confirmations.values())

    def get_status(self) -> Dict[str, Any]:
        """获取服务状态"""
        return {
            "audit_threshold": self.AUDIT_SCORE_THRESHOLD,
            "human_confirmation_required": self.HUMAN_CONFIRMATION_REQUIRED,
            "failure_count": self._failure_count,
            "successful_merges": self._successful_merges,
            "in_cooldown": self._is_in_cooldown(),
            "cooldown_remaining": self._get_cooldown_remaining() if self._is_in_cooldown() else 0,
            "pending_confirmations": len(self._pending_confirmations),
        }


# 全局服务实例
_auto_merger = None


def get_auto_merger(
    git_service=None,
    plane_service=None,
    lark_service=None,
    event_bus=None,
) -> AutoMergeService:
    """获取自动合并服务实例"""
    global _auto_merger
    if _auto_merger is None:
        _auto_merger = AutoMergeService(
            git_service=git_service,
            plane_service=plane_service,
            lark_service=lark_service,
            event_bus=event_bus,
        )
    return _auto_merger