import datetime
from datetime import timedelta

# --- STEP 1: DEFINE THE PLANS AND PRICES ---
# We define the available subscription tiers and their monthly costs.
PLANS = {
    "basic": {"price": 10.00, "name": "Basic"},
    "premium": {"price": 20.00, "name": "Premium"}
}

# --- STEP 2: THE SUBSCRIPTION CLASS ---
class Subscription:
    def __init__(self, customer_name, plan_name, start_date):
        self.customer = customer_name
        self.plan = plan_name
        self.price = PLANS[plan_name]["price"]
        self.billing_cycle_length_days = 30  # Simplified to 30 days
        self.start_date = start_date
        self.next_billing_date = start_date + timedelta(days=self.billing_cycle_length_days)
        self.status = "active"
        self.transaction_history = []

    def charge_next_billing(self):
        """Simulates charging the card at the next billing date."""
        # In production, this sends an API request to Stripe.
        print(f"[BILLING] Charging {self.customer} ${self.price:.2f} for {self.plan} plan.")
        self.transaction_history.append({
            "date": datetime.datetime.now(),
            "amount": self.price,
            "type": "recurring_charge"
        })
        # Move the next billing date forward by 30 days
        self.next_billing_date = self.next_billing_date + timedelta(days=self.billing_cycle_length_days)

    def change_plan(self, new_plan_name, change_date):
        """
        Calculates proration and executes the plan change.
        """
        if new_plan_name == self.plan:
            print("Already on this plan.")
            return
        
        new_price = PLANS[new_plan_name]["price"]
        old_price = self.price
        
        # --- THE PRORATION MATH ---
        # 1. Calculate days remaining in the current billing cycle
        #    Difference between the change_date and the next_billing_date
        days_remaining = (self.next_billing_date - change_date).days
        
        # Safety check: If days_remaining is 0 or negative, we are at the start of a new cycle.
        if days_remaining <= 0:
            print(f"[BILLING] Date is past the billing cycle. Immediately applying new plan price.")
            self.price = new_price
            self.plan = new_plan_name
            return
        
        # 2. Calculate daily rates
        daily_old = old_price / self.billing_cycle_length_days
        daily_new = new_price / self.billing_cycle_length_days
        
        # 3. Calculate the Credit (for unused old plan) and the Charge (for new plan)
        credit_for_old = daily_old * days_remaining
        charge_for_new = daily_new * days_remaining
        
        # 4. Calculate Net Prorated Amount
        prorated_charge = charge_for_new - credit_for_old
        
        # --- EXECUTING THE CHANGE ---
        if prorated_charge > 0:
            print(f"[BILLING] Upgrade from {self.plan} to {new_plan_name}.")
            print(f"    Prorated Charge today: ${prorated_charge:.2f} (Days remaining: {days_remaining})")
            # In production, we would charge the card `prorated_charge` here.
            self.transaction_history.append({
                "date": datetime.datetime.now(),
                "amount": prorated_charge,
                "type": "prorated_upgrade"
            })
        elif prorated_charge < 0:
            # A negative charge means we owe the customer a credit
            credit_amount = abs(prorated_charge)
            print(f"[BILLING] Downgrade from {self.plan} to {new_plan_name}.")
            print(f"    Credit applied to account: ${credit_amount:.2f} (Applied to next month's bill)")
            self.transaction_history.append({
                "date": datetime.datetime.now(),
                "amount": -credit_amount, # Stored as a negative
                "type": "prorated_downgrade_credit"
            })
        else:
            print(f"[BILLING] Plan change with $0 proration (neither party owes anything).")
        
        # 5. Update the subscription state
        self.plan = new_plan_name
        self.price = new_price

# --- STEP 3: RUNNING THE SIMULATION ---
# We create a subscription starting Jan 1st.
start_date = datetime.date(2024, 1, 1)
sub = Subscription("Alice", "basic", start_date)

print("--- SIMULATION: SUBSCRIPTION LIFECYCLE ---")
sub.charge_next_billing() # Alice pays $10 on Jan 1st. Next billing is Feb 1st.

# On Jan 15th, Alice wants to upgrade to Premium.
# We calculate the proration based on Jan 15th.
upgrade_date = datetime.date(2024, 1, 15)
sub.change_plan("premium", upgrade_date)

# On Feb 1st, the next billing runs.
# Because her daily rate is now $20/month, she pays the full $20.
print("\n--- NEXT BILLING CYCLE (FEBRUARY 1ST) ---")
sub.charge_next_billing()

print("\n--- TRANSACTION HISTORY ---")
for tx in sub.transaction_history:
    print(tx)

