Root Organization (管理账户)
├── Security OU
│   ├── Log Archive Account
│   └── Audit Account
├── Production OU
│   ├── Production Workloads Account
│   └── Production Data Account
├── Non-Production OU
│   ├── Development Account
│   ├── Staging Account
│   └── Testing Account
├── Shared Services OU
│   ├── Network Account
│   └── Shared Tools Account
└── Sandbox OU
    └── Developer Sandbox Accounts

class RIDiscountPropagation:
    """预留实例折扣传导计算器"""

    def __init__(self):
        self.ri_pool = []
        self.accounts = []

    def calculate_ri_benefit_distribution(self, ri_purchase, usage_data):
        """
        计算RI折扣在组织内的分配

        优先级规则：
        1. 购买账户优先使用
        2. 同AZ内其他账户
        3. 同Region内其他账户
        4. 大小灵活性匹配
        """

        distribution = {}
        remaining_ri = ri_purchase.copy()

        # Phase 1: 购买账户匹配
        purchasing_account = ri_purchase['account_id']
        if purchasing_account in usage_data:
            matched = self._match_usage(
                remaining_ri, 
                usage_data[purchasing_account]
            )
            distribution[purchasing_account] = matched
            remaining_ri = self._subtract_usage(remaining_ri, matched)

        # Phase 2: 同AZ匹配
        for account_id, usage in usage_data.items():
            if account_id == purchasing_account:
                continue

            if usage['availability_zone'] == ri_purchase['availability_zone']:
                matched = self._match_usage(remaining_ri, usage)
                distribution[account_id] = matched
                remaining_ri = self._subtract_usage(remaining_ri, matched)

        # Phase 3: 同Region匹配（区域RI）
        if ri_purchase['scope'] == 'Region':
            for account_id, usage in usage_data.items():
                if account_id in distribution:
                    continue

                if usage['region'] == ri_purchase['region']:
                    matched = self._match_usage(remaining_ri, usage)
                    distribution[account_id] = matched
                    remaining_ri = self._subtract_usage(remaining_ri, matched)

        # Phase 4: 大小灵活性匹配
        if ri_purchase['instance_size_flexibility']:
            distribution = self._apply_size_flexibility(
                distribution, 
                remaining_ri, 
                usage_data
            )

        return distribution

    def _match_usage(self, ri, usage):
        """匹配使用量与RI"""
        matched_hours = min(ri['hours'], usage['hours'])
        return {
            'instance_type': ri['instance_type'],
            'hours': matched_hours,
            'discount_rate': ri['discount_rate'],
            'savings': matched_hours * usage['hourly_rate'] * ri['discount_rate']
        }

    def _apply_size_flexibility(self, distribution, remaining_ri, usage_data):
        """应用实例大小灵活性"""

        # 标准化因子
        normalization_factors = {
            'nano': 0.25,
            'micro': 0.5,
            'small': 1,
            'medium': 2,
            'large': 4,
            'xlarge': 8,
            '2xlarge': 16,
            '4xlarge': 32,
            '8xlarge': 64,
            '16xlarge': 128,
            '32xlarge': 256
        }

        # 转换为标准化单位
        ri_units = remaining_ri['count'] * normalization_factors[
            remaining_ri['instance_size']
        ]

        # 分配到不同大小的实例
        for account_id, usage in usage_data.items():
            if ri_units <= 0:
                break

            for instance in usage['instances']:
                instance_units = normalization_factors[instance['size']]
                if ri_units >= instance_units:
                    # 分配折扣
                    if account_id not in distribution:
                        distribution[account_id] = []

                    distribution[account_id].append({
                        'instance_id': instance['id'],
                        'discount_applied': True,
                        'units_used': instance_units
                    })

                    ri_units -= instance_units

        return distribution

