COST07-BP02 - Choose regions based on cost

import boto3
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
import json
import requests
from geopy.distance import geodesic

@dataclass
class RegionalPricing:
    region: str
    service: str
    instance_type: str
    pricing_model: str
    hourly_rate: float
    data_transfer_in: float
    data_transfer_out: float
    storage_cost_per_gb: float

@dataclass
class RegionalRequirement:
    compliance_regions: List[str]
    max_latency_ms: float
    data_residency_required: bool
    disaster_recovery_regions: List[str]
    minimum_availability_zones: int

@dataclass
class RegionalRecommendation:
    primary_region: str
    secondary_regions: List[str]
    estimated_monthly_savings: float
    performance_impact: str
    compliance_status: str
    implementation_complexity: str
    rationale: str

class RegionalCostOptimizer:
    def __init__(self):
        self.pricing_client = boto3.client('pricing', region_name='us-east-1')
        self.ec2 = boto3.client('ec2')
        self.ce_client = boto3.client('ce')
        
        # AWS regions with their characteristics
        self.aws_regions = {
            'us-east-1': {'name': 'N. Virginia', 'cost_tier': 'low', 'latency_zone': 'us-east'},
            'us-east-2': {'name': 'Ohio', 'cost_tier': 'low', 'latency_zone': 'us-east'},
            'us-west-1': {'name': 'N. California', 'cost_tier': 'medium', 'latency_zone': 'us-west'},
            'us-west-2': {'name': 'Oregon', 'cost_tier': 'low', 'latency_zone': 'us-west'},
            'eu-west-1': {'name': 'Ireland', 'cost_tier': 'medium', 'latency_zone': 'eu-west'},
            'eu-central-1': {'name': 'Frankfurt', 'cost_tier': 'medium', 'latency_zone': 'eu-central'},
            'ap-southeast-1': {'name': 'Singapore', 'cost_tier': 'high', 'latency_zone': 'ap-southeast'},
            'ap-northeast-1': {'name': 'Tokyo', 'cost_tier': 'high', 'latency_zone': 'ap-northeast'}
        }
        
        # Regional pricing multipliers (relative to us-east-1)
        self.regional_multipliers = {
            'us-east-1': 1.0,
            'us-east-2': 1.0,
            'us-west-1': 1.15,
            'us-west-2': 1.05,
            'eu-west-1': 1.10,
            'eu-central-1': 1.12,
            'ap-southeast-1': 1.20,
            'ap-northeast-1': 1.25
        }
    
    def analyze_regional_costs(self, workload_requirements: Dict, 
                             regional_requirements: RegionalRequirement) -> Dict:
        """Analyze costs across regions for a workload"""
        
        analysis_results = {
            'analysis_date': datetime.now().isoformat(),
            'workload_requirements': workload_requirements,
            'regional_analysis': {},
            'recommendations': [],
            'cost_comparison': {},
            'compliance_analysis': {}
        }
        
        # Get eligible regions based on requirements
        eligible_regions = self.get_eligible_regions(regional_requirements)
        
        # Analyze costs for each eligible region
        for region in eligible_regions:
            regional_analysis = self.analyze_single_region(region, workload_requirements)
            analysis_results['regional_analysis'][region] = regional_analysis
        
        # Generate cost comparison
        analysis_results['cost_comparison'] = self.create_cost_comparison(
            analysis_results['regional_analysis']
        )
        
        # Generate recommendations
        analysis_results['recommendations'] = self.generate_regional_recommendations(
            analysis_results['regional_analysis'], regional_requirements
        )
        
        # Compliance analysis
        analysis_results['compliance_analysis'] = self.analyze_compliance_implications(
            analysis_results['recommendations'], regional_requirements
        )
        
        return analysis_results
    
    def get_eligible_regions(self, requirements: RegionalRequirement) -> List[str]:
        """Get list of regions eligible based on requirements"""
        
        eligible_regions = list(self.aws_regions.keys())
        
        # Filter by compliance requirements
        if requirements.compliance_regions:
            eligible_regions = [r for r in eligible_regions if r in requirements.compliance_regions]
        
        # Filter by data residency requirements
        if requirements.data_residency_required:
            # This would implement specific data residency logic
            pass
        
        return eligible_regions
    
    def analyze_single_region(self, region: str, workload_requirements: Dict) -> Dict:
        """Analyze costs for a single region"""
        
        regional_analysis = {
            'region': region,
            'region_name': self.aws_regions[region]['name'],
            'cost_tier': self.aws_regions[region]['cost_tier'],
            'service_costs': {},
            'total_monthly_cost': 0,
            'data_transfer_costs': {},
            'availability_zones': self.get_availability_zones(region),
            'service_availability': self.check_service_availability(region, workload_requirements)
        }
        
        # Calculate compute costs
        if 'compute' in workload_requirements:
            compute_cost = self.calculate_regional_compute_cost(
                region, workload_requirements['compute']
            )
            regional_analysis['service_costs']['compute'] = compute_cost
            regional_analysis['total_monthly_cost'] += compute_cost
        
        # Calculate storage costs
        if 'storage' in workload_requirements:
            storage_cost = self.calculate_regional_storage_cost(
                region, workload_requirements['storage']
            )
            regional_analysis['service_costs']['storage'] = storage_cost
            regional_analysis['total_monthly_cost'] += storage_cost
        
        # Calculate data transfer costs
        if 'data_transfer' in workload_requirements:
            transfer_cost = self.calculate_regional_data_transfer_cost(
                region, workload_requirements['data_transfer']
            )
            regional_analysis['data_transfer_costs'] = transfer_cost
            regional_analysis['total_monthly_cost'] += sum(transfer_cost.values())
        
        # Calculate network costs
        if 'networking' in workload_requirements:
            network_cost = self.calculate_regional_network_cost(
                region, workload_requirements['networking']
            )
            regional_analysis['service_costs']['networking'] = network_cost
            regional_analysis['total_monthly_cost'] += network_cost
        
        return regional_analysis
    
    def calculate_regional_compute_cost(self, region: str, compute_requirements: Dict) -> float:
        """Calculate compute costs for a region"""
        
        total_cost = 0
        multiplier = self.regional_multipliers.get(region, 1.0)
        
        for instance_config in compute_requirements.get('instances', []):
            instance_type = instance_config['type']
            quantity = instance_config['quantity']
            hours_per_month = instance_config.get('hours_per_month', 730)
            
            # Get base pricing (us-east-1 pricing)
            base_hourly_rate = self.get_base_instance_pricing(instance_type)
            
            # Apply regional multiplier
            regional_hourly_rate = base_hourly_rate * multiplier
            
            # Calculate monthly cost
            monthly_cost = regional_hourly_rate * quantity * hours_per_month
            total_cost += monthly_cost
        
        return total_cost
    
    def calculate_regional_storage_cost(self, region: str, storage_requirements: Dict) -> float:
        """Calculate storage costs for a region"""
        
        total_cost = 0
        multiplier = self.regional_multipliers.get(region, 1.0)
        
        for storage_config in storage_requirements.get('volumes', []):
            storage_type = storage_config['type']
            size_gb = storage_config['size_gb']
            
            # Get base storage pricing
            base_gb_rate = self.get_base_storage_pricing(storage_type)
            
            # Apply regional multiplier
            regional_gb_rate = base_gb_rate * multiplier
            
            # Calculate monthly cost
            monthly_cost = regional_gb_rate * size_gb
            total_cost += monthly_cost
        
        return total_cost
    
    def calculate_regional_data_transfer_cost(self, region: str, transfer_requirements: Dict) -> Dict:
        """Calculate data transfer costs for a region"""
        
        transfer_costs = {
            'internet_egress': 0,
            'inter_region': 0,
            'cloudfront': 0
        }
        
        # Internet egress costs
        if 'internet_egress_gb' in transfer_requirements:
            egress_gb = transfer_requirements['internet_egress_gb']
            egress_rate = self.get_internet_egress_rate(region)
            transfer_costs['internet_egress'] = egress_gb * egress_rate
        
        # Inter-region transfer costs
        if 'inter_region_transfer' in transfer_requirements:
            for destination_region, gb_transferred in transfer_requirements['inter_region_transfer'].items():
                transfer_rate = self.get_inter_region_transfer_rate(region, destination_region)
                transfer_costs['inter_region'] += gb_transferred * transfer_rate
        
        # CloudFront costs
        if 'cloudfront_gb' in transfer_requirements:
            cloudfront_gb = transfer_requirements['cloudfront_gb']
            cloudfront_rate = self.get_cloudfront_rate(region)
            transfer_costs['cloudfront'] = cloudfront_gb * cloudfront_rate
        
        return transfer_costs
    
    def generate_regional_recommendations(self, regional_analysis: Dict, 
                                        requirements: RegionalRequirement) -> List[RegionalRecommendation]:
        """Generate regional deployment recommendations"""
        
        recommendations = []
        
        # Sort regions by total cost
        sorted_regions = sorted(
            regional_analysis.items(),
            key=lambda x: x[1]['total_monthly_cost']
        )
        
        if len(sorted_regions) < 2:
            return recommendations
        
        cheapest_region = sorted_regions[0]
        current_region = sorted_regions[-1]  # Assume most expensive is current
        
        # Calculate potential savings
        monthly_savings = current_region[1]['total_monthly_cost'] - cheapest_region[1]['total_monthly_cost']
        
        if monthly_savings > 100:  # Only recommend if savings > $100/month
            
            # Assess performance impact
            performance_impact = self.assess_performance_impact(
                current_region[0], cheapest_region[0], requirements
            )
            
            # Check compliance
            compliance_status = self.check_compliance_status(
                cheapest_region[0], requirements
            )
            
            recommendation = RegionalRecommendation(
                primary_region=cheapest_region[0],
                secondary_regions=self.suggest_secondary_regions(
                    cheapest_region[0], sorted_regions, requirements
                ),
                estimated_monthly_savings=monthly_savings,
                performance_impact=performance_impact,
                compliance_status=compliance_status,
                implementation_complexity=self.assess_implementation_complexity(
                    current_region[0], cheapest_region[0]
                ),
                rationale=f"Moving from {current_region[0]} to {cheapest_region[0]} could save ${monthly_savings:.2f}/month"
            )
            
            recommendations.append(recommendation)
        
        # Multi-region optimization recommendations
        multi_region_rec = self.generate_multi_region_recommendation(
            regional_analysis, requirements
        )
        if multi_region_rec:
            recommendations.append(multi_region_rec)
        
        return recommendations
    
    def create_multi_region_cost_model(self, workload_requirements: Dict) -> Dict:
        """Create comprehensive multi-region cost model"""
        
        cost_model = {
            'model_date': datetime.now().isoformat(),
            'scenarios': {},
            'optimization_strategies': {},
            'recommendations': []
        }
        
        # Single region scenarios
        for region in self.aws_regions.keys():
            scenario_name = f"single_region_{region}"
            scenario_cost = self.calculate_scenario_cost(region, workload_requirements)
            cost_model['scenarios'][scenario_name] = scenario_cost
        
        # Multi-region scenarios
        multi_region_scenarios = [
            ['us-east-1', 'us-west-2'],  # US multi-region
            ['eu-west-1', 'eu-central-1'],  # EU multi-region
            ['us-east-1', 'eu-west-1', 'ap-southeast-1']  # Global multi-region
        ]
        
        for regions in multi_region_scenarios:
            scenario_name = f"multi_region_{'_'.join(regions)}"
            scenario_cost = self.calculate_multi_region_scenario_cost(regions, workload_requirements)
            cost_model['scenarios'][scenario_name] = scenario_cost
        
        # Optimization strategies
        cost_model['optimization_strategies'] = {
            'primary_region_optimization': self.analyze_primary_region_optimization(cost_model['scenarios']),
            'data_locality_optimization': self.analyze_data_locality_optimization(workload_requirements),
            'disaster_recovery_optimization': self.analyze_dr_optimization(cost_model['scenarios']),
            'content_delivery_optimization': self.analyze_cdn_optimization(workload_requirements)
        }
        
        return cost_model
    
    def implement_regional_cost_monitoring(self) -> Dict:
        """Implement monitoring for regional cost optimization"""
        
        monitoring_config = {
            'cloudwatch_dashboards': self.create_regional_cost_dashboards(),
            'cost_alerts': self.create_regional_cost_alerts(),
            'automated_reports': self.create_regional_cost_reports(),
            'optimization_triggers': self.create_optimization_triggers()
        }
        
        return monitoring_config
    
    def create_regional_cost_dashboards(self) -> List[Dict]:
        """Create CloudWatch dashboards for regional cost monitoring"""
        
        dashboards = [
            {
                'dashboard_name': 'Regional Cost Comparison',
                'widgets': [
                    {
                        'type': 'metric',
                        'title': 'Cost by Region',
                        'metrics': [
                            ['AWS/Billing', 'EstimatedCharges', 'Region', region]
                            for region in self.aws_regions.keys()
                        ],
                        'period': 86400,
                        'stat': 'Maximum'
                    },
                    {
                        'type': 'metric',
                        'title': 'Data Transfer Costs by Region',
                        'metrics': [
                            ['AWS/Billing', 'EstimatedCharges', 'ServiceName', 'AmazonCloudFront', 'Region', region]
                            for region in self.aws_regions.keys()
                        ]
                    }
                ]
            },
            {
                'dashboard_name': 'Regional Performance vs Cost',
                'widgets': [
                    {
                        'type': 'metric',
                        'title': 'Average Response Time by Region',
                        'metrics': [
                            ['AWS/ApplicationELB', 'TargetResponseTime', 'LoadBalancer', 'app-lb', 'Region', region]
                            for region in self.aws_regions.keys()
                        ]
                    },
                    {
                        'type': 'metric',
                        'title': 'Cost per Request by Region',
                        'expression': 'cost / requests',
                        'metrics': [
                            ['AWS/Billing', 'EstimatedCharges', 'Region', region, {'id': f'cost_{region}'}]
                            for region in self.aws_regions.keys()
                        ]
                    }
                ]
            }
        ]
        
        return dashboards
    
    def get_base_instance_pricing(self, instance_type: str) -> float:
        """Get base instance pricing for us-east-1"""
        
        # Sample pricing data - in practice, this would call the Pricing API
        base_pricing = {
            't3.micro': 0.0104,
            't3.small': 0.0208,
            't3.medium': 0.0416,
            't3.large': 0.0832,
            'm5.large': 0.096,
            'm5.xlarge': 0.192,
            'c5.large': 0.085,
            'c5.xlarge': 0.17,
            'r5.large': 0.126,
            'r5.xlarge': 0.252
        }
        
        return base_pricing.get(instance_type, 0.1)
    
    def get_base_storage_pricing(self, storage_type: str) -> float:
        """Get base storage pricing per GB for us-east-1"""
        
        base_storage_pricing = {
            'gp3': 0.08,
            'gp2': 0.10,
            'io1': 0.125,
            'io2': 0.125,
            'st1': 0.045,
            'sc1': 0.025,
            's3_standard': 0.023,
            's3_ia': 0.0125,
            's3_glacier': 0.004
        }
        
        return base_storage_pricing.get(storage_type, 0.08)
    
    def assess_performance_impact(self, current_region: str, target_region: str, 
                                requirements: RegionalRequirement) -> str:
        """Assess performance impact of region change"""
        
        # This would implement latency analysis based on user locations
        # For demonstration, using simplified logic
        
        if requirements.max_latency_ms < 50:
            return "High - Latency requirements may not be met"
        elif requirements.max_latency_ms < 100:
            return "Medium - Some latency increase expected"
        else:
            return "Low - Minimal performance impact expected"

