"""
EvaluateRecord 模型

对应数据库表 evaluate_record 的 ORM 模型
"""

from enum import IntEnum
from typing import Optional
from sqlalchemy import Column, String, BigInteger, Integer, Text, DateTime
from sqlalchemy.sql import func

from src.models.database import Base
from src.utils.logger import get_logger

logger = get_logger(__name__)


class EvaluateStatus(IntEnum):
    """评估状态枚举
    
    对应数据库字段 status 的值：
    - PENDING: 0 - 待执行
    - EXECUTING: 1 - 执行中
    - SUCCESS: 2 - 执行成功
    - FAILED: 3 - 执行失败
    """
    PENDING = 0
    EXECUTING = 1
    SUCCESS = 2
    FAILED = 3
    
    @classmethod
    def get_description(cls, status: int) -> str:
        """获取状态描述
        
        Args:
            status: 状态值
            
        Returns:
            str: 状态描述
        """
        descriptions = {
            cls.PENDING: "待执行",
            cls.EXECUTING: "执行中",
            cls.SUCCESS: "执行成功",
            cls.FAILED: "执行失败",
        }
        return descriptions.get(status, "未知状态")


class EvaluateRecord(Base):
    """评估记录模型
    
    对应数据库表: evaluate_record
    
    字段说明:
    - evaluate_id: 评估ID (bigint, primary key)
    - task_id: 任务ID (bigint, nullable)
    - evaluate_result: 评估结果 (mediumtext, nullable) - JSON格式
    - status: 状态 (int, nullable) - 0:待执行 / 1:执行中 / 2:执行成功 / 3:执行失败
    - created_at: 创建时间 (datetime, nullable)
    - updated_at: 更新时间 (datetime, nullable)
    """
    
    __tablename__ = "evaluate_record"
    
    # 主键
    evaluate_id = Column(BigInteger, primary_key=True, nullable=False, comment="评估ID")
    
    # 任务ID
    task_id = Column(BigInteger, nullable=True, index=True, comment="任务ID")
    
    # 评估结果（JSON 格式）
    evaluate_result = Column(Text, nullable=True, comment="评估结果（JSON格式）")
    
    # 状态
    status = Column(Integer, nullable=True, default=int(EvaluateStatus.PENDING), index=True, comment="状态: 0:待执行 / 1:执行中 / 2:执行成功 / 3:执行失败")
    
    # 时间戳字段
    created_at = Column(DateTime, nullable=True, server_default=func.now(), comment="创建时间")
    updated_at = Column(DateTime, nullable=True, server_default=func.now(), onupdate=func.now(), comment="更新时间")
    
    def __repr__(self) -> str:
        """对象字符串表示"""
        return f"<EvaluateRecord(evaluate_id={self.evaluate_id}, task_id={self.task_id}, status={self.status})>"
    
    def to_dict(self) -> dict:
        """转换为字典
        
        Returns:
            dict: 模型数据字典
        """
        return {
            "evaluate_id": self.evaluate_id,
            "task_id": self.task_id,
            "evaluate_result": self.evaluate_result,
            "status": self.status,
            "created_at": self.created_at.isoformat() if self.created_at else None,
            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
        }
    
    @classmethod
    def create(
        cls,
        evaluate_id: int,
        task_id: Optional[int] = None,
        status: Optional[int] = None,
        evaluate_result: Optional[str] = None
    ) -> "EvaluateRecord":
        """创建新的评估记录
        
        Args:
            evaluate_id: 评估ID
            task_id: 任务ID
            status: 状态（默认: PENDING）
            evaluate_result: 评估结果
            
        Returns:
            EvaluateRecord: 新创建的模型实例
        """
        # 统一将枚举转换为整型值
        if status is None:
            status_value = int(EvaluateStatus.PENDING)
        else:
            try:
                # 支持传入 IntEnum 或具体的整数
                status_value = int(status)
            except Exception:
                status_value = int(EvaluateStatus.PENDING)

        return cls(
            evaluate_id=evaluate_id,
            task_id=task_id,
            status=status_value,
            created_at=func.now(),
            evaluate_result=evaluate_result
        )
    
    def update_status(self, status: EvaluateStatus):
        """更新状态
        
        Args:
            status: 新状态
        """
        self.status = status.value
    
    def update_result(self, result: str):
        """更新评估结果
        
        Args:
            result: 评估结果（JSON 字符串）
        """
        self.evaluate_result = result
        if self.status == EvaluateStatus.EXECUTING:
            self.update_status(EvaluateStatus.SUCCESS)