import datetime
from datetime import timedelta
import time

# --- STEP 1: MOCK PAYMENT GATEWAY ---
# This simulates a real payment gateway. We will make it fail 3 times, then succeed on the 4th.
class MockPaymentGateway:
    def __init__(self):
        self.attempt_counter = 0
    
    def charge_card(self, token, amount):
        self.attempt_counter += 1
        # Simulate: Fail for the first 3 attempts, succeed on the 4th.
        if self.attempt_counter <= 3:
            return {"status": "failed", "error": "insufficient_funds"}
        else:
            return {"status": "succeeded", "transaction_id": "txn_12345"}

# --- STEP 2: THE DUNNING ENGINE ---
class DunningEngine:
    def __init__(self, payment_gateway):
        self.gateway = payment_gateway
        self.dunning_queue = []  # List of subscriptions currently in the dunning process

    def add_to_dunning(self, subscription, last_attempt_date):
        """Adds a subscription to the dunning queue after an initial failure."""
        # We schedule the first retry 3 days after the last attempt.
        self.dunning_queue.append({
            "subscription": subscription,
            "last_attempt_date": last_attempt_date,
            "attempt_count": 1 # We are on the 1st retry attempt
        })
        print(f"[DUNNING] Subscription for {subscription.customer} entered dunning queue.")

    def process_dunning_queue(self, current_date):
        """Scans the queue and processes any subscriptions that are ready for a retry."""
        print(f"\n[DUNNING ENGINE] Scanning queue on {current_date.strftime('%Y-%m-%d')}...")
        
        # We iterate over a copy of the list to allow modifications
        for item in list(self.dunning_queue):
            sub = item["subscription"]
            last_attempt = item["last_attempt_date"]
            attempt_count = item["attempt_count"]
            
            # --- THE SMART RETRY SCHEDULE (EXPONENTIAL BACKOFF) ---
            # Attempt 1: 3 days after last attempt.
            # Attempt 2: 7 days after last attempt.
            # Attempt 3: 14 days after last attempt.
            schedule = {1: 3, 2: 7, 3: 14}
            
            days_until_next_retry = schedule.get(attempt_count)
            
            # Check if enough days have passed since the last attempt
            if (current_date - last_attempt).days >= days_until_next_retry:
                print(f"    -> RETRYING CHARGE for {sub.customer} (Attempt #{attempt_count})")
                
                # Attempt the charge via the gateway
                result = self.gateway.charge_card("token_123", sub.price)
                
                if result["status"] == "succeeded":
                    print(f"        -> SUCCESS! Payment recovered for {sub.customer}.")
                    # Remove them from dunning, set status back to active, move the billing date forward.
                    self.dunning_queue.remove(item)
                    sub.status = "active"
                    sub.next_billing_date = current_date + timedelta(days=30)
                else:
                    # Payment failed again
                    print(f"        -> FAILED. Reason: {result['error']}")
                    
                    # Increment attempt count and update the last attempt date
                    item["attempt_count"] += 1
                    item["last_attempt_date"] = current_date
                    
                    # Check if we have exceeded maximum retries (3 attempts)
                    if item["attempt_count"] > 3:
                        print(f"        -> CRITICAL: Max retries exhausted for {sub.customer}.")
                        print(f"        -> SUBSCRIPTION CANCELLED.")
                        # Cancel the subscription, remove from queue
                        sub.status = "cancelled"
                        self.dunning_queue.remove(item)

# --- STEP 3: RUNNING THE DUNNING SIMULATION ---
# We use the Subscription class from our previous lab.
# We create a subscription for Bob.
start_date = datetime.date(2024, 1, 1)
bob_sub = Subscription("Bob", "basic", start_date)

# Simulate the initial payment failing
print("--- DUNNING SIMULATION: INITIAL PAYMENT FAILS ---")
print(f"[BILLING] Initial charge for {bob_sub.customer} FAILED.")

# Initialize the Mock Gateway and Dunning Engine
gateway = MockPaymentGateway() # This will fail 3 times, succeed on the 4th.
engine = DunningEngine(gateway)

# Add Bob's subscription to the dunning queue
engine.add_to_dunning(bob_sub, datetime.date(2024, 1, 1))

# We will fast-forward time and check the queue on specific days
test_dates = [
    datetime.date(2024, 1, 4), # Day 3
    datetime.date(2024, 1, 8), # Day 7
    datetime.date(2024, 1, 15), # Day 14
]

for date in test_dates:
    engine.process_dunning_queue(date)

print(f"\n--- FINAL STATUS ---")
print(f"Bob's Subscription Status: {bob_sub.status}")