# app.py - Sistema de Webhooks Rappi Optimizado
from flask import Flask, request, jsonify, render_template
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
import json
import os
import hashlib
import hmac
import logging

# Configurar logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = Flask(__name__)

# CONFIGURACIÓN
app.config['SQLALCHEMY_DATABASE_URI'] = (
    "mssql+pyodbc://sa:Sistemas123*%2F@194.163.45.32:1433/RappiWebhooks"
    "?driver=ODBC+Driver+17+for+SQL+Server&TrustServerCertificate=yes&Encrypt=yes&timeout=30"
)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SECRET_KEY'] = 'webhooks_secret_2025'

# URL base del webhook
WEBHOOK_BASE_URL = "https://cierresmig.online"

# Secret para validar webhooks (configurar según necesites)
RAPPI_WEBHOOK_SECRET = os.environ.get('RAPPI_WEBHOOK_SECRET')

db = SQLAlchemy(app)

# =================== MODELOS DE BASE DE DATOS ===================

class WebhookEvent(db.Model):
    __tablename__ = 'WebhookEvents'
    
    id = db.Column(db.Integer, primary_key=True)
    evento_tipo = db.Column(db.String(50), nullable=False)
    order_id = db.Column(db.String(100))
    store_id = db.Column(db.String(100))
    event_name = db.Column(db.String(100))  # Para el campo "event" específico
    datos_json = db.Column(db.Text, nullable=False)
    fecha_recepcion = db.Column(db.DateTime, default=datetime.utcnow)
    ip_origen = db.Column(db.String(45))
    firma_valida = db.Column(db.Boolean, default=False)
    procesado = db.Column(db.Boolean, default=False)
    error_procesamiento = db.Column(db.Text)

class RappiEventDetail(db.Model):
    __tablename__ = 'RappiEventDetails'
    
    id = db.Column(db.Integer, primary_key=True)
    webhook_event_id = db.Column(db.Integer, db.ForeignKey('WebhookEvents.id'))
    event_type = db.Column(db.String(50), nullable=False)
    order_id = db.Column(db.String(100))
    store_id = db.Column(db.String(100))
    event_name = db.Column(db.String(100))
    event_time = db.Column(db.String(100))
    message = db.Column(db.String(500))
    courier_data = db.Column(db.Text)  # JSON para información del courier
    additional_info = db.Column(db.Text)  # JSON para información adicional
    fecha_procesamiento = db.Column(db.DateTime, default=datetime.utcnow)

class SystemLog(db.Model):
    __tablename__ = 'SystemLogs'
    
    id = db.Column(db.Integer, primary_key=True)
    level = db.Column(db.String(20), default='INFO')
    message = db.Column(db.Text)
    endpoint = db.Column(db.String(100))
    ip_address = db.Column(db.String(45))
    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
    additional_data = db.Column(db.Text)

# =================== FUNCIONES DE UTILIDAD ===================

def log_system_event(level, message, endpoint=None, additional_data=None):
    """Registrar eventos del sistema"""
    try:
        log_entry = SystemLog(
            level=level,
            message=message,
            endpoint=endpoint,
            ip_address=request.remote_addr if request else None,
            additional_data=json.dumps(additional_data) if additional_data else None
        )
        db.session.add(log_entry)
        db.session.commit()
        
        logger.info(f"[{level}] {message}")
    except Exception as e:
        logger.error(f"Error logging system event: {e}")

