"""AI Knowledge Sync Event Handler"""
from typing import Dict, Any
from redis import Redis
from motia import FlowContext, queue


config = {
    "name": "AI Knowledge Sync",
    "description": "Synchronizes CAIKnowledge entities with XAI Collections",
    "flows": ["vmh-aiknowledge"],
    "triggers": [
        queue("aiknowledge.sync")
    ],
}


async def handler(event_data: Dict[str, Any], ctx: FlowContext[Any]) -> None:
    """
    Event handler for AI Knowledge synchronization.
    
    Emitted by:
    - Webhook on CAIKnowledge update
    - Daily full sync cron job
    
    Args:
        event_data: Event payload with knowledge_id
        ctx: Motia context
    """
    from services.redis_client import RedisClientFactory
    from services.aiknowledge_sync_utils import AIKnowledgeSync
    
    ctx.logger.info("=" * 80)
    ctx.logger.info("🔄 AI KNOWLEDGE SYNC STARTED")
    ctx.logger.info("=" * 80)
    
    # Extract data
    knowledge_id = event_data.get('knowledge_id')
    source = event_data.get('source', 'unknown')
    full_sync = event_data.get('full_sync', False)  # Blake3 verification mode
    
    if not knowledge_id:
        ctx.logger.error("❌ Missing knowledge_id in event data")
        return
    
    ctx.logger.info(f"📋 Knowledge ID: {knowledge_id}")
    ctx.logger.info(f"📋 Source: {source}")
    ctx.logger.info(f"📋 Full Sync Mode: {full_sync}")
    ctx.logger.info("=" * 80)
    
    # Get Redis for locking
    redis_client = RedisClientFactory.get_client(strict=False)
    
    # Initialize sync utils
    sync_utils = AIKnowledgeSync(ctx, redis_client)
    
    # Acquire lock
    lock_acquired = await sync_utils.acquire_sync_lock(knowledge_id)
    
    if not lock_acquired:
        ctx.logger.warning(f"⏸️  Lock already held for {knowledge_id}, skipping")
        ctx.logger.info("   (Will be retried by Motia queue)")
        raise RuntimeError(f"Lock busy for {knowledge_id}")  # Motia will retry
    
    try:
        # Perform sync
        await sync_utils.sync_knowledge_to_xai(knowledge_id, ctx, full_sync=full_sync)
        
        ctx.logger.info("=" * 80)
        ctx.logger.info("✅ AI KNOWLEDGE SYNC COMPLETED")
        ctx.logger.info("=" * 80)
        
        # Release lock with success=True
        await sync_utils.release_sync_lock(knowledge_id, success=True)
        
    except Exception as e:
        ctx.logger.error("=" * 80)
        ctx.logger.error("❌ AI KNOWLEDGE SYNC FAILED")
        ctx.logger.error("=" * 80)
        ctx.logger.error(f"Error: {e}", exc_info=True)
        ctx.logger.error(f"Knowledge ID: {knowledge_id}")
        ctx.logger.error("=" * 80)
        
        # Release lock with failure
        await sync_utils.release_sync_lock(
            knowledge_id,
            success=False,
            error_message=str(e)
        )
        
        # Re-raise to let Motia retry
        raise