class SavingsPlansPropagation:
    """Savings Plans折扣传导管理"""

    def __init__(self):
        self.sp_commitments = []
        self.usage_data = {}

    def calculate_sp_coverage(self, commitment, organization_usage):
        """
        计算SP覆盖率和折扣分配

        Compute SP: 最灵活，覆盖EC2、Fargate、Lambda
        EC2 Instance SP: 仅EC2，更高折扣
        """

        coverage_report = {
            'total_commitment': commitment['hourly_commitment'],
            'utilized': 0,
            'waste': 0,
            'coverage_by_account': {},
            'coverage_by_service': {}
        }

        # 按服务类型排序使用量（优先级）
        prioritized_usage = self._prioritize_usage(organization_usage)

        remaining_commitment = commitment['hourly_commitment']

        for usage_item in prioritized_usage:
            if remaining_commitment <= 0:
                break

            # 应用SP折扣
            discounted_amount = min(
                usage_item['on_demand_cost'],
                remaining_commitment
            )

            account_id = usage_item['account_id']
            service = usage_item['service']

            # 记录覆盖情况
            if account_id not in coverage_report['coverage_by_account']:
                coverage_report['coverage_by_account'][account_id] = 0
            coverage_report['coverage_by_account'][account_id] += discounted_amount

            if service not in coverage_report['coverage_by_service']:
                coverage_report['coverage_by_service'][service] = 0
            coverage_report['coverage_by_service'][service] += discounted_amount

            remaining_commitment -= discounted_amount
            coverage_report['utilized'] += discounted_amount

        coverage_report['waste'] = remaining_commitment
        coverage_report['utilization_rate'] = (
            coverage_report['utilized'] / 
            coverage_report['total_commitment'] * 100
        )

        return coverage_report

    def _prioritize_usage(self, usage_data):
        """
        优先级排序：
        1. 生产环境 EC2
        2. 生产环境 Fargate
        3. 非生产环境 EC2
        4. Lambda
        5. 其他
        """

        priority_map = {
            ('production', 'ec2'): 1,
            ('production', 'fargate'): 2,
            ('non-production', 'ec2'): 3,
            ('production', 'lambda'): 4,
            ('non-production', 'fargate'): 5,
            ('non-production', 'lambda'): 6
        }

        prioritized = []
        for item in usage_data:
            env = item.get('environment', 'non-production')
            service = item.get('service', 'other').lower()
            priority = priority_map.get((env, service), 999)

            prioritized.append({
                **item,
                'priority': priority
            })

        return sorted(prioritized, key=lambda x: x['priority'])

