// 重构前的代码：一个充满问题的订单处理类
public class OrderProcessor {
    
    public void processOrder(Order order) {
        // 验证订单
        if (order.getItems() == null || order.getItems().isEmpty()) {
            throw new IllegalArgumentException("Order must have items");
        }
        
        // 计算总价
        double total = 0;
        for (OrderItem item : order.getItems()) {
            total += item.getPrice() * item.getQuantity();
        }
        
        // 应用折扣
        if (total > 1000) {
            total = total * 0.9; // 10% discount for large orders
        } else if (total > 500) {
            total = total * 0.95; // 5% discount
        }
        
        // 检查库存
        for (OrderItem item : order.getItems()) {
            Inventory inventory = getInventory(item.getProductId());
            if (inventory.getStock() < item.getQuantity()) {
                throw new RuntimeException("Insufficient stock for product: " + item.getProductId());
            }
        }
        
        // 扣减库存
        for (OrderItem item : order.getItems()) {
            Inventory inventory = getInventory(item.getProductId());
            inventory.setStock(inventory.getStock() - item.getQuantity());
            saveInventory(inventory);
        }
        
        // 创建支付
        Payment payment = new Payment();
        payment.setAmount(total);
        payment.setOrderId(order.getId());
        payment.setStatus("PENDING");
        savePayment(payment);
        
        // 发送确认邮件
        sendConfirmationEmail(order, total);
        
        // 更新订单状态
        order.setStatus("PROCESSING");
        saveOrder(order);
    }
    
    private Inventory getInventory(String productId) { /* ... */ }
    private void saveInventory(Inventory inventory) { /* ... */ }
    private void savePayment(Payment payment) { /* ... */ }
    private void sendConfirmationEmail(Order order, double amount) { /* ... */ }
    private void saveOrder(Order order) { /* ... */ }
}

// 重构后的代码：职责分离，清晰可读
public class OrderProcessor {
    
    private static final double LARGE_ORDER_THRESHOLD = 1000.0;
    private static final double MEDIUM_ORDER_THRESHOLD = 500.0;
    private static final double LARGE_ORDER_DISCOUNT = 0.9;
    private static final double MEDIUM_ORDER_DISCOUNT = 0.95;
    
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    private final OrderRepository orderRepository;
    
    public OrderProcessor(InventoryService inventoryService,
                         PaymentService paymentService,
                         NotificationService notificationService,
                         OrderRepository orderRepository) {
        this.inventoryService = inventoryService;
        this.paymentService = paymentService;
        this.notificationService = notificationService;
        this.orderRepository = orderRepository;
    }
    
    public ProcessingResult processOrder(Order order) {
        validateOrder(order);
        
        double total = calculateTotal(order);
        double discountedTotal = applyDiscount(total);
        
        checkAndReserveInventory(order);
        
        Payment payment = createPayment(order, discountedTotal);
        
        order.setStatus(OrderStatus.PROCESSING);
        orderRepository.save(order);
        
        notificationService.sendConfirmation(order, discountedTotal);
        
        return new ProcessingResult(order.getId(), payment.getId(), discountedTotal);
    }
    
    private void validateOrder(Order order) {
        if (order.getItems() == null || order.getItems().isEmpty()) {
            throw new InvalidOrderException("Order must contain at least one item");
        }
        if (order.getCustomer() == null) {
            throw new InvalidOrderException("Order must have a customer");
        }
    }
    
    private double calculateTotal(Order order) {
        return order.getItems().stream()
            .mapToDouble(item -> item.getPrice() * item.getQuantity())
            .sum();
    }
    
    private double applyDiscount(double total) {
        if (total > LARGE_ORDER_THRESHOLD) {
            return total * LARGE_ORDER_DISCOUNT;
        } else if (total > MEDIUM_ORDER_THRESHOLD) {
            return total * MEDIUM_ORDER_DISCOUNT;
        }
        return total;
    }
    
    private void checkAndReserveInventory(Order order) {
        Map<String, Integer> requiredStock = aggregateRequiredStock(order);
        
        for (Map.Entry<String, Integer> entry : requiredStock.entrySet()) {
            String productId = entry.getKey();
            int required = entry.getValue();
            
            Inventory inventory = inventoryService.getInventory(productId);
            if (inventory.getAvailableStock() < required) {
                throw new InsufficientStockException(
                    "Insufficient stock for product: " + productId);
            }
            inventoryService.reserveStock(productId, required);
        }
    }
    
    private Map<String, Integer> aggregateRequiredStock(Order order) {
        return order.getItems().stream()
            .collect(Collectors.groupingBy(
                OrderItem::getProductId,
                Collectors.summingInt(OrderItem::getQuantity)));
    }
    
