import boto3
import json
import pandas as pd
from datetime import datetime, timedelta
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple, Any
from enum import Enum
import logging
import numpy as np
from decimal import Decimal

class EffortCategory(Enum):
    DEVELOPMENT = "development"
    TESTING = "testing"
    DEPLOYMENT = "deployment"
    TRAINING = "training"
    DOCUMENTATION = "documentation"
    MONITORING = "monitoring"
    MAINTENANCE = "maintenance"

class SkillLevel(Enum):
    JUNIOR = "junior"
    INTERMEDIATE = "intermediate"
    SENIOR = "senior"
    EXPERT = "expert"

class RiskLevel(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"

@dataclass
class ResourceRequirement:
    resource_type: str
    skill_level: SkillLevel
    hours_required: float
    hourly_rate: float
    availability_constraint: Optional[str] = None
    
    @property
    def total_cost(self) -> float:
        return self.hours_required * self.hourly_rate

@dataclass
class EffortComponent:
    category: EffortCategory
    description: str
    resource_requirements: List[ResourceRequirement]
    dependencies: List[str] = field(default_factory=list)
    risks: List[Dict] = field(default_factory=list)
    duration_days: float = 0
    
    @property
    def total_cost(self) -> float:
        return sum(req.total_cost for req in self.resource_requirements)
    
    @property
    def total_hours(self) -> float:
        return sum(req.hours_required for req in self.resource_requirements)

@dataclass
class OptimizationInitiative:
    initiative_id: str
    name: str
    description: str
    expected_savings: float
    effort_components: List[EffortComponent]
    business_impact: str
    technical_complexity: str
    timeline_constraint: Optional[datetime] = None
    
    @property
    def total_effort_cost(self) -> float:
        return sum(component.total_cost for component in self.effort_components)
    
    @property
    def total_effort_hours(self) -> float:
        return sum(component.total_hours for component in self.effort_components)
    
    @property
    def roi_estimate(self) -> float:
        if self.total_effort_cost == 0:
            return float('inf')
        return (self.expected_savings - self.total_effort_cost) / self.total_effort_cost

class EffortAnalysisManager:
    def __init__(self):
        self.systems_manager = boto3.client('ssm')
        self.cost_explorer = boto3.client('ce')
        self.cloudwatch = boto3.client('cloudwatch')
        
        # Standard hourly rates by skill level (configurable)
        self.standard_rates = {
            SkillLevel.JUNIOR: 75.0,
            SkillLevel.INTERMEDIATE: 100.0,
            SkillLevel.SENIOR: 135.0,
            SkillLevel.EXPERT: 175.0
        }
        
        # Effort estimation templates
        self.effort_templates = self.load_effort_templates()
        
        # Setup logging
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)
    
    def load_effort_templates(self) -> Dict:
        """Load standardized effort estimation templates"""
        
        templates = {
            'ec2_rightsizing': {
                'development': {'hours': 16, 'skill_level': SkillLevel.INTERMEDIATE},
                'testing': {'hours': 24, 'skill_level': SkillLevel.INTERMEDIATE},
                'deployment': {'hours': 8, 'skill_level': SkillLevel.SENIOR},
                'documentation': {'hours': 4, 'skill_level': SkillLevel.JUNIOR},
                'monitoring': {'hours': 8, 'skill_level': SkillLevel.INTERMEDIATE}
            },
            'storage_optimization': {
                'development': {'hours': 12, 'skill_level': SkillLevel.INTERMEDIATE},
                'testing': {'hours': 16, 'skill_level': SkillLevel.INTERMEDIATE},
                'deployment': {'hours': 4, 'skill_level': SkillLevel.SENIOR},
                'documentation': {'hours': 3, 'skill_level': SkillLevel.JUNIOR},
                'monitoring': {'hours': 6, 'skill_level': SkillLevel.INTERMEDIATE}
            },
            'database_optimization': {
                'development': {'hours': 32, 'skill_level': SkillLevel.SENIOR},
                'testing': {'hours': 40, 'skill_level': SkillLevel.SENIOR},
                'deployment': {'hours': 16, 'skill_level': SkillLevel.EXPERT},
                'documentation': {'hours': 8, 'skill_level': SkillLevel.INTERMEDIATE},
                'monitoring': {'hours': 12, 'skill_level': SkillLevel.SENIOR}
            },
            'serverless_migration': {
                'development': {'hours': 80, 'skill_level': SkillLevel.SENIOR},
                'testing': {'hours': 60, 'skill_level': SkillLevel.SENIOR},
                'deployment': {'hours': 24, 'skill_level': SkillLevel.EXPERT},
                'training': {'hours': 16, 'skill_level': SkillLevel.EXPERT},
                'documentation': {'hours': 12, 'skill_level': SkillLevel.INTERMEDIATE},
                'monitoring': {'hours': 20, 'skill_level': SkillLevel.SENIOR}
            }
        }
        
        return templates
    
    def analyze_optimization_effort(self, initiative: OptimizationInitiative) -> Dict:
        """Perform comprehensive effort analysis for optimization initiative"""
        
        analysis_results = {
            'initiative_id': initiative.initiative_id,
            'analysis_date': datetime.now().isoformat(),
            'effort_breakdown': self.create_effort_breakdown(initiative),
            'resource_analysis': self.analyze_resource_requirements(initiative),
            'risk_assessment': self.assess_implementation_risks(initiative),
            'timeline_analysis': self.analyze_timeline_requirements(initiative),
            'cost_benefit_analysis': self.perform_cost_benefit_analysis(initiative),
            'recommendations': self.generate_effort_recommendations(initiative),
            'confidence_metrics': self.calculate_confidence_metrics(initiative)
        }
        
        return analysis_results
    
    def create_effort_breakdown(self, initiative: OptimizationInitiative) -> Dict:
        """Create detailed breakdown of effort by category and resource type"""
        
        breakdown = {
            'by_category': {},
            'by_skill_level': {},
            'by_resource_type': {},
            'total_summary': {
                'total_hours': initiative.total_effort_hours,
                'total_cost': initiative.total_effort_cost,
                'estimated_duration_days': self.estimate_project_duration(initiative)
            }
        }
        
        # Breakdown by category
        for component in initiative.effort_components:
            category = component.category.value
            breakdown['by_category'][category] = {
                'hours': component.total_hours,
                'cost': component.total_cost,
                'resource_count': len(component.resource_requirements)
            }
        
        # Breakdown by skill level
        skill_totals = {}
        for component in initiative.effort_components:
            for req in component.resource_requirements:
                skill = req.skill_level.value
                if skill not in skill_totals:
                    skill_totals[skill] = {'hours': 0, 'cost': 0}
                skill_totals[skill]['hours'] += req.hours_required
                skill_totals[skill]['cost'] += req.total_cost
        
        breakdown['by_skill_level'] = skill_totals
        
        # Breakdown by resource type
        resource_totals = {}
        for component in initiative.effort_components:
            for req in component.resource_requirements:
                resource_type = req.resource_type
                if resource_type not in resource_totals:
                    resource_totals[resource_type] = {'hours': 0, 'cost': 0}
                resource_totals[resource_type]['hours'] += req.hours_required
                resource_totals[resource_type]['cost'] += req.total_cost
        
        breakdown['by_resource_type'] = resource_totals
        
        return breakdown
    
    def analyze_resource_requirements(self, initiative: OptimizationInitiative) -> Dict:
        """Analyze resource requirements and availability constraints"""
        
        resource_analysis = {
            'skill_requirements': self.analyze_skill_requirements(initiative),
            'availability_constraints': self.identify_availability_constraints(initiative),
            'capacity_planning': self.perform_capacity_planning(initiative),
            'external_dependencies': self.identify_external_dependencies(initiative)
        }
        
        return resource_analysis
    
    def analyze_skill_requirements(self, initiative: OptimizationInitiative) -> Dict:
        """Analyze required skills and identify gaps"""
        
        skill_requirements = {}
        
        for component in initiative.effort_components:
            for req in component.resource_requirements:
                skill_key = f"{req.resource_type}_{req.skill_level.value}"
                if skill_key not in skill_requirements:
                    skill_requirements[skill_key] = {
                        'resource_type': req.resource_type,
                        'skill_level': req.skill_level.value,
                        'total_hours': 0,
                        'components': []
                    }
                
                skill_requirements[skill_key]['total_hours'] += req.hours_required
                skill_requirements[skill_key]['components'].append(component.category.value)
        
        # Add skill gap analysis
        for skill_key, details in skill_requirements.items():
            details['availability_risk'] = self.assess_skill_availability_risk(
                details['resource_type'], 
                details['skill_level'], 
                details['total_hours']
            )
            details['training_requirements'] = self.identify_training_requirements(
                details['resource_type'], 
                details['skill_level']
            )
        
        return skill_requirements
    
    def assess_implementation_risks(self, initiative: OptimizationInitiative) -> Dict:
        """Assess risks associated with the optimization initiative"""
        
        risk_assessment = {
            'technical_risks': [],
            'operational_risks': [],
            'business_risks': [],
            'resource_risks': [],
            'overall_risk_score': 0,
            'mitigation_strategies': []
        }
        
        # Collect risks from components
        all_risks = []
        for component in initiative.effort_components:
            all_risks.extend(component.risks)
        
        # Categorize risks
        for risk in all_risks:
            risk_category = risk.get('category', 'technical')
            risk_level = risk.get('level', RiskLevel.MEDIUM)
            
            risk_item = {
                'description': risk.get('description', ''),
                'level': risk_level.value if isinstance(risk_level, RiskLevel) else risk_level,
                'probability': risk.get('probability', 0.5),
                'impact': risk.get('impact', 0.5),
                'mitigation': risk.get('mitigation', '')
            }
            
            if risk_category == 'technical':
                risk_assessment['technical_risks'].append(risk_item)
            elif risk_category == 'operational':
                risk_assessment['operational_risks'].append(risk_item)
            elif risk_category == 'business':
                risk_assessment['business_risks'].append(risk_item)
            elif risk_category == 'resource':
                risk_assessment['resource_risks'].append(risk_item)
        
        # Calculate overall risk score
        risk_assessment['overall_risk_score'] = self.calculate_overall_risk_score(all_risks)
        
        # Generate mitigation strategies
        risk_assessment['mitigation_strategies'] = self.generate_risk_mitigation_strategies(
            initiative, all_risks
        )
        
        return risk_assessment
    
    def perform_cost_benefit_analysis(self, initiative: OptimizationInitiative) -> Dict:
        """Perform comprehensive cost-benefit analysis"""
        
        analysis = {
            'investment_costs': {
                'direct_effort_cost': initiative.total_effort_cost,
                'infrastructure_costs': self.estimate_infrastructure_costs(initiative),
                'training_costs': self.estimate_training_costs(initiative),
                'opportunity_costs': self.estimate_opportunity_costs(initiative),
                'total_investment': 0
            },
            'expected_benefits': {
                'annual_savings': initiative.expected_savings,
                'productivity_gains': self.estimate_productivity_gains(initiative),
                'risk_reduction_value': self.estimate_risk_reduction_value(initiative),
                'total_annual_benefits': 0
            },
            'financial_metrics': {},
            'payback_analysis': {},
            'sensitivity_analysis': {}
        }
        
        # Calculate totals
        analysis['investment_costs']['total_investment'] = sum(
            analysis['investment_costs'].values()
        ) - analysis['investment_costs']['total_investment']  # Exclude the total itself
        
        analysis['expected_benefits']['total_annual_benefits'] = sum(
            analysis['expected_benefits'].values()
        ) - analysis['expected_benefits']['total_annual_benefits']  # Exclude the total itself
        
        # Calculate financial metrics
        analysis['financial_metrics'] = self.calculate_financial_metrics(
            analysis['investment_costs']['total_investment'],
            analysis['expected_benefits']['total_annual_benefits']
        )
        
        # Payback analysis
        analysis['payback_analysis'] = self.calculate_payback_analysis(
            analysis['investment_costs']['total_investment'],
            analysis['expected_benefits']['total_annual_benefits']
        )
        
        # Sensitivity analysis
        analysis['sensitivity_analysis'] = self.perform_sensitivity_analysis(
            initiative, analysis
        )
        
        return analysis
    
    def estimate_project_duration(self, initiative: OptimizationInitiative) -> float:
        """Estimate project duration considering dependencies and resource constraints"""
        
        # Create dependency graph
        component_dependencies = {}
        for component in initiative.effort_components:
            component_dependencies[component.category.value] = component.dependencies
        
        # Calculate critical path
        critical_path_duration = self.calculate_critical_path(
            initiative.effort_components, component_dependencies
        )
        
        # Add buffer for risks and unknowns (typically 20-30%)
        buffer_factor = 1.25
        estimated_duration = critical_path_duration * buffer_factor
        
        return estimated_duration
    
    def generate_effort_recommendations(self, initiative: OptimizationInitiative) -> List[Dict]:
        """Generate recommendations for effort optimization"""
        
        recommendations = []
        
        # Analyze effort distribution
        effort_breakdown = self.create_effort_breakdown(initiative)
        
        # Recommendation 1: Resource optimization
        if effort_breakdown['total_summary']['total_cost'] > 50000:
            recommendations.append({
                'type': 'resource_optimization',
                'priority': 'high',
                'description': 'Consider phased implementation to spread costs over time',
                'rationale': f"Total effort cost of ${effort_breakdown['total_summary']['total_cost']:,.2f} is significant",
                'implementation': 'Break initiative into smaller phases with independent value delivery'
            })
        
        # Recommendation 2: Skill development
        skill_analysis = self.analyze_skill_requirements(initiative)
        high_skill_hours = sum(
            details['total_hours'] for details in skill_analysis.values()
            if details['skill_level'] in ['senior', 'expert']
        )
        
        if high_skill_hours > 100:
            recommendations.append({
                'type': 'skill_development',
                'priority': 'medium',
                'description': 'Invest in training to reduce dependency on senior resources',
                'rationale': f"{high_skill_hours} hours of senior/expert time required",
                'implementation': 'Provide training to intermediate resources before project start'
            })
        
        # Recommendation 3: Risk mitigation
        risk_assessment = self.assess_implementation_risks(initiative)
        if risk_assessment['overall_risk_score'] > 0.7:
            recommendations.append({
                'type': 'risk_mitigation',
                'priority': 'high',
                'description': 'Implement comprehensive risk mitigation before proceeding',
                'rationale': f"High overall risk score of {risk_assessment['overall_risk_score']:.2f}",
                'implementation': 'Develop detailed risk mitigation plan and contingencies'
            })
        
        # Recommendation 4: Automation opportunities
        manual_effort_hours = sum(
            component.total_hours for component in initiative.effort_components
            if component.category in [EffortCategory.TESTING, EffortCategory.DEPLOYMENT]
        )
        
        if manual_effort_hours > 50:
            recommendations.append({
                'type': 'automation',
                'priority': 'medium',
                'description': 'Invest in automation to reduce manual effort',
                'rationale': f"{manual_effort_hours} hours of manual testing/deployment effort",
                'implementation': 'Develop automated testing and deployment pipelines'
            })
        
        return recommendations