class CostAllocationManager:
    """成本分摊管理器"""

    def __init__(self):
        self.required_tags = [
            'Environment',
            'Project',
            'Owner',
            'CostCenter',
            'Application',
            'Team'
        ]
        self.cost_data = {}

    def setup_tag_policies(self, org_client):
        """配置组织级标签策略"""

        tag_policy = {
            "tags": {
                "Environment": {
                    "tag_key": {
                        "@@assign": "Environment"
                    },
                    "tag_value": {
                        "@@assign": [
                            "Production",
                            "Staging",
                            "Development",
                            "Testing",
                            "Sandbox"
                        ]
                    },
                    "enforced_for": {
                        "@@assign": [
                            "ec2:instance",
                            "ec2:volume",
                            "rds:db",
                            "s3:bucket"
                        ]
                    }
                },
                "CostCenter": {
                    "tag_key": {
                        "@@assign": "CostCenter"
                    },
                    "tag_value": {
                        "@@assign": [
                            "Engineering",
                            "Marketing",
                            "Sales",
                            "Operations",
                            "Finance"
                        ]
                    }
                },
                "Project": {
                    "tag_key": {
                        "@@assign": "Project"
                    },
                    "tag_value": {
                        "@@assert_exists": True
                    }
                }
            }
        }

        response = org_client.create_policy(
            Content=json.dumps(tag_policy),
            Description='Mandatory tagging policy for cost allocation',
            Name='CostAllocationTagPolicy',
            Type='TAG_POLICY'
        )

        return response['Policy']['PolicyId']

    def calculate_shared_costs_allocation(self, shared_costs, allocation_rules):
        """
        计算共享成本分摊

        分摊方法：
        1. 直接分摊：基于实际使用量
        2. 比例分摊：基于总成本占比
        3. 固定分摊：预定义的分摊比例
        """

        allocation_result = {}

        for cost_item in shared_costs:
            service = cost_item['service']
            amount = cost_item['amount']

            if service in allocation_rules:
                rule = allocation_rules[service]

                if rule['method'] == 'usage_based':
                    # 基于使用量分摊
                    allocation = self._allocate_by_usage(
                        amount,
                        rule['usage_metrics']
                    )

                elif rule['method'] == 'proportional':
                    # 按比例分摊
                    allocation = self._allocate_proportionally(
                        amount,
                        rule['proportions']
                    )

                elif rule['method'] == 'fixed':
                    # 固定比例分摊
                    allocation = self._allocate_fixed(
                        amount,
                        rule['fixed_percentages']
                    )

                else:
                    # 默认平均分摊
                    allocation = self._allocate_equally(
                        amount,
                        rule['targets']
                    )

                for target, allocated_amount in allocation.items():
                    if target not in allocation_result:
                        allocation_result[target] = {}

                    if service not in allocation_result[target]:
                        allocation_result[target][service] = 0

                    allocation_result[target][service] += allocated_amount

        return allocation_result

    def _allocate_by_usage(self, amount, usage_metrics):
        """基于使用量的分摊"""
        total_usage = sum(usage_metrics.values())
        allocation = {}

        for entity, usage in usage_metrics.items():
            allocation[entity] = (usage / total_usage) * amount

        return allocation

    def generate_chargeback_report(self, period):
        """生成成本回收报告"""

        report = {
            'period': period,
            'generated_at': datetime.now().isoformat(),
            'departments': {},
            'projects': {},
            'summary': {
                'total_costs': 0,
                'allocated_costs': 0,
                'unallocated_costs': 0
            }
        }

        # 获取成本和使用数据
        ce_client = boto3.client('ce')

        response = ce_client.get_cost_and_usage_with_resources(
            TimePeriod={
                'Start': period['start'],
                'End': period['end']
            },
            Granularity='MONTHLY',
            Metrics=['UnblendedCost', 'UsageQuantity'],
            GroupBy=[
                {'Type': 'TAG', 'Key': 'CostCenter'},
                {'Type': 'TAG', 'Key': 'Project'}
            ]
        )

        # 处理成本数据
        for result in response['ResultsByTime']:
            for group in result['Groups']:
                tags = {
                    dim['Key']: dim['Value'] 
                    for dim in group['Keys']
                }

                cost = float(group['Metrics']['UnblendedCost']['Amount'])

                # 按部门汇总
                cost_center = tags.get('TAG$CostCenter', 'Untagged')
                if cost_center not in report['departments']:
                    report['departments'][cost_center] = {
                        'total': 0,
                        'projects': {}
                    }

                report['departments'][cost_center]['total'] += cost

                # 按项目汇总
                project = tags.get('TAG$Project', 'Untagged')
                if project not in report['projects']:
                    report['projects'][project] = {
                        'total': 0,
                        'departments': {}
                    }

                report['projects'][project]['total'] += cost

                # 交叉引用
                report['departments'][cost_center]['projects'][project] = cost
                report['projects'][project]['departments'][cost_center] = cost

                # 更新汇总
                report['summary']['total_costs'] += cost
                if cost_center != 'Untagged' and project != 'Untagged':
                    report['summary']['allocated_costs'] += cost
                else:
                    report['summary']['unallocated_costs'] += cost

        return report