    private Payment createPayment(Order order, double amount) {
        Payment payment = new Payment();
        payment.setAmount(amount);
        payment.setOrderId(order.getId());
        payment.setStatus(PaymentStatus.PENDING);
        return paymentService.createPayment(payment);
    }
}

"""
技术债务量化分析工具

这个示例展示了如何用数据驱动的方式评估技术债务的影响。
"""

import json
from dataclasses import dataclass, field
from typing import List, Dict
from datetime import datetime


@dataclass
class CodeMetric:
    """代码度量指标"""
    file_path: str
    lines_of_code: int
    cyclomatic_complexity: int
    number_of_methods: int
    max_method_length: int
    coupling_count: int  # 与其他类的依赖数量
    
    def calculate_maintenance_index(self) -> float:
        """
        计算维护指数（0-100，越高越好）
        
        这是一个简化的公式，实际项目中可以使用更复杂的模型
        """
        # 基础分
        score = 100.0
        
        # 代码长度惩罚
        if self.lines_of_code > 500:
            score -= min(30, (self.lines_of_code - 500) / 50)
        
        # 复杂度惩罚
        if self.cyclomatic_complexity > 10:
            score -= min(25, (self.cyclomatic_complexity - 10) * 2)
        
        # 方法长度惩罚
        if self.max_method_length > 50:
            score -= min(20, (self.max_method_length - 50) / 5)
        
        # 耦合度惩罚
        if self.coupling_count > 10:
            score -= min(25, (self.coupling_count - 10) * 2)
        
        return max(0, score)


@dataclass
class TechnicalDebtItem:
    """技术债务项"""
    description: str
    severity: str  # LOW, MEDIUM, HIGH, CRITICAL
    estimated_fix_hours: float
    impact_on_velocity: float  # 对开发速度的影响百分比
    introduced_date: str
    category: str  # CODE_SMELL, MISSING_TEST, DUPLICATION, etc.
    
    def calculate_interest_rate(self) -> float:
        """
        计算债务的'利率'
        
        利率表示如果不修复，每月额外增加的成本比例
        """
        severity_multiplier = {
            'LOW': 0.02,
            'MEDIUM': 0.05,
            'HIGH': 0.10,
            'CRITICAL': 0.20
        }
        base_rate = severity_multiplier.get(self.severity, 0.05)
        
        # 债务存在时间越长，利率越高（复利效应）
        months_exist = self._months_since_introduced()
        compounded_rate = base_rate * (1 + 0.1 * months_exist)
        
        return min(compounded_rate, 0.5)  # 上限50%
    
    def _months_since_introduced(self) -> int:
        introduced = datetime.strptime(self.introduced_date, "%Y-%m-%d")
        now = datetime.now()
        return (now.year - introduced.year) * 12 + (now.month - introduced.month)


class TechnicalDebtAnalyzer:
    """技术债务分析器"""
    
    def __init__(self):
        self.debt_items: List[TechnicalDebtItem] = []
        self.code_metrics: List[CodeMetric] = []
    
    def add_debt_item(self, item: TechnicalDebtItem):
        self.debt_items.append(item)
    
    def add_code_metric(self, metric: CodeMetric):
        self.code_metrics.append(metric)
    
    def generate_report(self) -> Dict:
        """生成技术债务报告"""
        total_fix_cost = sum(item.estimated_fix_hours for item in self.debt_items)
        average_maintenance_index = self._calculate_average_mi()
        
        # 计算每月的利息成本
        monthly_interest = sum(
            item.estimated_fix_hours * item.calculate_interest_rate()
            for item in self.debt_items
        )
        
        # 按严重程度分类
        by_severity = {}
        for item in self.debt_items:
            if item.severity not in by_severity:
                by_severity[item.severity] = []
            by_severity[item.severity].append({
                'description': item.description,
                'fix_hours': item.estimated_fix_hours,
                'interest_rate': f"{item.calculate_interest_rate():.2%}"
            })
        
        return {
            'summary': {
                'total_debt_items': len(self.debt_items),
                'total_fix_cost_hours': total_fix_cost,
                'monthly_interest_cost_hours': round(monthly_interest, 2),
                'average_maintenance_index': round(average_maintenance_index, 2),
                'code_health': self._assess_health(average_maintenance_index)
            },
            'by_severity': by_severity,
            'recommendations': self._generate_recommendations()
        }
    
    def _calculate_average_mi(self) -> float:
        if not self.code_metrics:
            return 0
        return sum(m.calculate_maintenance_index() for m in self.code_metrics) / len(self.code_metrics)
    
    def _assess_health(self, mi: float) -> str:
        if mi >= 80:
            return "HEALTHY"
        elif mi >= 60:
            return "MODERATE_RISK"
        elif mi >= 40:
            return "HIGH_RISK"
        else:
            return "CRITICAL"
    
    def _generate_recommendations(self) -> List[str]:
        recommendations = []
        
        critical_items = [i for i in self.debt_items if i.severity == 'CRITICAL']
        if critical_items:
            recommendations.append(
                f"立即处理 {len(critical_items)} 个严重级别的技术债务项"
            )
        
        high_impact = sorted(
            self.debt_items,
            key=lambda x: x.impact_on_velocity,
            reverse=True
        )[:5]
        if high_impact:
            recommendations.append(
                "优先修复对开发速度影响最大的以下债务项："
            )
            for item in high_impact:
                recommendations.append(f"  - {item.description}")
        
        if self._calculate_average_mi() < 60:
            recommendations.append(
                "整体代码健康度较低，建议安排专门的重构迭代"
            )
        
        return recommendations


