from src.infrastructure.kafka.consumer.service import kafka_consumer
from src.infrastructure.observability.logger import logger
import os

"""
Event Handler Template
Auto-generated handler for topic: transcript.completed

This handler is scaffolded - implement your business logic in the handle method
"""

class TranscriptCompletedHandlerHandler:
    def __init__(self):
        self.topic = 'transcript.completed'
        self.group_id = 'test_project-transcript.completed-handler' or 'test_project-transcript.completed-handler'
        self.is_running = False
    
    async def start(self):
        """Initialize and start consuming events"""
        try:
            if self.is_running:
                logger.warning('Event Handler: Already running', extra={'topic': self.topic})
                return
            
            await kafka_consumer.subscribe(
                self.group_id,
                [self.topic],
                self.handle,
                {
                    'fromBeginning': False,  # Start from latest offset
                    'sessionTimeout': 30000,
                    'heartbeatInterval': 3000
                }
            )
            
            self.is_running = True
            logger.info('Event Handler: Started', extra={'topic': self.topic, 'groupId': self.group_id})
        except Exception as e:
            logger.error('Event Handler: Start failed', extra={
                'topic': self.topic,
                'error': str(e)
            })
            raise
    
    async def stop(self):
        """Stop consuming events"""
        try:
            if not self.is_running:
                return
            
            await kafka_consumer.disconnect(self.group_id)
            self.is_running = False
            logger.info('Event Handler: Stopped', extra={'topic': self.topic})
        except Exception as e:
            logger.error('Event Handler: Stop failed', extra={
                'topic': self.topic,
                'error': str(e)
            })
    
    async def handle(self, message: dict):
        """
        Handle incoming event
        TODO: Implement your business logic here
        
        Args:
            message: Kafka message dict with keys:
                - topic: Topic name
                - partition: Partition number
                - offset: Message offset
                - key: Message key
                - value: Parsed message value
                - headers: Message headers
                - timestamp: Message timestamp
        """
        topic = message['topic']
        key = message.get('key')
        value = message.get('value', {})
        headers = message.get('headers', {})
        timestamp = message.get('timestamp')
        
        logger.info('Event Handler: Processing event', extra={
            'topic': topic,
            'key': key,
            'eventId': value.get('id') or value.get('eventId'),
            'timestamp': timestamp
        })
        
        try:
            # TODO: Implement your business logic here
            # Examples:
            # - Update related entities
            # - Send notifications
            # - Trigger workflows
            # - Update cache
            # - Write to database
            
            # Example implementation:
            # event_id = value.get('id')
            # event_name = value.get('name')
            # await self.process_event(event_id, event_name)
            
            logger.info('Event Handler: Event processed successfully', extra={
                'topic': topic,
                'key': key,
                'eventId': value.get('id') or value.get('eventId')
            })
        except Exception as e:
            logger.error('Event Handler: Processing failed', extra={
                'topic': topic,
                'key': key,
                'error': str(e)
            })
            
            # Re-throw to trigger Kafka retry mechanism
            # For DLQ handling, implement custom retry logic here
            raise
    
    async def process_event(self, event_id: str, event_data: dict):
        """
        Process event
        TODO: Implement your business logic
        
        Args:
            event_id: Event ID
            event_data: Event data
        """
        # Example: Send notification
        # await self.notification_service.notify_admins({
        #     'type': 'EVENT_RECEIVED',
        #     'eventId': event_id,
        #     'data': event_data
        # })
        
        # Example: Update cache
        # from src.infrastructure.redis.cache.service import cache_service
        # await cache_service.set(f'event:{event_id}', event_data, 3600)
        
        # Example: Write to audit log
        # from src.services.audit_log_service import audit_log_service
        # await audit_log_service.log({
        #     'action': 'EVENT_PROCESSED',
        #     'entityId': event_id,
        #     'metadata': event_data
        # })
        pass

# Singleton instance
transcriptCompletedHandler_handler = TranscriptCompletedHandlerHandler()

# Auto-start if enabled
if os.getenv('KAFKA_AUTO_START_HANDLERS', 'true').lower() != 'false':
    import asyncio
    asyncio.create_task(transcriptCompletedHandler_handler.start())