def calculate_confidence_metrics(self, initiative: OptimizationInitiative) -> Dict:
    """Calculate confidence metrics for effort estimates"""
    
    confidence_metrics = {
        'estimation_confidence': 0.0,
        'resource_availability_confidence': 0.0,
        'technical_feasibility_confidence': 0.0,
        'timeline_confidence': 0.0,
        'overall_confidence': 0.0,
        'confidence_factors': []
    }
    
    # Estimation confidence based on template usage and historical data
    template_coverage = self.calculate_template_coverage(initiative)
    confidence_metrics['estimation_confidence'] = min(0.9, 0.5 + (template_coverage * 0.4))
    
    # Resource availability confidence
    resource_analysis = self.analyze_resource_requirements(initiative)
    availability_risks = sum(
        1 for skill in resource_analysis['skill_requirements'].values()
        if skill.get('availability_risk', 'low') in ['high', 'critical']
    )
    confidence_metrics['resource_availability_confidence'] = max(0.1, 1.0 - (availability_risks * 0.2))
    
    # Technical feasibility confidence
    risk_assessment = self.assess_implementation_risks(initiative)
    technical_risk_score = sum(
        risk['probability'] * risk['impact'] 
        for risk in risk_assessment['technical_risks']
    ) / max(1, len(risk_assessment['technical_risks']))
    confidence_metrics['technical_feasibility_confidence'] = max(0.1, 1.0 - technical_risk_score)
    
    # Timeline confidence
    timeline_complexity = len(initiative.effort_components) * 0.1
    confidence_metrics['timeline_confidence'] = max(0.1, 1.0 - timeline_complexity)
    
    # Overall confidence (weighted average)
    weights = {
        'estimation_confidence': 0.3,
        'resource_availability_confidence': 0.3,
        'technical_feasibility_confidence': 0.25,
        'timeline_confidence': 0.15
    }
    
    confidence_metrics['overall_confidence'] = sum(
        confidence_metrics[metric] * weight
        for metric, weight in weights.items()
    )
    
    # Add confidence factors
    if confidence_metrics['overall_confidence'] < 0.6:
        confidence_metrics['confidence_factors'].append(
            "Low confidence - recommend additional analysis and risk mitigation"
        )
    elif confidence_metrics['overall_confidence'] < 0.8:
        confidence_metrics['confidence_factors'].append(
            "Medium confidence - proceed with caution and monitoring"
        )
    else:
        confidence_metrics['confidence_factors'].append(
            "High confidence - good candidate for implementation"
        )
    
    return confidence_metrics