def validate_rappi_signature(payload_body, signature_header):
    """Validar la firma de Rappi usando HMAC SHA256"""
    if not RAPPI_WEBHOOK_SECRET or not signature_header:
        return False
    
    try:
        parts = signature_header.split(',')
        timestamp = None
        signature = None
        
        for part in parts:
            key, value = part.split('=', 1)
            if key == 't':
                timestamp = value
            elif key == 'sign':
                signature = value
        
        if not timestamp or not signature:
            return False
        
        signed_payload = f"{timestamp}.{payload_body}"
        
        expected_signature = hmac.new(
            RAPPI_WEBHOOK_SECRET.encode('utf-8'),
            signed_payload.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        
        return hmac.compare_digest(signature, expected_signature)
        
    except Exception as e:
        logger.error(f"Error validating signature: {e}")
        return False

def identify_event_type(webhook_data):
    """Identificar el tipo de evento basándose en la estructura del payload"""
    try:
        logger.info(f"Identificando evento con payload: {webhook_data}")
        
        # PING - solo tiene store_id
        if 'store_id' in webhook_data and len(webhook_data) == 1:
            logger.info("Evento identificado como PING")
            return 'PING'
        
        # MENU_APPROVED - tiene store_id y message con "approved"
        if 'store_id' in webhook_data and 'message' in webhook_data:
            message = webhook_data.get('message', '').lower()
            if 'approved' in message:
                logger.info("Evento identificado como MENU_APPROVED")
                return 'MENU_APPROVED'
            else:
                logger.info("Evento identificado como MENU_REJECTED (con mensaje)")
                return 'MENU_REJECTED'
        
        # MENU_REJECTED - solo tiene store_id (sin message) - CORREGIDO
        if 'store_id' in webhook_data and 'message' not in webhook_data and len(webhook_data) == 1:
            logger.info("Evento identificado como MENU_REJECTED (sin mensaje)")
            return 'MENU_REJECTED'
        
        # ORDER_EVENT_CANCEL - tiene order_id, store_id y event con cancelación
        if 'order_id' in webhook_data and 'store_id' in webhook_data and 'event' in webhook_data:
            event_name = webhook_data.get('event', '').lower()
            if 'cancel' in event_name:
                logger.info("Evento identificado como ORDER_EVENT_CANCEL")
                return 'ORDER_EVENT_CANCEL'
            else:
                logger.info("Evento identificado como ORDER_OTHER_EVENT (por event)")
                return 'ORDER_OTHER_EVENT'
        
        # ORDER_OTHER_EVENT - tiene order_id, store_id, event_time y additional_information
        if ('order_id' in webhook_data and 'store_id' in webhook_data and 
            'event_time' in webhook_data and 'additional_information' in webhook_data):
            logger.info("Evento identificado como ORDER_OTHER_EVENT (completo)")
            return 'ORDER_OTHER_EVENT'
        
        # STORE_CONNECTIVITY - tiene external_store_id y enabled
        if 'external_store_id' in webhook_data and 'enabled' in webhook_data:
            logger.info("Evento identificado como STORE_CONNECTIVITY")
            return 'STORE_CONNECTIVITY'
        
        # ORDER_RT_TRACKING - tiene lat, lng, order_id
        if ('lat' in webhook_data and 'lng' in webhook_data and 
            'order_id' in webhook_data and 'eta_in_millis' in webhook_data):
            logger.info("Evento identificado como ORDER_RT_TRACKING")
            return 'ORDER_RT_TRACKING'
        
        # Si llegamos aquí, no pudimos identificar el evento
        logger.warning(f"No se pudo identificar el tipo de evento. Keys: {list(webhook_data.keys())}")
        return 'UNKNOWN'
        
    except Exception as e:
        logger.error(f"Error identificando tipo de evento: {e}")
        return 'UNKNOWN'

def process_order_event_cancel(webhook_data):
    """Procesar evento ORDER_EVENT_CANCEL"""
    try:
        order_id = webhook_data.get('order_id')
        store_id = webhook_data.get('store_id')
        event_name = webhook_data.get('event')
        
        if not order_id:
            raise ValueError("No se pudo obtener order_id")
        
        event_detail = RappiEventDetail(
            event_type='ORDER_EVENT_CANCEL',
            order_id=order_id,
            store_id=store_id,
            event_name=event_name
        )
        
        db.session.add(event_detail)
        
        log_system_event('INFO', f"Cancelación procesada: {order_id}", 
                        additional_data={'event': event_name, 'store_id': store_id})
        
        return True
        
    except Exception as e:
        logger.error(f"Error processing ORDER_EVENT_CANCEL: {e}")
        raise

def process_order_other_event(webhook_data):
    """Procesar evento ORDER_OTHER_EVENT"""
    try:
        order_id = webhook_data.get('order_id')
        store_id = webhook_data.get('store_id')
        event_name = webhook_data.get('event')
        event_time = webhook_data.get('event_time')
        additional_information = webhook_data.get('additional_information', {})
        
        courier_data = additional_information.get('courier_data')
        
        event_detail = RappiEventDetail(
            event_type='ORDER_OTHER_EVENT',
            order_id=order_id,
            store_id=store_id,
            event_name=event_name,
            event_time=event_time,
            courier_data=json.dumps(courier_data) if courier_data else None,
            additional_info=json.dumps(additional_information)
        )
        
        db.session.add(event_detail)
        
        log_system_event('INFO', f"Evento de orden procesado: {event_name} - {order_id}")
        
        return True
        
    except Exception as e:
        logger.error(f"Error processing ORDER_OTHER_EVENT: {e}")
        raise

def process_menu_approved(webhook_data):
    """Procesar evento MENU_APPROVED"""
    try:
        store_id = webhook_data.get('store_id')
        message = webhook_data.get('message')
        
        event_detail = RappiEventDetail(
            event_type='MENU_APPROVED',
            store_id=store_id,
            message=message
        )
        
        db.session.add(event_detail)
        
        log_system_event('INFO', f"Menú aprobado para tienda: {store_id}")
        
        return True
        
    except Exception as e:
        logger.error(f"Error processing MENU_APPROVED: {e}")
        raise

def process_menu_rejected(webhook_data):
    """Procesar evento MENU_REJECTED"""
    try:
        store_id = webhook_data.get('store_id')
        
        event_detail = RappiEventDetail(
            event_type='MENU_REJECTED',
            store_id=store_id
        )
        
        db.session.add(event_detail)
        
        log_system_event('INFO', f"Menú rechazado para tienda: {store_id}")
        
        return True
        
    except Exception as e:
        logger.error(f"Error processing MENU_REJECTED: {e}")
        raise

def process_ping(webhook_data):
    """Procesar evento PING"""
    try:
        store_id = webhook_data.get('store_id')
        
        event_detail = RappiEventDetail(
            event_type='PING',
            store_id=store_id
        )
        
        db.session.add(event_detail)
        
        log_system_event('INFO', f"Ping recibido para tienda: {store_id}")
        
        return True
        
    except Exception as e:
        logger.error(f"Error processing PING: {e}")
        raise

def process_store_connectivity(webhook_data):
    """Procesar evento STORE_CONNECTIVITY"""
    try:
        store_id = webhook_data.get('external_store_id')
        enabled = webhook_data.get('enabled')
        message = webhook_data.get('message')
        
        event_detail = RappiEventDetail(
            event_type='STORE_CONNECTIVITY',
            store_id=store_id,
            message=message,
            additional_info=json.dumps({'enabled': enabled})
        )
        
        db.session.add(event_detail)
        
        status = "habilitada" if enabled else "deshabilitada"
        log_system_event('INFO', f"Tienda {store_id} {status}")
        
        return True
        
    except Exception as e:
        logger.error(f"Error processing STORE_CONNECTIVITY: {e}")
        raise

def process_order_rt_tracking(webhook_data):
    """Procesar evento ORDER_RT_TRACKING"""
    try:
        order_id = webhook_data.get('order_id')
        store_id = webhook_data.get('store_id')
        courier_id = webhook_data.get('courier_id')
        
        tracking_info = {
            'lat': webhook_data.get('lat'),
            'lng': webhook_data.get('lng'),
            'eta_in_millis': webhook_data.get('eta_in_millis'),
            'eta_type': webhook_data.get('eta_type'),
            'created_at': webhook_data.get('created_at')
        }
        
        event_detail = RappiEventDetail(
            event_type='ORDER_RT_TRACKING',
            order_id=str(order_id),
            store_id=str(store_id),
            additional_info=json.dumps(tracking_info),
            courier_data=json.dumps({'courier_id': courier_id})
        )
        
        db.session.add(event_detail)
        
        log_system_event('INFO', f"Tracking actualizado para orden: {order_id}")
        
        return True
        
    except Exception as e:
        logger.error(f"Error processing ORDER_RT_TRACKING: {e}")
        raise

# =================== RUTAS DE WEBHOOKS ===================

@app.route('/webhook/rappi', methods=['POST'])
def webhook_rappi():
    """Endpoint principal para recibir webhooks de Rappi"""
    try:
        # Obtener datos del request
        payload_body = request.get_data(as_text=True)
        signature_header = request.headers.get('Rappi-Signature')
        
        # Rappi NO envía el tipo de evento en el header, lo identificamos del payload
        event_type_from_header = request.headers.get('X-Rappi-Event-Type', 'unknown')
        
        # Log del webhook recibido
        log_system_event('INFO', f"Webhook recibido desde Rappi", 
                        endpoint='/webhook/rappi',
                        additional_data={'has_signature': bool(signature_header)})
        
        # Validar firma si tenemos secret configurado
        signature_valid = True
        if RAPPI_WEBHOOK_SECRET:
            signature_valid = validate_rappi_signature(payload_body, signature_header)
            if not signature_valid:
                log_system_event('ERROR', 'Firma de webhook inválida', endpoint='/webhook/rappi')
                return jsonify({'error': 'Invalid signature'}), 401
        
        # Parsear JSON
        try:
            webhook_data = request.get_json()
            if not webhook_data:
                raise ValueError("Empty JSON body")
        except Exception as e:
            log_system_event('ERROR', f'JSON inválido en webhook: {e}', endpoint='/webhook/rappi')
            return jsonify({'error': 'Invalid JSON'}), 400
        
        # IDENTIFICAR EL TIPO DE EVENTO AUTOMÁTICAMENTE
        event_type = identify_event_type(webhook_data)
        
        # Log del tipo de evento identificado
        log_system_event('INFO', f"Evento identificado como: {event_type}", 
                        additional_data={'payload_keys': list(webhook_data.keys())})
        
        # Extraer IDs importantes según el tipo identificado
        order_id = None
        store_id = None
        event_name = None
        
        if event_type in ['ORDER_EVENT_CANCEL', 'ORDER_OTHER_EVENT']:
            order_id = webhook_data.get('order_id')
            store_id = webhook_data.get('store_id')
            event_name = webhook_data.get('event')
        elif event_type in ['MENU_APPROVED', 'MENU_REJECTED', 'PING']:
            store_id = webhook_data.get('store_id')
        elif event_type == 'STORE_CONNECTIVITY':
            store_id = webhook_data.get('external_store_id')
        elif event_type == 'ORDER_RT_TRACKING':
            order_id = str(webhook_data.get('order_id', ''))
            store_id = str(webhook_data.get('store_id', ''))
        
        # Guardar evento en la base de datos
        webhook_event = WebhookEvent(
            evento_tipo=event_type,
            order_id=order_id,
            store_id=store_id,
            event_name=event_name,
            datos_json=payload_body,
            ip_origen=request.remote_addr,
            firma_valida=signature_valid
        )
        
        # Procesar según tipo de evento identificado
        try:
            if event_type == 'ORDER_EVENT_CANCEL':
                process_order_event_cancel(webhook_data)
                webhook_event.procesado = True
                
            elif event_type == 'ORDER_OTHER_EVENT':
                process_order_other_event(webhook_data)
                webhook_event.procesado = True
                
            elif event_type == 'MENU_APPROVED':
                process_menu_approved(webhook_data)
                webhook_event.procesado = True
                
            elif event_type == 'MENU_REJECTED':
                process_menu_rejected(webhook_data)
                webhook_event.procesado = True
                
            elif event_type == 'PING':
                process_ping(webhook_data)
                webhook_event.procesado = True
                
            elif event_type == 'STORE_CONNECTIVITY':
                process_store_connectivity(webhook_data)
                webhook_event.procesado = True
                
            elif event_type == 'ORDER_RT_TRACKING':
                process_order_rt_tracking(webhook_data)
                webhook_event.procesado = True
                
            else:
                webhook_event.procesado = False
                webhook_event.error_procesamiento = f'Tipo de evento no reconocido: {event_type}'
                log_system_event('WARNING', f'Tipo de evento no reconocido: {event_type}',
                               additional_data={'payload': webhook_data})
                
        except Exception as process_error:
            webhook_event.procesado = False
            webhook_event.error_procesamiento = str(process_error)
            log_system_event('ERROR', f'Error procesando webhook {event_type}: {process_error}')
        
        db.session.add(webhook_event)
        db.session.commit()
        
        # Respuestas específicas por tipo de evento
        if event_type == 'PING':
            return jsonify({
                'status': 'OK',
                'description': 'Sistema funcionando correctamente'
            })
        
        return jsonify({
            'success': True,
            'message': 'Webhook procesado correctamente',
            'event_id': webhook_event.id,
            'event_type': event_type,
            'identified_from_payload': True
        }), 200
        
    except Exception as e:
        logger.error(f"Error general en webhook: {e}")
        log_system_event('ERROR', f'Error general en webhook: {e}', endpoint='/webhook/rappi')
        
        return jsonify({
            'error': 'Error interno del servidor',
            'message': str(e)
        }), 500

# =================== RUTAS DE API ===================

@app.route('/')
def home():
    """Página principal"""
    return render_template('index.html', webhook_url=f"{WEBHOOK_BASE_URL}/webhook/rappi")

@app.route('/api/eventos')
def get_eventos():
    """Obtener eventos de webhooks"""
    try:
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 50, type=int)
        
        eventos = WebhookEvent.query.order_by(
            WebhookEvent.fecha_recepcion.desc()
        ).paginate(page=page, per_page=per_page, error_out=False)
        
        result = []
        for evento in eventos.items:
            result.append({
                'id': evento.id,
                'tipo': evento.evento_tipo,
                'order_id': evento.order_id,
                'store_id': evento.store_id,
                'event_name': evento.event_name,
                'fecha': evento.fecha_recepcion.strftime('%Y-%m-%d %H:%M:%S'),
                'ip': evento.ip_origen,
                'firma_valida': evento.firma_valida,
                'procesado': evento.procesado,
                'error': evento.error_procesamiento
            })
        
        return jsonify({
            'eventos': result,
            'total': eventos.total,
            'pages': eventos.pages,
            'current_page': page
        })
        
    except Exception as e:
        logger.error(f"Error obteniendo eventos: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/event-details')
def get_event_details():
    """Obtener detalles de eventos procesados"""
    try:
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 50, type=int)
        event_type = request.args.get('event_type')
        
        query = RappiEventDetail.query
        if event_type:
            query = query.filter(RappiEventDetail.event_type == event_type)
            
        details = query.order_by(
            RappiEventDetail.fecha_procesamiento.desc()
        ).paginate(page=page, per_page=per_page, error_out=False)
        
        result = []
        for detail in details.items:
            result.append({
                'id': detail.id,
                'event_type': detail.event_type,
                'order_id': detail.order_id,
                'store_id': detail.store_id,
                'event_name': detail.event_name,
                'event_time': detail.event_time,
                'message': detail.message,
                'fecha_procesamiento': detail.fecha_procesamiento.strftime('%Y-%m-%d %H:%M:%S')
            })
        
        return jsonify({
            'details': result,
            'total': details.total,
            'pages': details.pages,
            'current_page': page
        })
        
    except Exception as e:
        logger.error(f"Error obteniendo detalles: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/estadisticas')
def get_estadisticas():
    """Obtener estadísticas del sistema"""
    try:
        total_eventos = WebhookEvent.query.count()
        total_detalles = RappiEventDetail.query.count()
        
        # Contar por tipo de evento
        eventos_por_tipo = {}
        for event_type in ['ORDER_EVENT_CANCEL', 'ORDER_OTHER_EVENT', 'MENU_APPROVED', 
                          'MENU_REJECTED', 'PING', 'STORE_CONNECTIVITY', 'ORDER_RT_TRACKING']:
            count = WebhookEvent.query.filter_by(evento_tipo=event_type).count()
            eventos_por_tipo[event_type] = count
        
        ultimo_evento = WebhookEvent.query.order_by(
            WebhookEvent.fecha_recepcion.desc()
        ).first()
        
        return jsonify({
            'total_eventos': total_eventos,
            'total_detalles_procesados': total_detalles,
            'eventos_por_tipo': eventos_por_tipo,
            'ultimo_evento': {
                'tipo': ultimo_evento.evento_tipo,
                'fecha': ultimo_evento.fecha_recepcion.isoformat()
            } if ultimo_evento else None,
            'sistema_activo': True,
            'webhook_url': f"{WEBHOOK_BASE_URL}/webhook/rappi"
        })
        
    except Exception as e:
        logger.error(f"Error obteniendo estadísticas: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/health')
def health_check():
    """Health check para monitoreo"""
    try:
        # Test simple de la base de datos
        test_query = db.session.execute(db.text('SELECT 1 as test'))
        result = test_query.fetchone()
        
        if result and result[0] == 1:
            return jsonify({
                'status': 'healthy',
                'timestamp': datetime.utcnow().isoformat(),
                'webhook_url': f"{WEBHOOK_BASE_URL}/webhook/rappi",
                'database': 'connected'
            })
        else:
            raise Exception("Database test failed")
            
    except Exception as e:
        logger.error(f"Health check failed: {e}")
        return jsonify({
            'status': 'unhealthy',
            'error': str(e),
            'timestamp': datetime.utcnow().isoformat(),
            'database': 'disconnected'
        }), 500

@app.route('/debug/last-requests')
def debug_last_requests():
    """Endpoint para debug - ver últimas peticiones recibidas"""
    try:
        # Obtener los últimos 10 logs del sistema
        logs = SystemLog.query.filter(
            SystemLog.endpoint == '/webhook/rappi'
        ).order_by(SystemLog.timestamp.desc()).limit(10).all()
        
        result = []
        for log in logs:
            additional_data = {}
            if log.additional_data:
                try:
                    additional_data = json.loads(log.additional_data)
                except:
                    additional_data = {"raw": log.additional_data}
                    
            result.append({
                'timestamp': log.timestamp.strftime('%Y-%m-%d %H:%M:%S'),
                'level': log.level,
                'message': log.message,
                'ip': log.ip_address,
                'additional_data': additional_data
            })
        
        # También obtener los últimos webhooks recibidos
        webhooks = WebhookEvent.query.order_by(WebhookEvent.fecha_recepcion.desc()).limit(5).all()
        
        webhook_data = []
        for wh in webhooks:
            webhook_data.append({
                'id': wh.id,
                'tipo': wh.evento_tipo,
                'store_id': wh.store_id,
                'procesado': wh.procesado,
                'fecha': wh.fecha_recepcion.strftime('%Y-%m-%d %H:%M:%S'),
                'datos_json': wh.datos_json[:500] + '...' if len(wh.datos_json) > 500 else wh.datos_json
            })
        
        return jsonify({
            'logs': result,
            'webhooks': webhook_data,
            'total_webhooks': WebhookEvent.query.count(),
            'webhook_url': f"{WEBHOOK_BASE_URL}/webhook/rappi"
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/test-webhook-manual', methods=['POST'])
def test_webhook_manual():
    """Endpoint para probar manualmente la identificación de eventos"""
    try:
        test_data = request.get_json()
        
        if not test_data:
            return jsonify({'error': 'No JSON data provided'}), 400
            
        event_type = identify_event_type(test_data)
        
        return jsonify({
            'success': True,
            'identified_event_type': event_type,
            'payload_keys': list(test_data.keys()),
            'payload': test_data
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/config')
def show_config():
    """Mostrar configuración actual"""
    return jsonify({
        'webhook_url': f"{WEBHOOK_BASE_URL}/webhook/rappi",
        'has_secret': bool(RAPPI_WEBHOOK_SECRET),
        'database_connected': True,
        'supported_events': [
            'ORDER_EVENT_CANCEL',
            'ORDER_OTHER_EVENT', 
            'MENU_APPROVED',
            'MENU_REJECTED',
            'PING',
            'STORE_CONNECTIVITY',
            'ORDER_RT_TRACKING'
        ]
    })

# =================== INICIALIZACIÓN ===================

def init_database():
    """Inicializar base de datos"""
    try:
        with app.app_context():
            db.create_all()
            logger.info("Base de datos inicializada correctamente")
            
            log_system_event('INFO', 'Sistema de webhooks iniciado', 
                           additional_data={'webhook_url': f"{WEBHOOK_BASE_URL}/webhook/rappi"})
            
    except Exception as e:
        logger.error(f"Error inicializando base de datos: {e}")
        raise

# Inicializar BD al importar
init_database()

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)