# 使用示例
def main():
    analyzer = TechnicalDebtAnalyzer()
    
    # 添加一些技术债务项
    analyzer.add_debt_item(TechnicalDebtItem(
        description="订单处理类超过2000行，职责混乱",
        severity="HIGH",
        estimated_fix_hours=40,
        impact_on_velocity=0.15,
        introduced_date="2023-01-15",
        category="CODE_SMELL"
    ))
    
    analyzer.add_debt_item(TechnicalDebtItem(
        description="支付模块缺少单元测试",
        severity="CRITICAL",
        estimated_fix_hours=60,
        impact_on_velocity=0.20,
        introduced_date="2022-06-01",
        category="MISSING_TEST"
    ))
    
    analyzer.add_debt_item(TechnicalDebtItem(
        description="用户认证逻辑在5个地方重复",
        severity="MEDIUM",
        estimated_fix_hours=16,
        impact_on_velocity=0.08,
        introduced_date="2023-03-20",
        category="DUPLICATION"
    ))
    
    # 添加代码度量
    analyzer.add_code_metric(CodeMetric(
        file_path="src/order/OrderProcessor.java",
        lines_of_code=2150,
        cyclomatic_complexity=45,
        number_of_methods=32,
        max_method_length=180,
        coupling_count=18
    ))
    
    analyzer.add_code_metric(CodeMetric(
        file_path="src/payment/PaymentService.java",
        lines_of_code=450,
        cyclomatic_complexity=12,
        number_of_methods=15,
        max_method_length=45,
        coupling_count=8
    ))
    
    # 生成报告
    report = analyzer.generate_report()
    print(json.dumps(report, indent=2))


if __name__ == "__main__":
    main()

"""
设计决策经济分析框架

这个工具帮助团队量化不同设计选择的成本和收益。
"""

from dataclasses import dataclass
from typing import List, Optional
from enum import Enum


class TimeHorizon(Enum):
    SHORT_TERM = "short_term"      # 0-6个月
    MEDIUM_TERM = "medium_term"    # 6-18个月
    LONG_TERM = "long_term"        # 18个月以上


@dataclass
class DesignOption:
    """设计选项"""
    name: str
    description: str
    
    # 成本
    initial_implementation_hours: float
    learning_curve_hours: float     # 团队学习新技术的时间
    infrastructure_cost_monthly: float
    
    # 收益
    development_speed_improvement: float  # 开发速度提升百分比
    maintenance_cost_reduction: float     # 维护成本降低百分比
    scalability_rating: float             # 可扩展性评分 1-10
    
    # 风险
    technical_risk: float          # 技术风险 0-1
    vendor_lock_in_risk: float     # 供应商锁定风险 0-1
    
    def calculate_total_cost(self, months: int, team_size: int, hourly_rate: float) -> float:
        """
        计算指定时间段内的总成本
        
        Args:
            months: 时间段（月）
            team_size: 团队规模
            hourly_rate: 平均小时工资
        """
        # 初始实施成本
        implementation_cost = (self.initial_implementation_hours + self.learning_curve_hours) * hourly_rate
        
        # 月度基础设施成本
        infrastructure_total = self.infrastructure_cost_monthly * months
        
        # 运营成本（考虑效率提升）
        # 假设团队每月工作 160 小时/人
        monthly_team_hours = team_size * 160
        baseline_monthly_cost = monthly_team_hours * hourly_rate
        
        # 由于开发速度提升和维护成本降低，实际运营成本降低
        efficiency_gain = self.development_speed_improvement + self.maintenance_cost_reduction
        adjusted_monthly_cost = baseline_monthly_cost * (1 - efficiency_gain)
        
        # 节省的运营成本
        cost_savings = (baseline_monthly_cost - adjusted_monthly_cost) * months
        
        # 总成本 = 实施成本 + 基础设施成本 - 节省的运营成本
        total_cost = implementation_cost + infrastructure_total - cost_savings
        
        return total_cost
    
    def calculate_risk_adjusted_cost(self, months: int, team_size: int, hourly_rate: float) -> float:
        """计算风险调整后的成本"""
        base_cost = self.calculate_total_cost(months, team_size, hourly_rate)
        
        # 风险系数：风险越高，潜在成本越大
        risk_factor = 1 + (self.technical_risk + self.vendor_lock_in_risk) / 2
        
        return base_cost * risk_factor