def create_effort_estimation_template(self, optimization_type: str, 
                                    historical_data: List[Dict]) -> Dict:
    """Create effort estimation template based on historical data"""
    
    if not historical_data:
        return self.effort_templates.get(optimization_type, {})
    
    # Analyze historical data to create template
    template = {}
    
    for category in EffortCategory:
        category_data = [
            item for item in historical_data 
            if item.get('category') == category.value
        ]
        
        if category_data:
            avg_hours = np.mean([item['hours'] for item in category_data])
            std_hours = np.std([item['hours'] for item in category_data])
            
            # Determine most common skill level
            skill_levels = [item['skill_level'] for item in category_data]
            most_common_skill = max(set(skill_levels), key=skill_levels.count)
            
            template[category.value] = {
                'hours': avg_hours,
                'hours_std': std_hours,
                'skill_level': most_common_skill,
                'confidence': min(0.9, len(category_data) / 10)  # More data = higher confidence
            }
    
    return template

def generate_effort_report(self, analysis_results: Dict) -> str:
    """Generate comprehensive effort analysis report"""
    
    report = f"""

    for i, rec in enumerate(analysis_results['recommendations'], 1):
        report += f"""

def calculate_template_coverage(self, initiative: OptimizationInitiative) -> float:
    """Calculate how well the initiative matches existing templates"""
    # Implementation would compare initiative components to templates
    return 0.7  # Placeholder

