import logging
from datetime import datetime

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.interval import IntervalTrigger

from app.core.config import settings
from app.db.session import SessionLocal
from app.services.scanner import BlockScanner

logger = logging.getLogger(__name__)


class BlockScanScheduler:
    """
    Scheduler for periodic blockchain scanning
    """
    
    def __init__(self):
        self.scheduler = BackgroundScheduler()
        self.scan_job = None
    
    def start(self):
        """
        Start the scheduler
        """
        if self.scan_job is None:
            # Add job for scanning blocks periodically
            self.scan_job = self.scheduler.add_job(
                self._scan_blocks,
                IntervalTrigger(seconds=settings.SCAN_INTERVAL_SECONDS),
                id="scan_blocks",
                name="Periodic Block Scan",
                replace_existing=True,
            )
            
            logger.info(f"Scheduled block scanning every {settings.SCAN_INTERVAL_SECONDS} seconds")
        
        # Start the scheduler
        self.scheduler.start()
        logger.info("Block scan scheduler started")
    
    def shutdown(self):
        """
        Shutdown the scheduler
        """
        if self.scheduler.running:
            self.scheduler.shutdown()
            logger.info("Block scan scheduler shut down")
    
    def _scan_blocks(self):
        """
        Scan blocks for arbitrage transactions
        """
        logger.info("Starting periodic block scan")
        
        db = SessionLocal()
        try:
            scanner = BlockScanner(db)
            
            # Skip if a scan is already in progress
            if scanner.scan_in_progress:
                logger.warning("Scan already in progress, skipping scheduled scan")
                return
            
            # Scan latest blocks
            events = scanner.scan_blocks(settings.SOLANA_BLOCKS_TO_SCAN)
            
            logger.info(
                f"Completed block scan at {datetime.utcnow().isoformat()}, "
                f"found {len(events)} arbitrage events"
            )
        
        except Exception as e:
            logger.error(f"Error during scheduled block scan: {str(e)}")
        
        finally:
            db.close()


# Singleton instance
scheduler = BlockScanScheduler()