Regional_Cost_Analysis:
  analysis_id: "REGIONAL-COST-2024-001"
  analysis_date: "2024-01-15"
  workload: "web-application"
  
  requirements:
    compliance_regions: ["us-east-1", "us-west-2", "eu-west-1"]
    max_latency_ms: 100
    data_residency_required: false
    disaster_recovery_required: true
    
  regional_comparison:
    us_east_1:
      region_name: "N. Virginia"
      monthly_cost: 2500.00
      cost_breakdown:
        compute: 1800.00
        storage: 400.00
        data_transfer: 300.00
      availability_zones: 6
      service_availability: 100
      
    us_west_2:
      region_name: "Oregon"
      monthly_cost: 2625.00
      cost_breakdown:
        compute: 1890.00
        storage: 420.00
        data_transfer: 315.00
      availability_zones: 4
      service_availability: 98
      
    eu_west_1:
      region_name: "Ireland"
      monthly_cost: 2750.00
      cost_breakdown:
        compute: 1980.00
        storage: 440.00
        data_transfer: 330.00
      availability_zones: 3
      service_availability: 95
      
  recommendations:
    primary_recommendation:
      recommended_region: "us-east-1"
      current_region: "us-west-2"
      monthly_savings: 125.00
      annual_savings: 1500.00
      performance_impact: "Low"
      compliance_status: "Compliant"
      implementation_effort: "Medium"
      
    multi_region_strategy:
      primary_region: "us-east-1"
      secondary_region: "us-west-2"
      disaster_recovery_region: "eu-west-1"
      total_monthly_cost: 3200.00
      redundancy_cost: 700.00
      availability_improvement: "99.99%"
      
  data_transfer_optimization:
    cloudfront_savings: 450.00
    inter_region_optimization: 200.00
    direct_connect_roi: 18  # months
    
  implementation_plan:
    phase_1:
      duration: "Month 1"
      actions:
        - "Set up infrastructure in us-east-1"
        - "Configure CloudFront distribution"
      cost_impact: -200.00  # Setup costs
      
    phase_2:
      duration: "Month 2"
      actions:
        - "Migrate primary workload"
        - "Update DNS routing"
      cost_impact: 125.00  # Monthly savings begin
      
    phase_3:
      duration: "Month 3"
      actions:
        - "Decommission old infrastructure"
        - "Optimize data transfer patterns"
      cost_impact: 125.00  # Full savings realized

