from django.db import transaction, connection
from django.db.transaction import Atomic
from functools import wraps
import logging
 
logger = logging.getLogger(__name__)
 
class TransactionManager:
    def __init__(self, isolation_level=None):
        self.isolation_level = isolation_level or 'read committed'
 
    def __enter__(self):
        connection.set_autocommit(False)
        self.transaction = transaction.atomic()
        self.transaction.__enter__()
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            self.transaction.__exit__(exc_type, exc_val, exc_tb)
            raise exc_val
        return self.transaction.__exit__(exc_type, exc_val, exc_tb)
 
def with_savepoint(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        with transaction.savepoint():
            return func(*args, **kwargs)
    return wrapper
 
class OrderProcessingService:
    @with_savepoint
    def process_order(self, order_id, payment_data):
        from myapp.models import Order, Payment, Inventory
        order = Order.objects.select_for_update().get(id=order_id)
 
        with transaction.savepoint():
            inventory_check = Inventory.objects.select_for_update().filter(
                product_id=order.product_id,
                quantity__gte=order.quantity
            ).exists()
 
            if not inventory_check:
                raise ValueError('Insufficient inventory')
 
        payment = Payment.objects.create(
            order=order,
            amount=order.total,
            **payment_data
        )
 
        with transaction.atomic(savepoint=True):
            Inventory.objects.filter(product_id=order.product_id).update(
                quantity=models.F('quantity') - order.quantity
            )
 
            order.status = 'processing'
            order.save()
 
        return order
 
    def bulk_process_with_recovery(self, order_ids):
        results = {'success': [], 'failed': []}
        for order_id in order_ids:
            try:
                with TransactionManager('repeatable read'):
                    self.process_order(order_id, {})
                    results['success'].append(order_id)
            except Exception as e:
                logger.error(f'Order {order_id} failed: {e}')
                results['failed'].append({'id': order_id, 'error': str(e)})
        return results