def assess_skill_availability_risk(self, resource_type: str, skill_level: str, hours: float) -> str:
    """Assess risk of resource availability"""
    if hours > 200 and skill_level in ['senior', 'expert']:
        return 'high'
    elif hours > 100 and skill_level == 'expert':
        return 'medium'
    else:
        return 'low'

def identify_training_requirements(self, resource_type: str, skill_level: str) -> List[str]:
    """Identify training requirements for resource type and skill level"""
    training_map = {
        'aws_architect': ['AWS Solutions Architect Certification', 'Well-Architected Training'],
        'devops_engineer': ['AWS DevOps Certification', 'Infrastructure as Code Training'],
        'developer': ['AWS Developer Certification', 'Serverless Development Training']
    }
    return training_map.get(resource_type, [])

def calculate_overall_risk_score(self, risks: List[Dict]) -> float:
    """Calculate overall risk score from individual risks"""
    if not risks:
        return 0.0
    
    total_risk = sum(
        risk.get('probability', 0.5) * risk.get('impact', 0.5)
        for risk in risks
    )
    return min(1.0, total_risk / len(risks))

def generate_risk_mitigation_strategies(self, initiative: OptimizationInitiative, 
                                      risks: List[Dict]) -> List[Dict]:
    """Generate risk mitigation strategies"""
    strategies = []
    
    high_risks = [r for r in risks if r.get('level') in ['high', 'critical']]
    
    for risk in high_risks:
        strategy = {
            'risk_description': risk.get('description', ''),
            'mitigation_approach': risk.get('mitigation', 'Develop specific mitigation plan'),
            'contingency_plan': 'Define fallback approach if mitigation fails',
            'monitoring_approach': 'Establish early warning indicators'
        }
        strategies.append(strategy)
    
    return strategies

