#!/usr/bin/env python
# -*- coding: utf-8 -*-

from typing import Dict, Any, List, Optional
from datetime import datetime

from sqlalchemy import Column, Integer, String, DateTime, Index
from sqlalchemy.dialects.mysql import JSON

from cryptoai.models.base import Base, logger

# 定义分析结果模型
class AnalysisResult(Base):
    """分析结果表模型"""
    __tablename__ = 'analysis_results'

    id = Column(Integer, primary_key=True, autoincrement=True)
    agent = Column(String(50), nullable=False, comment='智能体类型(crypto, gold)')
    symbol = Column(String(50), nullable=False, comment='交易对符号')
    time_interval = Column(String(20), nullable=False, comment='时间间隔')
    completion_result = Column(JSON, nullable=False, comment='分析结果JSON')
    created_at = Column(DateTime, nullable=False, default=datetime.now, comment='创建时间')
    updated_at = Column(DateTime, nullable=False, default=datetime.now, onupdate=datetime.now, comment='更新时间')
    
    # 索引
    __table_args__ = (
        Index('idx_agent', 'agent'),
        Index('idx_symbol', 'symbol'),
        Index('idx_time_interval', 'time_interval'),
        Index('idx_created_at', 'created_at'),
    )

class AnalysisResultManager:
    """分析结果管理类"""
    
    def __init__(self, db_session):
        self.session = db_session
    
    def save_analysis_result(self, agent: str, symbol: str, time_interval: str, 
                           analysis_result: Dict[str, Any]) -> bool:
        """
        保存分析结果到数据库
        
        Args:
            agent: 智能体类型，例如 'crypto' 或 'gold'
            symbol: 交易对符号，例如 'BTCUSDT'
            time_interval: 时间间隔，例如 '1h', '4h', '1d'
            analysis_result: 分析结果数据
            
        Returns:
            保存是否成功
        """
        try:
            # 创建新记录
            new_result = AnalysisResult(
                agent=agent,
                symbol=symbol,
                time_interval=time_interval,
                completion_result=analysis_result,
                created_at=datetime.now(),
                updated_at=datetime.now()
            )
            
            # 添加并提交
            self.session.add(new_result)
            self.session.commit()
            
            logger.info(f"成功保存 {agent} 分析结果，交易对: {symbol}, 时间间隔: {time_interval}")
            return True
            
        except Exception as e:
            self.session.rollback()
            logger.error(f"保存分析结果失败: {e}")
            return False
    
    def get_latest_result(self, agent: str, symbol: str, time_interval: str) -> Optional[Dict[str, Any]]:
        """
        获取最新的分析结果
        
        Args:
            agent: 智能体类型，例如 'crypto' 或 'gold'
            symbol: 交易对符号，例如 'BTCUSDT'
            time_interval: 时间间隔，例如 '1h', '4h', '1d'
            
        Returns:
            最新分析结果，如果查询失败则返回None
        """
        try:
            # 查询最新的结果
            result = self.session.query(AnalysisResult).filter(
                AnalysisResult.agent == agent,
                AnalysisResult.symbol == symbol,
                AnalysisResult.time_interval == time_interval
            ).order_by(AnalysisResult.created_at.desc()).first()
            
            if result:
                # 转换为字典
                return {
                    'id': result.id,
                    'agent': result.agent,
                    'symbol': result.symbol,
                    'time_interval': result.time_interval,
                    'completion_result': result.completion_result,
                    'created_at': result.created_at
                }
            else:
                return None
                
        except Exception as e:
            logger.error(f"获取最新分析结果失败: {e}")
            return None