class BillingReconciliation:
    """账单对账自动化系统"""

    def __init__(self, org_id):
        self.org_id = org_id
        self.ce_client = boto3.client('ce')
        self.org_client = boto3.client('organizations')
        self.s3_client = boto3.client('s3')

    def perform_monthly_reconciliation(self, year, month):
        """执行月度对账"""

        reconciliation_report = {
            'period': f"{year}-{month:02d}",
            'status': 'in_progress',
            'discrepancies': [],
            'validations': {},
            'recommendations': []
        }

        # Step 1: 获取CUR数据
        cur_data = self._fetch_cur_data(year, month)

        # Step 2: 获取Cost Explorer数据
        ce_data = self._fetch_cost_explorer_data(year, month)

        # Step 3: 获取各账户直接查询数据
        account_data = self._fetch_account_level_data(year, month)

        # Step 4: 交叉验证
        validations = self._cross_validate(cur_data, ce_data, account_data)
        reconciliation_report['validations'] = validations

        # Step 5: 识别异常
        discrepancies = self._identify_discrepancies(validations)
        reconciliation_report['discrepancies'] = discrepancies

        # Step 6: 生成建议
        recommendations = self._generate_recommendations(discrepancies)
        reconciliation_report['recommendations'] = recommendations

        # Step 7: 折扣验证
        discount_validation = self._validate_discounts(cur_data)
        reconciliation_report['discount_validation'] = discount_validation

        reconciliation_report['status'] = 'completed'
        reconciliation_report['completed_at'] = datetime.now().isoformat()

        return reconciliation_report

    def _fetch_cur_data(self, year, month):
        """从S3获取CUR数据"""

        # CUR文件路径模式
        bucket = 'your-cur-bucket'
        prefix = f"cur-reports/{year}/{month:02d}/"

        # 获取Parquet文件
        response = self.s3_client.list_objects_v2(
            Bucket=bucket,
            Prefix=prefix
        )

        cur_data = {
            'total_cost': 0,
            'by_account': {},
            'by_service': {},
            'by_usage_type': {},
            'discounts': {
                'ri_volume_discount': 0,
                'sp_discount': 0,
                'enterprise_discount': 0
            }
        }

        # 使用Athena查询CUR数据
        athena_client = boto3.client('athena')

        query = f"""
        SELECT 
            line_item_usage_account_id,
            product_product_name,
            line_item_usage_type,
            SUM(line_item_unblended_cost) as total_cost,
            SUM(reservation_effective_cost) as ri_cost,
            SUM(savings_plan_savings_plan_effective_cost) as sp_cost,
            SUM(pricing_public_on_demand_cost - line_item_unblended_cost) as discount
        FROM cur_database.cur_table
        WHERE 
            year = '{year}'
            AND month = '{month}'
        GROUP BY 
            line_item_usage_account_id,
            product_product_name,
            line_item_usage_type
        """

        # 执行查询并处理结果
        # ... (查询执行代码)

        return cur_data

    def _validate_discounts(self, cur_data):
        """验证折扣是否正确应用"""

        validation_results = {
            'ri_validation': {},
            'sp_validation': {},
            'volume_discount_validation': {},
            'issues_found': []
        }

        # 验证RI折扣
        ri_purchases = self._get_ri_purchases()
        ri_usage = cur_data.get('ri_usage', {})

        for ri in ri_purchases:
            expected_coverage = ri['instance_count'] * ri['hours_in_month']
            actual_coverage = ri_usage.get(ri['reservation_id'], 0)

            utilization = (actual_coverage / expected_coverage * 100) if expected_coverage > 0 else 0

            validation_results['ri_validation'][ri['reservation_id']] = {
                'expected_hours': expected_coverage,
                'actual_hours': actual_coverage,
                'utilization_rate': utilization,
                'status': 'optimal' if utilization > 95 else 'suboptimal'
            }

            if utilization < 80:
                validation_results['issues_found'].append({
                    'type': 'low_ri_utilization',
                    'reservation_id': ri['reservation_id'],
                    'utilization': utilization,
                    'potential_waste': ri['hourly_rate'] * (expected_coverage - actual_coverage)
                })

        # 验证SP折扣
        sp_commitments = self._get_sp_commitments()
        sp_usage = cur_data.get('sp_usage', {})

        for sp in sp_commitments:
            committed_spend = sp['hourly_commitment'] * 730  # 月度小时数
            actual_spend = sp_usage.get(sp['savings_plan_id'], 0)

            utilization = (actual_spend / committed_spend * 100) if committed_spend > 0 else 0

            validation_results['sp_validation'][sp['savings_plan_id']] = {
                'committed_spend': committed_spend,
                'actual_spend': actual_spend,
                'utilization_rate': utilization,
                'status': 'optimal' if utilization > 95 else 'suboptimal'
            }

        return validation_results

    def _generate_recommendations(self, discrepancies):
        """基于对账结果生成优化建议"""

        recommendations = []

        for discrepancy in discrepancies:
            if discrepancy['type'] == 'untagged_resources':
                recommendations.append({
                    'priority': 'high',
                    'category': 'tagging',
                    'description': f"发现 {discrepancy['count']} 个未标记资源",
                    'action': '实施强制标签策略',
                    'potential_impact': '改善成本可见性和分摊准确性',
                    'implementation': """
                    aws organizations create-policy \\
                        --content file://tag-policy.json \\
                        --description "Enforce required tags" \\
                        --name RequiredTagsPolicy \\
                        --type TAG_POLICY
                    """
                })

            elif discrepancy['type'] == 'ri_underutilization':
                recommendations.append({
                    'priority': 'high',
                    'category': 'reserved_instances',
                    'description': f"RI利用率仅 {discrepancy['utilization']:.1f}%",
                    'action': '考虑转换为Savings Plans或调整RI配置',
                    'potential_savings': f"${discrepancy['potential_waste']:.2f}/月",
                    'implementation': '使用RI交换或修改功能优化配置'
                })

            elif discrepancy['type'] == 'cost_anomaly':
                recommendations.append({
                    'priority': 'medium',
                    'category': 'cost_anomaly',
                    'description': f"检测到异常成本增长 {discrepancy['increase_percentage']:.1f}%",
                    'action': '调查成本异常原因',
                    'affected_service': discrepancy['service'],
                    'investigation_query': f"""
                    SELECT 
                        line_item_resource_id,
                        SUM(line_item_unblended_cost) as cost
                    FROM cur_table
                    WHERE 
                        product_product_name = '{discrepancy['service']}'
                        AND line_item_usage_account_id = '{discrepancy['account_id']}'
                    GROUP BY line_item_resource_id
                    ORDER BY cost DESC
                    LIMIT 10
                    """
                })

        return recommendations