def estimate_infrastructure_costs(self, initiative: OptimizationInitiative) -> float:
    """Estimate additional infrastructure costs for implementation"""
    # This would analyze the initiative to estimate infrastructure needs
    return 5000.0  # Placeholder

def estimate_training_costs(self, initiative: OptimizationInitiative) -> float:
    """Estimate training costs"""
    # Calculate based on skill requirements and training needs
    return 3000.0  # Placeholder

def estimate_opportunity_costs(self, initiative: OptimizationInitiative) -> float:
    """Estimate opportunity costs of resource allocation"""
    # Calculate based on alternative uses of resources
    return initiative.total_effort_cost * 0.15  # 15% of effort cost

def estimate_productivity_gains(self, initiative: OptimizationInitiative) -> float:
    """Estimate productivity gains from optimization"""
    # Calculate based on optimization type and scope
    return initiative.expected_savings * 0.1  # 10% additional productivity gains

def estimate_risk_reduction_value(self, initiative: OptimizationInitiative) -> float:
    """Estimate value of risk reduction"""
    # Calculate based on risks mitigated
    return 2000.0  # Placeholder

def calculate_financial_metrics(self, investment: float, annual_benefits: float) -> Dict:
    """Calculate financial metrics"""
    if investment == 0:
        return {'roi': float('inf'), 'npv_3_year': annual_benefits * 3}
    
    roi = (annual_benefits - investment) / investment
    npv_3_year = (annual_benefits * 3) - investment  # Simplified NPV
    
    return {
        'roi': roi,
        'npv_3_year': npv_3_year,
        'benefit_cost_ratio': annual_benefits / investment if investment > 0 else float('inf')
    }