def create_multi_region_optimization_strategy():
    """Create comprehensive multi-region cost optimization strategy"""
    
    strategy = {
        'primary_region_selection': {
            'criteria': [
                'Lowest compute costs for primary workload',
                'Best connectivity to user base',
                'Compliance and regulatory requirements',
                'Service availability and maturity'
            ],
            'evaluation_matrix': {
                'cost_weight': 0.4,
                'performance_weight': 0.3,
                'compliance_weight': 0.2,
                'availability_weight': 0.1
            }
        },
        
        'secondary_region_strategy': {
            'disaster_recovery': {
                'selection_criteria': 'Cost-effective region with adequate separation',
                'cost_optimization': 'Use lower-cost storage and minimal compute until needed',
                'automation': 'Automated failover and cost monitoring'
            },
            'load_distribution': {
                'traffic_routing': 'Route 53 latency-based routing',
                'cost_balancing': 'Dynamic routing based on cost and performance',
                'scaling_strategy': 'Scale in cost-effective regions first'
            }
        },
        
        'data_strategy': {
            'data_locality': 'Keep data close to processing to minimize transfer costs',
            'backup_strategy': 'Use cost-effective regions for backup storage',
            'archival_strategy': 'Leverage regional pricing differences for long-term storage'
        },
        
        'monitoring_and_optimization': {
            'cost_tracking': 'Real-time cost monitoring by region',
            'performance_monitoring': 'Latency and availability tracking',
            'automated_optimization': 'Dynamic workload placement based on cost-performance ratio'
        }
    }
    
    return strategy