class EnterpriseOrgOptimization:
    """大型企业组织优化实施"""

    def __init__(self):
        self.accounts = []
        self.ous = []
        self.policies = []

    def implement_enterprise_structure(self):
        """实施企业级组织结构"""

        # 1. 创建组织单元层级
        ou_structure = {
            'Root': {
                'Security': ['LogArchive', 'Audit', 'SecurityTools'],
                'Production': {
                    'CustomerFacing': ['WebApp', 'MobileAPI', 'CDN'],
                    'Backend': ['Database', 'Analytics', 'ML'],
                    'Integration': ['B2B', 'Partners', 'ThirdParty']
                },
                'NonProduction': {
                    'Development': ['Dev1', 'Dev2', 'Dev3'],
                    'Testing': ['QA', 'Performance', 'Security'],
                    'Staging': ['PreProd', 'UAT']
                },
                'SharedServices': {
                    'Networking': ['Transit', 'DirectConnect', 'VPN'],
                    'Tools': ['CI/CD', 'Monitoring', 'Backup'],
                    'Data': ['DataLake', 'Warehouse', 'Archive']
                },
                'Sandbox': ['Sandbox1', 'Sandbox2', 'Sandbox3']
            }
        }

        # 2. 配置SCP策略
        scp_policies = [
            {
                'name': 'DenyExpensiveInstances',
                'description': 'Prevent launching expensive instance types in non-prod',
                'targets': ['NonProduction', 'Sandbox'],
                'policy': {
                    "Version": "2012-10-17",
                    "Statement": [{
                        "Effect": "Deny",
                        "Action": "ec2:RunInstances",
                        "Resource": "arn:aws:ec2:*:*:instance/*",
                        "Condition": {
                            "StringEquals": {
                                "ec2:InstanceType": [
                                    "p3.16xlarge",
                                    "p3dn.24xlarge",
                                    "x1e.32xlarge"
                                ]
                            }
                        }
                    }]
                }
            },
            {
                'name': 'RequireTagsOnCreation',
                'description': 'Enforce tagging on resource creation',
                'targets': ['Root'],
                'policy': {
                    "Version": "2012-10-17",
                    "Statement": [{
                        "Effect": "Deny",
                        "Action": [
                            "ec2:RunInstances",
                            "rds:CreateDBInstance"
                        ],
                        "Resource": "*",
                        "Condition": {
                            "Null": {
                                "aws:RequestTag/Environment": "true",
                                "aws:RequestTag/CostCenter": "true"
                            }
                        }
                    }]
                }
            }
        ]

        # 3. 设置预算和告警
        budget_config = {
            'organization_budget': {
                'amount': 2000000,
                'currency': 'USD',
                'time_unit': 'MONTHLY',
                'alert_thresholds': [80, 90, 100, 110]
            },
            'ou_budgets': {
                'Production': 1200000,
                'NonProduction': 300000,
                'SharedServices': 400000,
                'Sandbox': 100000
            },
            'account_budgets': {
                'default_dev': 10000,
                'default_prod': 50000,
                'default_sandbox': 1000
            }
        }

        return {
            'structure': ou_structure,
            'policies': scp_policies,
            'budgets': budget_config
        }

