smart_scraper.py

"""
Scraper Inteligente com Estratégia Otimizada
Executa diferentes modos dependendo do contexto
"""
import asyncio
import argparse
import os
from pathlib import Path
from datetime import datetime, timedelta
from scraper.scraper import BundleScraper
from scraper.filters import BundleFilter
from scraper.logger import Logger
from scraper.database import Database
from sqlalchemy import select, func


async def get_max_bundle_id(db: Database) -> int:
    """Busca o maior ID de bundle conhecido no banco"""
    async with db.async_session() as session:
        from scraper.database import Bundle
        result = await session.execute(
            select(func.max(Bundle.id))
        )
        max_id_str = result.scalar()
        if max_id_str:
            try:
                return int(max_id_str)
            except (ValueError, TypeError):
                return 0
        return 0


async def get_known_bundle_ids(db: Database) -> list:
    """Busca todos os IDs conhecidos do banco"""
    async with db.async_session() as session:
        from scraper.database import Bundle
        result = await session.execute(
            select(Bundle.id).order_by(Bundle.id)
        )
        return [row[0] for row in result.all()]


async def mark_as_deleted(db: Database, bundle_ids: list):
    """Marca bundles como deletados no banco"""
    async with db.async_session() as session:
        from scraper.database import Bundle
        async with session.begin():
            # Aqui você pode adicionar uma coluna 'deleted' ou remover do banco
            # Por enquanto, vamos apenas registrar no log
            pass


async def sync_to_supabase(logger: Logger, only_recent: bool = False):
    """Sincroniza dados com Supabase se configurado"""
    # Verifica se Supabase está configurado
    if not os.getenv('SUPABASE_URL') or not os.getenv('SUPABASE_SERVICE_KEY'):
        logger.info("⏭️  Supabase não configurado, pulando sincronização")
        return
    
    logger.info("🔄 Iniciando sincronização com Supabase...")
    
    try:
        # Import dinâmico para não falhar se não tiver supabase instalado
        from sync_supabase import SupabaseSync
        
        syncer = SupabaseSync()
        await syncer.sync_all(only_recent=only_recent, batch_size=500)
        logger.success("✅ Sincronização com Supabase concluída!")
    
    except ImportError:
        logger.warning("⚠️  Módulo sync_supabase não encontrado")
    except Exception as e:
        logger.error(f"❌ Erro ao sincronizar com Supabase: {e}")


async def run_incremental(logger: Logger):
    """
    Modo INCREMENTAL - Execução diária/frequente
    Busca apenas novos bundles após o último conhecido
    Se o banco estiver vazio, executa descoberta completa automaticamente
    """
    logger.start_operation("Scraping INCREMENTAL")
    
    db = Database()
    await db.init_db()
    
    # Busca o último ID conhecido
    max_id = await get_max_bundle_id(db)
    
    # Se banco vazio, faz descoberta completa automaticamente
    if max_id == 0:
        logger.warning("⚠️ Banco de dados vazio detectado!")
        logger.info("🚀 Executando descoberta COMPLETA automaticamente...")
        await db.close()
        await run_full_discovery(logger)
        return
    
    logger.info(f"Último bundle conhecido: ID {max_id}")
    
    async with BundleScraper() as scraper:
        # Descoberta incremental a partir do último ID + 1
        result = await scraper.discover_bundles_incremental(
            start_id=max_id + 1,
            batch_size=100,
            max_empty_batches=10
        )
        
        bundle_ids = result['bundle_ids']
        
        if not bundle_ids:
            logger.info("Nenhum bundle novo encontrado")
            await db.close()
            return
        
        logger.success(f"Encontrados {len(bundle_ids)} novos bundles!")
        
        # Busca dados completos
        bundles = await scraper.scrape_all_bundles(bundle_ids)
        
        # Aplica filtros
        filter_service = BundleFilter()
        bundles = filter_service.filter_valid(bundles)
        bundles = filter_service.filter_duplicates(bundles)
        
        # Salva no banco
        saved_count = await db.save_bundles_batch(bundles)
        logger.success(f"✓ {saved_count} novos bundles salvos no banco!")
        
        # Salva checkpoint do último ID verificado
        checkpoint_file = Path('data/last_max_id.txt')
        checkpoint_file.parent.mkdir(exist_ok=True)
        checkpoint_file.write_text(str(result['max_id_checked']))
    
    await db.close()
    logger.end_operation("Scraping INCREMENTAL", success=True)
    
    # Sincroniza com Supabase (apenas novos)
    await sync_to_supabase(logger, only_recent=True)