def calculate_payback_analysis(self, investment: float, annual_benefits: float) -> Dict:
    """Calculate payback analysis"""
    if annual_benefits <= 0:
        return {'payback_months': float('inf'), 'break_even_point': 'Never'}
    
    payback_months = (investment / annual_benefits) * 12
    
    return {
        'payback_months': payback_months,
        'break_even_point': f"{payback_months:.1f} months",
        'cumulative_benefits_year_1': annual_benefits,
        'cumulative_benefits_year_2': annual_benefits * 2,
        'cumulative_benefits_year_3': annual_benefits * 3
    }

def perform_sensitivity_analysis(self, initiative: OptimizationInitiative, 
                               analysis: Dict) -> Dict:
    """Perform sensitivity analysis on key variables"""
    
    base_investment = analysis['investment_costs']['total_investment']
    base_benefits = analysis['expected_benefits']['total_annual_benefits']
    
    scenarios = {
        'optimistic': {
            'investment_multiplier': 0.8,
            'benefits_multiplier': 1.2,
            'description': 'Best case scenario'
        },
        'pessimistic': {
            'investment_multiplier': 1.3,
            'benefits_multiplier': 0.7,
            'description': 'Worst case scenario'
        },
        'realistic': {
            'investment_multiplier': 1.1,
            'benefits_multiplier': 0.9,
            'description': 'Conservative estimate'
        }
    }
    
    sensitivity_results = {}
    
    for scenario_name, scenario in scenarios.items():
        adjusted_investment = base_investment * scenario['investment_multiplier']
        adjusted_benefits = base_benefits * scenario['benefits_multiplier']
        
        sensitivity_results[scenario_name] = {
            'investment': adjusted_investment,
            'annual_benefits': adjusted_benefits,
            'roi': (adjusted_benefits - adjusted_investment) / adjusted_investment if adjusted_investment > 0 else float('inf'),
            'payback_months': (adjusted_investment / adjusted_benefits) * 12 if adjusted_benefits > 0 else float('inf'),
            'description': scenario['description']
        }
    
    return sensitivity_results