class CostAnomalyDetector:
    """成本异常自动检测系统"""

    def __init__(self, threshold_percentage=20):
        self.threshold = threshold_percentage
        self.ce_client = boto3.client('ce')
        self.sns_client = boto3.client('sns')

    def detect_anomalies(self, lookback_days=30):
        """检测成本异常"""

        end_date = datetime.now().date()
        start_date = end_date - timedelta(days=lookback_days)

        # 获取历史成本数据
        response = self.ce_client.get_cost_and_usage(
            TimePeriod={
                'Start': start_date.isoformat(),
                'End': end_date.isoformat()
            },
            Granularity='DAILY',
            Metrics=['UnblendedCost'],
            GroupBy=[
                {'Type': 'DIMENSION', 'Key': 'SERVICE'},
                {'Type': 'DIMENSION', 'Key': 'LINKED_ACCOUNT'}
            ]
        )

        anomalies = []

        # 分析每个服务和账户组合
        for result in response['ResultsByTime']:
            date = result['TimePeriod']['Start']

            for group in result['Groups']:
                service = group['Keys'][0]
                account = group['Keys'][1]
                cost = float(group['Metrics']['UnblendedCost']['Amount'])

                # 获取历史平均值
                historical_avg = self._get_historical_average(
                    service, account, date
                )

                if historical_avg > 0:
                    variance_percentage = (
                        (cost - historical_avg) / historical_avg * 100
                    )

                    if abs(variance_percentage) > self.threshold:
                        anomalies.append({
                            'date': date,
                            'service': service,
                            'account': account,
                            'cost': cost,
                            'historical_avg': historical_avg,
                            'variance_percentage': variance_percentage,
                            'severity': self._calculate_severity(variance_percentage)
                        })

        # 发送告警
        if anomalies:
            self._send_alerts(anomalies)

        return anomalies

    def _calculate_severity(self, variance_percentage):
        """计算异常严重程度"""

        abs_variance = abs(variance_percentage)

        if abs_variance < 30:
            return 'low'
        elif abs_variance < 50:
            return 'medium'
        elif abs_variance < 100:
            return 'high'
        else:
            return 'critical'

    def _send_alerts(self, anomalies):
        """发送异常告警"""

        critical_anomalies = [
            a for a in anomalies 
            if a['severity'] in ['high', 'critical']
        ]

        if critical_anomalies:
            message = "Critical Cost Anomalies Detected:\n\n"

            for anomaly in critical_anomalies[:10]:  # 最多显示10个
                message += f"""
                Service: {anomaly['service']}
                Account: {anomaly['account']}
                Date: {anomaly['date']}
                Cost: ${anomaly['cost']:.2f}
                Expected: ${anomaly['historical_avg']:.2f}
                Variance: {anomaly['variance_percentage']:.1f}%
                Severity: {anomaly['severity']}
                ---
                """

            self.sns_client.publish(
                TopicArn='arn:aws:sns:us-east-1:xxx:cost-alerts',
                Subject='🚨 Critical Cost Anomaly Alert',
                Message=message
            )