async def run_validation(logger: Logger):
    """
    Modo VALIDAÇÃO - Execução semanal
    Re-verifica bundles conhecidos para detectar exclusões e mudanças
    """
    logger.start_operation("Validação SEMANAL de bundles conhecidos")
    
    db = Database()
    await db.init_db()
    
    # Busca todos os IDs conhecidos
    known_ids = await get_known_bundle_ids(db)
    logger.info(f"Validando {len(known_ids)} bundles conhecidos")
    
    async with BundleScraper() as scraper:
        # Valida bundles conhecidos
        result = await scraper.validate_known_bundles(known_ids)
        
        # Atualiza bundles que ainda existem
        if result['updated_bundles']:
            filter_service = BundleFilter()
            bundles = filter_service.filter_valid(result['updated_bundles'])
            saved_count = await db.save_bundles_batch(bundles)
            logger.success(f"✓ {saved_count} bundles atualizados")
        
        # Marca deletados
        if result['deleted']:
            await mark_as_deleted(db, result['deleted'])
            logger.warning(f"⚠️ {len(result['deleted'])} bundles foram removidos da Steam")
    
    await db.close()
    logger.end_operation("Validação SEMANAL", success=True)


async def run_fill_gaps(logger: Logger):
    """
    Modo PREENCHIMENTO - Execução mensal
    Busca bundles em gaps entre IDs conhecidos
    """
    logger.start_operation("Preenchimento MENSAL de gaps")
    
    db = Database()
    await db.init_db()
    
    # Busca IDs conhecidos
    known_ids = await get_known_bundle_ids(db)
    logger.info(f"Analisando gaps entre {len(known_ids)} bundles conhecidos")
    
    async with BundleScraper() as scraper:
        # Preenche gaps
        new_ids = await scraper.fill_gaps(known_ids)
        
        if not new_ids:
            logger.info("Nenhum bundle encontrado nos gaps")
            await db.close()
            return
        
        logger.success(f"Encontrados {len(new_ids)} bundles nos gaps!")
        
        # Busca dados completos
        bundles = await scraper.scrape_all_bundles(new_ids)
        
        # Salva no banco
        filter_service = BundleFilter()
        bundles = filter_service.filter_valid(bundles)
        saved_count = await db.save_bundles_batch(bundles)
        logger.success(f"✓ {saved_count} bundles salvos")
    
    await db.close()
    logger.end_operation("Preenchimento MENSAL", success=True)


async def run_full_discovery(logger: Logger):
    """
    Modo COMPLETO - Primeira execução apenas
    Descoberta completa de todos os bundles
    """
    logger.start_operation("Descoberta COMPLETA (setup inicial)")
    
    db = Database()
    await db.init_db()
    
    async with BundleScraper() as scraper:
        # Descoberta completa
        bundle_ids = await scraper.discover_bundles_sequential(
            start_id=0,
            end_id=100000,
            batch_size=100,
            max_empty_batches=10
        )
        
        logger.success(f"Descobertos {len(bundle_ids)} bundles!")
        
        # Busca dados completos
        bundles = await scraper.scrape_all_bundles(bundle_ids)
        
        # Salva no banco
        filter_service = BundleFilter()
        bundles = filter_service.filter_valid(bundles)
        bundles = filter_service.filter_duplicates(bundles)
        saved_count = await db.save_bundles_batch(bundles)
        logger.success(f"✓ {saved_count} bundles salvos")
    
    await db.close()
    logger.end_operation("Descoberta COMPLETA", success=True)
    
    # Sincroniza tudo com Supabase
    await sync_to_supabase(logger, only_recent=False)


async def main():
    """Executa o modo apropriado baseado nos argumentos"""
    parser = argparse.ArgumentParser(description='Steam Bundle Scraper Inteligente')
    parser.add_argument('--mode', '-m', 
                       choices=['incremental', 'validation', 'gaps', 'full', 'auto'],
                       default='auto',
                       help='Modo de execução: auto (detecta automaticamente), incremental, validation, gaps, full')
    
    args = parser.parse_args()
    logger = Logger('smart_scraper')
    
    if args.mode == 'auto':
        # Modo automático: detecta se banco está vazio
        db = Database()
        await db.init_db()
        max_id = await get_max_bundle_id(db)
        await db.close()
        
        if max_id == 0:
            logger.info("🚀 Modo AUTO: Banco vazio detectado, executando descoberta COMPLETA")
            await run_full_discovery(logger)
        else:
            logger.info("⚡ Modo AUTO: Executando scraping INCREMENTAL")
            await run_incremental(logger)
    elif args.mode == 'incremental':
        await run_incremental(logger)
    elif args.mode == 'validation':
        await run_validation(logger)
    elif args.mode == 'gaps':
        await run_fill_gaps(logger)
    elif args.mode == 'full':
        await run_full_discovery(logger)


if __name__ == "__main__":
    asyncio.run(main())