def calculate_critical_path(self, components: List[EffortComponent], 
                          dependencies: Dict) -> float:
    """Calculate critical path duration"""
    # Simplified critical path calculation
    # In practice, this would use proper project management algorithms
    
    total_duration = 0
    processed_components = set()
    
    # Process components in dependency order
    while len(processed_components) < len(components):
        for component in components:
            category = component.category.value
            if category in processed_components:
                continue
            
            # Check if all dependencies are processed
            deps = dependencies.get(category, [])
            if all(dep in processed_components for dep in deps):
                # Add component duration
                component_duration = component.duration_days or (component.total_hours / 8)  # Assume 8 hours per day
                total_duration = max(total_duration, component_duration)
                processed_components.add(category)
    
    return total_duration

def identify_availability_constraints(self, initiative: OptimizationInitiative) -> List[Dict]:
    """Identify resource availability constraints"""
    constraints = []
    
    for component in initiative.effort_components:
        for req in component.resource_requirements:
            if req.availability_constraint:
                constraints.append({
                    'component': component.category.value,
                    'resource_type': req.resource_type,
                    'constraint': req.availability_constraint,
                    'impact': 'May delay project timeline'
                })
    
    return constraints

def perform_capacity_planning(self, initiative: OptimizationInitiative) -> Dict:
    """Perform capacity planning analysis"""
    
    capacity_plan = {
        'resource_utilization': {},
        'peak_demand_periods': [],
        'capacity_gaps': [],
        'recommendations': []
    }
    
    # Calculate resource utilization by skill level
    for component in initiative.effort_components:
        for req in component.resource_requirements:
            skill = req.skill_level.value
            if skill not in capacity_plan['resource_utilization']:
                capacity_plan['resource_utilization'][skill] = {
                    'total_hours': 0,
                    'peak_weekly_hours': 0,
                    'resource_count_needed': 0
                }
            
            capacity_plan['resource_utilization'][skill]['total_hours'] += req.hours_required
            
            # Estimate peak weekly hours (assuming work spread over project duration)
            project_weeks = max(1, self.estimate_project_duration(initiative) / 7)
            weekly_hours = req.hours_required / project_weeks
            capacity_plan['resource_utilization'][skill]['peak_weekly_hours'] = max(
                capacity_plan['resource_utilization'][skill]['peak_weekly_hours'],
                weekly_hours
            )
    
    # Identify capacity gaps
    for skill, utilization in capacity_plan['resource_utilization'].items():
        if utilization['peak_weekly_hours'] > 40:  # More than full-time
            capacity_plan['capacity_gaps'].append({
                'skill_level': skill,
                'gap_hours': utilization['peak_weekly_hours'] - 40,
                'recommendation': 'Consider additional resources or extended timeline'
            })
    
    return capacity_plan

def identify_external_dependencies(self, initiative: OptimizationInitiative) -> List[Dict]:
    """Identify external dependencies that could impact effort"""
    
    dependencies = []
    
    # Check for common external dependencies
    for component in initiative.effort_components:
        if component.category == EffortCategory.DEPLOYMENT:
            dependencies.append({
                'type': 'deployment_window',
                'description': 'Requires scheduled deployment window',
                'impact': 'May constrain timeline flexibility',
                'mitigation': 'Coordinate with change management process'
            })
        
        if component.category == EffortCategory.TESTING:
            dependencies.append({
                'type': 'test_environment',
                'description': 'Requires dedicated test environment',
                'impact': 'May delay testing phase',
                'mitigation': 'Reserve test environment in advance'
            })
    
    return dependencies