class AutomatedCostReporting:
    """自动化成本报告系统"""

    def __init__(self):
        self.ce_client = boto3.client('ce')
        self.s3_client = boto3.client('s3')
        self.ses_client = boto3.client('ses')

    def generate_executive_report(self, month, year):
        """生成高管月度报告"""

        report = {
            'period': f"{year}-{month:02d}",
            'executive_summary': {},
            'department_breakdown': {},
            'project_costs': {},
            'optimization_opportunities': [],
            'forecast': {}
        }

        # 1. 执行摘要
        report['executive_summary'] = self._generate_executive_summary(month, year)

        # 2. 部门成本分解
        report['department_breakdown'] = self._get_department_costs(month, year)

        # 3. 项目成本
        report['project_costs'] = self._get_project_costs(month, year)

        # 4. 优化机会
        report['optimization_opportunities'] = self._identify_optimizations()

        # 5. 成本预测
        report['forecast'] = self._generate_forecast()

        # 生成HTML报告
        html_report = self._generate_html_report(report)

        # 保存到S3
        report_key = f"cost-reports/{year}/{month:02d}/executive-report.html"
        self.s3_client.put_object(
            Bucket='cost-reports-bucket',
            Key=report_key,
            Body=html_report,
            ContentType='text/html'
        )

        # 发送邮件
        self._send_report_email(html_report, report)

        return report

    def _generate_html_report(self, report):
        """生成HTML格式报告"""

        html = """
        <!DOCTYPE html>
        <html>
        <head>
            <title>AWS Cost Report - {period}</title>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 20px; }}
                .header {{ background: #232f3e; color: white; padding: 20px; }}
                .summary {{ background: #f0f0f0; padding: 15px; margin: 20px 0; }}
                .metric {{ display: inline-block; margin: 10px; padding: 10px; background: white; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }}
                .increase {{ color: red; }}
                .decrease {{ color: green; }}
                .chart {{ margin: 20px 0; }}
            </style>
        </head>
        <body>
            <div class="header">
                <h1>AWS Organizations 成本报告</h1>
                <h2>{period}</h2>
            </div>

            <div class="summary">
                <h2>执行摘要</h2>
                <div class="metric">
                    <h3>总成本</h3>
                    <p>${total_cost:,.2f}</p>
                    <p class="{cost_trend_class}">{cost_trend:+.1f}% vs 上月</p>
                </div>
                <div class="metric">
                    <h3>节省金额</h3>
                    <p>${total_savings:,.2f}</p>
                </div>
                <div class="metric">
                    <h3>RI覆盖率</h3>
                    <p>{ri_coverage:.1f}%</p>
                </div>
                <div class="metric">
                    <h3>SP覆盖率</h3>
                    <p>{sp_coverage:.1f}%</p>
                </div>
            </div>

            <div class="department-costs">
                <h2>部门成本明细</h2>
                <table>
                    <tr>
                        <th>部门</th>
                        <th>本月成本</th>
                        <th>预算</th>
                        <th>使用率</th>
                        <th>环比</th>
                    </tr>
                    {department_rows}
                </table>
            </div>

            <div class="top-services">
                <h2>Top 10 服务成本</h2>
                <table>
                    <tr>
                        <th>服务</th>
                        <th>成本</th>
                        <th>占比</th>
                        <th>环比</th>
                    </tr>
                    {service_rows}
                </table>
            </div>

            <div class="optimization">
                <h2>优化建议</h2>
                <ul>
                    {optimization_items}
                </ul>
            </div>

            <div class="forecast">
                <h2>成本预测</h2>
                <p>基于当前趋势，预计下月成本: <strong>${forecast_amount:,.2f}</strong></p>
                <p>年度预计总成本: <strong>${annual_forecast:,.2f}</strong></p>
            </div>
        </body>
        </html>
        """.format(
            period=report['period'],
            total_cost=report['executive_summary']['total_cost'],
            cost_trend=report['executive_summary']['cost_trend'],
            cost_trend_class='increase' if report['executive_summary']['cost_trend'] > 0 else 'decrease',
            total_savings=report['executive_summary']['total_savings'],
            ri_coverage=report['executive_summary']['ri_coverage'],
            sp_coverage=report['executive_summary']['sp_coverage'],
            department_rows=self._format_department_rows(report['department_breakdown']),
            service_rows=self._format_service_rows(report['executive_summary']['top_services']),
            optimization_items=self._format_optimization_items(report['optimization_opportunities']),
            forecast_amount=report['forecast']['next_month'],
            annual_forecast=report['forecast']['annual_projection']
        )

        return html