class DesignDecisionAnalyzer:
    """设计决策分析器"""
    
    def __init__(self, team_size: int, hourly_rate: float):
        self.team_size = team_size
        self.hourly_rate = hourly_rate
        self.options: List[DesignOption] = []
    
    def add_option(self, option: DesignOption):
        self.options.append(option)
    
    def compare_options(self, time_horizon: TimeHorizon) -> dict:
        """比较不同设计选项"""
        months_map = {
            TimeHorizon.SHORT_TERM: 6,
            TimeHorizon.MEDIUM_TERM: 18,
            TimeHorizon.LONG_TERM: 36
        }
        months = months_map[time_horizon]
        
        results = []
        for option in self.options:
            base_cost = option.calculate_total_cost(months, self.team_size, self.hourly_rate)
            risk_adjusted_cost = option.calculate_risk_adjusted_cost(months, self.team_size, self.hourly_rate)
            
            results.append({
                'option': option.name,
                'description': option.description,
                'base_cost': round(base_cost, 2),
                'risk_adjusted_cost': round(risk_adjusted_cost, 2),
                'development_speed_improvement': f"{option.development_speed_improvement:.0%}",
                'scalability': option.scalability_rating,
                'technical_risk': f"{option.technical_risk:.0%}"
            })
        
        # 按风险调整后成本排序
        results.sort(key=lambda x: x['risk_adjusted_cost'])
        
        return {
            'time_horizon': time_horizon.value,
            'months_analyzed': months,
            'team_parameters': {
                'team_size': self.team_size,
                'hourly_rate': self.hourly_rate
            },
            'options_ranked': results,
            'recommendation': results[0]['option'] if results else None
        }


# 实际案例分析：选择 ORM 框架
def analyze_orm_choices():
    """分析不同的 ORM 选择"""
    
    analyzer = DesignDecisionAnalyzer(team_size=5, hourly_rate=50)
    
    # 选项1：手写 SQL
    analyzer.add_option(DesignOption(
        name="Hand-written SQL",
        description="直接使用 JDBC/原生 SQL，无 ORM",
        initial_implementation_hours=200,
        learning_curve_hours=40,
        infrastructure_cost_monthly=0,
        development_speed_improvement=0,  # 基准
        maintenance_cost_reduction=0,
        scalability_rating=9,
        technical_risk=0.2,
        vendor_lock_in_risk=0
    ))
    
    # 选项2：轻量级 ORM（如 MyBatis）
    analyzer.add_option(DesignOption(
        name="Lightweight ORM (MyBatis)",
        description="使用 MyBatis 进行对象映射",
        initial_implementation_hours=300,
        learning_curve_hours=80,
        infrastructure_cost_monthly=0,
        development_speed_improvement=0.15,
        maintenance_cost_reduction=0.10,
        scalability_rating=8,
        technical_risk=0.15,
        vendor_lock_in_risk=0.1
    ))
    
    # 选项3：全功能 ORM（如 Hibernate/JPA）
    analyzer.add_option(DesignOption(
        name="Full-featured ORM (Hibernate)",
        description="使用 Hibernate/JPA 完整 ORM 解决方案",
        initial_implementation_hours=400,
        learning_curve_hours=120,
        infrastructure_cost_monthly=0,
        development_speed_improvement=0.25,
        maintenance_cost_reduction=0.20,
        scalability_rating=7,
        technical_risk=0.25,
        vendor_lock_in_risk=0.2
    ))
    
    print("\n=== ORM 选择分析 ===\n")
    
    for horizon in TimeHorizon:
        result = analyzer.compare_options(horizon)
        print(f"\n时间范围: {result['time_horizon']} ({result['months_analyzed']}个月)")
        print("-" * 60)
        for opt in result['options_ranked']:
            print(f"\n{opt['option']}:")
            print(f"  基础成本: ${opt['base_cost']:,.2f}")
            print(f"  风险调整后成本: ${opt['risk_adjusted_cost']:,.2f}")
            print(f"  开发速度提升: {opt['development_speed_improvement']}")
            print(f"  可扩展性: {opt['scalability']}/10")
        
        print(f"\n推荐方案: {result['recommendation']}")


if __name__ == "__main__":
    analyze_orm_choices()