Comprehensive comparison for technology in applications

from celery import Celery, Task
from celery.exceptions import MaxRetriesExceededError
from kombu import Queue
import logging
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from typing import Dict, List
import redis
from datetime import datetime, timedelta

# Configure Celery with Redis as broker and result backend
app = Celery(
    'order_processing',
    broker='redis://localhost:6379/0',
    backend='redis://localhost:6379/1'
)

# Celery configuration
app.conf.update(
    task_serializer='json',
    accept_content=['json'],
    result_serializer='json',
    timezone='UTC',
    enable_utc=True,
    task_track_started=True,
    task_time_limit=300,
    task_soft_time_limit=240,
    worker_prefetch_multiplier=4,
    task_acks_late=True,
    task_reject_on_worker_lost=True,
    task_default_queue='default',
    task_queues=(
        Queue('default', routing_key='default'),
        Queue('high_priority', routing_key='high_priority'),
        Queue('low_priority', routing_key='low_priority'),
    )
)

logger = logging.getLogger(__name__)
redis_client = redis.Redis(host='localhost', port=6379, db=2, decode_responses=True)


class OrderProcessingTask(Task):
    """Custom task class with error handling and retry logic"""
    autoretry_for = (smtplib.SMTPException, ConnectionError)
    retry_kwargs = {'max_retries': 3, 'countdown': 60}
    retry_backoff = True
    retry_backoff_max = 600
    retry_jitter = True


@app.task(base=OrderProcessingTask, bind=True, queue='high_priority')
def process_order_payment(self, order_id: str, customer_email: str, amount: float) -> Dict:
    """Process payment for an order with retry logic and notifications"""
    try:
        # Check if order was already processed (idempotency)
        cache_key = f'order_processed:{order_id}'
        if redis_client.get(cache_key):
            logger.info(f'Order {order_id} already processed, skipping')
            return {'status': 'already_processed', 'order_id': order_id}

        # Simulate payment processing
        logger.info(f'Processing payment for order {order_id}, amount: ${amount}')
        
        # Mock payment gateway call
        payment_result = _process_payment_gateway(order_id, amount)
        
        if not payment_result['success']:
            raise Exception(f"Payment failed: {payment_result['error']}")

        # Mark order as processed (cache for 24 hours)
        redis_client.setex(cache_key, timedelta(hours=24), '1')
        
        # Send confirmation email asynchronously
        send_order_confirmation_email.apply_async(
            args=[customer_email, order_id, amount],
            countdown=5
        )
        
        # Update inventory asynchronously with lower priority
        update_inventory.apply_async(
            args=[order_id],
            queue='low_priority'
        )
        
        return {
            'status': 'success',
            'order_id': order_id,
            'transaction_id': payment_result['transaction_id'],
            'processed_at': datetime.utcnow().isoformat()
        }
        
    except Exception as exc:
        logger.error(f'Error processing order {order_id}: {str(exc)}')
        try:
            # Retry with exponential backoff
            raise self.retry(exc=exc, countdown=2 ** self.request.retries * 60)
        except MaxRetriesExceededError:
            # Send alert to admin after max retries
            send_admin_alert.apply_async(
                args=[f'Order {order_id} failed after max retries', str(exc)],
                queue='high_priority'
            )
            return {'status': 'failed', 'order_id': order_id, 'error': str(exc)}


@app.task(bind=True, max_retries=5)
def send_order_confirmation_email(self, customer_email: str, order_id: str, amount: float) -> bool:
    """Send order confirmation email to customer"""
    try:
        msg = MIMEMultipart('alternative')
        msg['Subject'] = f'Order Confirmation - {order_id}'
        msg['From'] = '[email protected]'
        msg['To'] = customer_email
        
        html_content = f"""
        <html>
          <body>
            <h2>Order Confirmed!</h2>
            <p>Your order {order_id} has been confirmed.</p>
            <p>Amount: ${amount:.2f}</p>
            <p>Thank you for your purchase!</p>
          </body>
        </html>
        """
        
        msg.attach(MIMEText(html_content, 'html'))
        
        # Mock SMTP send (replace with actual SMTP configuration)
        logger.info(f'Sending confirmation email to {customer_email} for order {order_id}')
        # with smtplib.SMTP('smtp.example.com', 587) as server:
        #     server.starttls()
        #     server.login('user', 'password')
        #     server.send_message(msg)
        
        return True
        
    except Exception as exc:
        logger.error(f'Failed to send email: {str(exc)}')
        raise self.retry(exc=exc, countdown=120)


@app.task(queue='low_priority')
def update_inventory(order_id: str) -> Dict:
    """Update inventory after successful order"""
    logger.info(f'Updating inventory for order {order_id}')
    # Mock inventory update logic
    return {'status': 'inventory_updated', 'order_id': order_id}


@app.task(queue='high_priority')
def send_admin_alert(subject: str, message: str) -> bool:
    """Send alert to admin for critical issues"""
    logger.critical(f'ADMIN ALERT: {subject} - {message}')
    # Implement actual alerting (email, Slack, PagerDuty, etc.)
    return True


def _process_payment_gateway(order_id: str, amount: float) -> Dict:
    """Mock payment gateway integration"""
    # Simulate payment processing
    import random
    success = random.random() > 0.1  # 90% success rate
    
    if success:
        return {
            'success': True,
            'transaction_id': f'txn_{order_id}_{int(datetime.utcnow().timestamp())}'
        }
    else:
        return {'success': False, 'error': 'Insufficient funds'}


# Periodic task to clean up old cache entries
@app.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
    """Setup periodic tasks"""
    sender.add_periodic_task(
        3600.0,  # Run every hour
        cleanup_old_orders.s(),
        name='cleanup_old_orders_hourly'
    )


@app.task
def cleanup_old_orders() -> int:
    """Clean up old processed order cache entries"""
    logger.info('Running cleanup task for old orders')
    # Implement cleanup logic
    return 0