import asyncio
from loguru import logger
from typing import List, Dict
import signal
import sys

from config.settings import SYNC_CONFIG
from .position_sync import PositionSync
from .order_sync import OrderSync
from .account_sync import AccountSync

class SyncManager:
    """同步管理器"""
    
    def __init__(self):
        self.is_running = True
        self.sync_interval = SYNC_CONFIG['interval']
        
        # 初始化同步器
        self.syncers = []
        
        if SYNC_CONFIG['enable_position_sync']:
            self.syncers.append(PositionSync())
            logger.info("启用持仓同步")
        
        if SYNC_CONFIG['enable_order_sync']:
            self.syncers.append(OrderSync())
            logger.info("启用订单同步")
        
        if SYNC_CONFIG['enable_account_sync']:
            self.syncers.append(AccountSync())
            logger.info("启用账户信息同步")
        
        # 注册信号处理器
        signal.signal(signal.SIGINT, self.signal_handler)
        signal.signal(signal.SIGTERM, self.signal_handler)
    
    def signal_handler(self, signum, frame):
        """信号处理器"""
        logger.info(f"接收到信号 {signum}，正在关闭...")
        self.is_running = False
    
    async def start(self):
        """启动同步服务"""
        logger.info(f"同步服务启动，间隔 {self.sync_interval} 秒")
        
        while self.is_running:
            try:
                # 执行所有同步器
                tasks = [syncer.sync() for syncer in self.syncers]
                await asyncio.gather(*tasks, return_exceptions=True)
                
                logger.debug(f"同步完成，等待 {self.sync_interval} 秒")
                await asyncio.sleep(self.sync_interval)
                
            except asyncio.CancelledError:
                logger.info("同步任务被取消")
                break
            except Exception as e:
                logger.error(f"同步任务异常: {e}")
                await asyncio.sleep(30)  # 出错后等待30秒
    
    async def stop(self):
        """停止同步服务"""
        self.is_running = False
        logger.info("同步服务停止")