Now let me add the usage examples and templates:
## Usage Examples

### Example 1: EC2 Right-sizing Initiative

### Example 2: Serverless Migration Initiative

## Effort Analysis Templates

### Template Configuration

testing:
  hours: 24
  skill_level: "intermediate"
  resource_type: "devops_engineer"
  risks:
    - category: "operational"
      level: "medium"
      description: "Performance impact detection"
      
deployment:
  hours: 8
  skill_level: "senior"
  resource_type: "aws_architect"
  risks:
    - category: "business"
      level: "high"
      description: "Service disruption risk"
      

testing:
  hours: 16
  skill_level: "intermediate"
  resource_type: "devops_engineer"
  
deployment:
  hours: 4
  skill_level: "senior"
  resource_type: "aws_architect"
  

testing:
  hours: 40
  skill_level: "senior"
  resource_type: "database_engineer"
  
deployment:
  hours: 16
  skill_level: "expert"
  resource_type: "database_architect"
  
training:
  hours: 8
  skill_level: "expert"
  resource_type: "trainer"

## Common Challenges and Solutions

### Challenge: Inaccurate Effort Estimates

**Solution**: Build historical databases of effort data from previous optimization initiatives. Use multiple estimation techniques (bottom-up, top-down, analogous) and compare results. Include uncertainty ranges rather than point estimates.

### Challenge: Hidden Costs and Dependencies

**Solution**: Use comprehensive checklists to identify all potential costs including training, documentation, monitoring setup, and ongoing maintenance. Map dependencies early and include buffer time for coordination overhead.

### Challenge: Resource Availability Constraints

**Solution**: Perform capacity planning analysis to identify resource conflicts early. Consider alternative resource allocation strategies such as phased implementation or external contractor support.

### Challenge: Changing Requirements During Implementation

**Solution**: Build flexibility into effort estimates with contingency buffers. Establish change control processes to manage scope changes and their impact on effort requirements.

### Challenge: Measuring Soft Benefits

**Solution**: Develop frameworks for quantifying indirect benefits such as improved maintainability, reduced technical debt, and enhanced team productivity. Use proxy metrics and stakeholder surveys to capture qualitative improvements.

## Related Resources

<div class="related-resources">
  <h2>Related Resources</h2>
  <ul>
    <li><a href="https://docs.aws.amazon.com/wellarchitected/latest/framework/cost-11.html">AWS Well-Architected Framework - How do you evaluate the cost of effort?</a></li>
    <li><a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html">AWS Systems Manager User Guide</a></li>
    <li><a href="https://docs.aws.amazon.com/cost-management/latest/userguide/ce-what-is.html">AWS Cost Explorer User Guide</a></li>
    <li><a href="https://docs.aws.amazon.com/quicksight/latest/user/welcome.html">Amazon QuickSight User Guide</a></li>
    <li><a href="https://docs.aws.amazon.com/cloudwatch/latest/monitoring/WhatIsCloudWatch.html">Amazon CloudWatch User Guide</a></li>
    <li><a href="https://aws.amazon.com/architecture/well-architected/">AWS Well-Architected Framework</a></li>
    <li><a href="https://docs.aws.amazon.com/wellarchitected/latest/userguide/intro.html">AWS Well-Architected Tool User Guide</a></li>
  </ul>
</div>

<style>
.pillar-header {
  background-color: #e8f5e8;
  border-left: 5px solid #2d7d2d;
}

.pillar-header h1 {
  color: #2d7d2d;
}

.aws-service-content h4 {
  color: #2d7d2d;
}

.related-resources {
  background-color: #e8f5e8;
}

.related-resources h2 {
  color: #2d7d2d;
}
</style>