Subscription Billing Systems: Recurring Payments and Dunning Management

from datetime import datetime, timedelta
from enum import Enum

class SubscriptionStatus(Enum):
    ACTIVE = "active"
    PAUSED = "paused"
    CANCELLED = "cancelled"
    PAST_DUE = "past_due"

class SubscriptionBillingSystem:
    """Manage subscription billing"""
    
    def __init__(self, db_connection, payment_processor):
        self.db = db_connection
        self.payment = payment_processor
    
    def create_subscription(self, customer_id: str, plan_id: str,
                           billing_cycle: str = "monthly") -> dict:
        """Create new subscription"""
        
        plan = self.db.query("SELECT * FROM plans WHERE id = ?", (plan_id,))[0]
        
        subscription = {
            'id': f"sub_{datetime.now().timestamp()}",
            'customer_id': customer_id,
            'plan_id': plan_id,
            'status': SubscriptionStatus.ACTIVE.value,
            'billing_cycle': billing_cycle,
            'amount': plan['price'],
            'created_at': datetime.now(),
            'next_billing_date': datetime.now() + timedelta(days=30),
            'failed_attempts': 0
        }
        
        self.db.insert('subscriptions', subscription)
        
        # Charge immediately
        self.charge_subscription(subscription['id'])
        
        return subscription
    
    def charge_subscription(self, subscription_id: str) -> dict:
        """Charge subscription"""
        
        subscription = self.db.query(
            "SELECT * FROM subscriptions WHERE id = ?",
            (subscription_id,)
        )[0]
        
        customer = self.db.query(
            "SELECT * FROM customers WHERE id = ?",
            (subscription['customer_id'],)
        )[0]
        
        # Attempt charge
        try:
            charge = self.payment.charge(
                customer['payment_method_id'],
                subscription['amount'],
                description=f"Subscription {subscription_id}"
            )
            
            # Record successful charge
            self.db.insert('charges', {
                'subscription_id': subscription_id,
                'amount': subscription['amount'],
                'status': 'succeeded',
                'charge_id': charge['id'],
                'charged_at': datetime.now()
            })
            
            # Update subscription
            self.db.update('subscriptions', subscription_id, {
                'status': SubscriptionStatus.ACTIVE.value,
                'next_billing_date': datetime.now() + timedelta(days=30),
                'failed_attempts': 0
            })
            
            return {'success': True, 'charge_id': charge['id']}
        
        except Exception as e:
            # Record failed charge
            self.db.insert('charges', {
                'subscription_id': subscription_id,
                'amount': subscription['amount'],
                'status': 'failed',
                'error': str(e),
                'charged_at': datetime.now()
            })
            
            # Increment failed attempts
            failed_attempts = subscription['failed_attempts'] + 1
            
            self.db.update('subscriptions', subscription_id, {
                'failed_attempts': failed_attempts,
                'status': SubscriptionStatus.PAST_DUE.value if failed_attempts > 0 else SubscriptionStatus.ACTIVE.value
            })
            
            return {'success': False, 'error': str(e)}
    
    def cancel_subscription(self, subscription_id: str,
                           reason: str = None) -> dict:
        """Cancel subscription"""
        
        self.db.update('subscriptions', subscription_id, {
            'status': SubscriptionStatus.CANCELLED.value,
            'cancelled_at': datetime.now(),
            'cancellation_reason': reason
        })
        
        return {'success': True}

# Usage
billing = SubscriptionBillingSystem(db, payment_processor)

# Create subscription
sub = billing.create_subscription('cust_123', 'plan_pro')

# Charge subscription
result = billing.charge_subscription(sub['id'])

class DunningManager:
    """Manage failed payment recovery"""
    
    RETRY_SCHEDULE = [
        {'days': 0, 'description': 'Initial charge'},
        {'days': 3, 'description': 'First retry'},
        {'days': 5, 'description': 'Second retry'},
        {'days': 7, 'description': 'Final retry'},
    ]
    
    def __init__(self, db_connection, payment_processor):
        self.db = db_connection
        self.payment = payment_processor
    
    def process_failed_payment(self, subscription_id: str):
        """Process failed payment with dunning"""
        
        subscription = self.db.query(
            "SELECT * FROM subscriptions WHERE id = ?",
            (subscription_id,)
        )[0]
        
        failed_attempts = subscription['failed_attempts']
        
        if failed_attempts >= len(self.RETRY_SCHEDULE):
            # Max retries reached
            self._cancel_subscription(subscription_id)
            return
        
        # Schedule next retry
        retry_info = self.RETRY_SCHEDULE[failed_attempts]
        next_retry = datetime.now() + timedelta(days=retry_info['days'])
        
        self.db.insert('dunning_attempts', {
            'subscription_id': subscription_id,
            'attempt_number': failed_attempts,
            'scheduled_at': next_retry,
            'status': 'scheduled'
        })
    
    def _cancel_subscription(self, subscription_id: str):
        """Cancel subscription after max retries"""
        
        self.db.update('subscriptions', subscription_id, {
            'status': SubscriptionStatus.CANCELLED.value,
            'cancellation_reason': 'Payment failed - max retries exceeded'
        })

# Usage
dunning = DunningManager(db, payment_processor)
dunning.process_failed_payment('sub_123')