根据需求描述，我们使用策略模式来实现支付系统中的不同购买行为（新购、升级、续费）。策略模式适用于需要根据不同条件选择不同算法的场景，这里每种购买行为都有独立的支付金额和有效期计算逻辑，因此策略模式是合适的选择。

实现方案

1. 定义抽象策略接口 PurchaseStrategy，包含计算支付金额和有效期的抽象方法
2. 实现三种具体策略：
   • NewPurchaseStrategy：处理新购逻辑
   • UpgradeStrategy：处理升级逻辑
   • RenewalStrategy：处理续费逻辑
3. 使用上下文类 PurchaseContext 来执行策略

代码实现

from abc import ABC, abstractmethod
from datetime import datetime, timedelta

class PurchaseStrategy(ABC):
    """购买策略抽象接口"""
    @abstractmethod
    def calculate_amount(self, context: dict) -> float:
        pass
    
    @abstractmethod
    def calculate_expiration(self, context: dict) -> datetime:
        pass

class NewPurchaseStrategy(PurchaseStrategy):
    """新购策略"""
    def calculate_amount(self, context: dict) -> float:
        # 新购直接使用服务价格
        return context['service_price']
    
    def calculate_expiration(self, context: dict) -> datetime:
        # 新购默认一年有效期
        return context['current_time'] + timedelta(days=365)

class UpgradeStrategy(PurchaseStrategy):
    """升级策略"""
    def calculate_amount(self, context: dict) -> float:
        # 计算差价 = (新服务价格 - 旧服务价格) * 剩余时间比例
        time_used = (context['current_time'] - context['original_start_time']).days
        total_duration = 365  # 假设原服务一年期
        remaining_ratio = 1 - time_used / total_duration
        return (context['new_service_price'] - context['original_service_price']) * remaining_ratio
    
    def calculate_expiration(self, context: dict) -> datetime:
        # 新到期时间 = 当前时间 + 剩余时间 + 新服务时长
        original_remaining = context['original_expiration'] - context['current_time']
        new_duration = timedelta(days=365)  # 新服务一年
        return context['current_time'] + original_remaining + new_duration

class RenewalStrategy(PurchaseStrategy):
    """续费策略"""
    def calculate_amount(self, context: dict) -> float:
        # 续费价格 = 服务价格 × 续费年限
        return context['service_price'] * context['renewal_years']
    
    def calculate_expiration(self, context: dict) -> datetime:
        # 在原始到期时间上增加续费年限
        return context['original_expiration'] + timedelta(days=365 * context['renewal_years'])

class PurchaseContext:
    """购买上下文，执行具体策略"""
    def __init__(self, strategy: PurchaseStrategy):
        self._strategy = strategy
    
    def execute_calculation(self, context: dict) -> dict:
        """执行策略计算"""
        return {
            "amount": self._strategy.calculate_amount(context),
            "expiration": self._strategy.calculate_expiration(context)
        }

# 示例使用
if __name__ == "__main__":
    # 公共参数
    current_time = datetime.now()
    original_start_time = current_time - timedelta(days=100)  # 假设100天前购买
    original_expiration = original_start_time + timedelta(days=365)  # 原服务有效期
    
    # 新购示例
    new_purchase_context = {
        'current_time': current_time,
        'service_price': 100.0
    }
    context = PurchaseContext(NewPurchaseStrategy())
    result = context.execute_calculation(new_purchase_context)
    print(f"新购结果: 金额={result['amount']}, 到期时间={result['expiration']}")
    
    # 升级示例
    upgrade_context = {
        'current_time': current_time,
        'original_start_time': original_start_time,
        'original_expiration': original_expiration,
        'original_service_price': 80.0,
        'new_service_price': 120.0
    }
    context = PurchaseContext(UpgradeStrategy())
    result = context.execute_calculation(upgrade_context)
    print(f"升级结果: 金额={result['amount']:.2f}, 到期时间={result['expiration']}")
    
    # 续费示例
    renewal_context = {
        'original_expiration': original_expiration,
        'service_price': 90.0,
        'renewal_years': 2  # 续费两年
    }
    context = PurchaseContext(RenewalStrategy())
    result = context.execute_calculation(renewal_context)
    print(f"续费结果: 金额={result['amount']}, 到期时间={result['expiration']}")

策略说明

1. 新购策略：

   • 支付金额：直接使用服务价格
   • 有效期：从当前时间开始计算一年

2. 升级策略：

   • 支付金额：计算新旧服务差价 × 剩余时间比例
   • 有效期：原始剩余时间 + 新服务时长（一年）

3. 续费策略：

   • 支付金额：服务价格 × 续费年限
   • 有效期：在原始到期时间上增加续费年限

策略模式选择理由

• 扩展性：新增购买类型只需添加新策略类
• 解耦：将业务逻辑与客户端代码分离
• 复用性：共用计算接口，便于统一管理

此实现严格遵循需求描述，对时间计算使用天数为单位（按 365 天/年），实际生产环境可根据业务需求调整时间计算精度。