COST10-BP03 - Implement new service evaluation automation

import boto3
import json
import requests
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 re
import feedparser
from bs4 import BeautifulSoup
import openai  # For natural language processing
import numpy as np

class ServiceCategory(Enum):
    COMPUTE = "compute"
    STORAGE = "storage"
    DATABASE = "database"
    NETWORKING = "networking"
    SECURITY = "security"
    ANALYTICS = "analytics"
    MACHINE_LEARNING = "machine_learning"
    SERVERLESS = "serverless"
    CONTAINERS = "containers"
    MANAGEMENT = "management"

class RelevanceLevel(Enum):
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"
    NOT_APPLICABLE = "not_applicable"

class AdoptionRecommendation(Enum):
    IMMEDIATE = "immediate"
    PILOT = "pilot"
    EVALUATE = "evaluate"
    MONITOR = "monitor"
    IGNORE = "ignore"

@dataclass
class ServiceAnnouncement:
    announcement_id: str
    title: str
    description: str
    service_name: str
    category: ServiceCategory
    announcement_date: datetime
    source_url: str
    key_features: List[str]
    pricing_model: Optional[str] = None
    availability_regions: List[str] = field(default_factory=list)
    
@dataclass
class WorkloadProfile:
    workload_id: str
    architecture_components: List[str]
    current_services: List[str]
    cost_profile: Dict[str, float]
    performance_requirements: Dict[str, Any]
    compliance_requirements: List[str]
    business_criticality: str
    
@dataclass
class ServiceEvaluationResult:
    evaluation_id: str
    workload_id: str
    service_announcement: ServiceAnnouncement
    relevance_level: RelevanceLevel
    relevance_score: float
    potential_benefits: List[str]
    estimated_cost_impact: float
    implementation_complexity: str
    risk_assessment: Dict[str, str]
    recommendation: AdoptionRecommendation
    rationale: str
    evaluation_date: datetime
    next_review_date: datetime

class ServiceEvaluationAutomation:
    def __init__(self):
        self.lambda_client = boto3.client('lambda')
        self.sns_client = boto3.client('sns')
        self.dynamodb = boto3.resource('dynamodb')
        self.systems_manager = boto3.client('ssm')
        self.cost_explorer = boto3.client('ce')
        
        # Configuration
        self.config = {
            'rss_feeds': [
                'https://aws.amazon.com/new/feed/',
                'https://aws.amazon.com/blogs/aws/feed/',
                'https://aws.amazon.com/blogs/compute/feed/',
                'https://aws.amazon.com/blogs/storage/feed/',
                'https://aws.amazon.com/blogs/database/feed/'
            ],
            'evaluation_thresholds': {
                'high_relevance': 0.8,
                'medium_relevance': 0.5,
                'cost_impact_threshold': 100.0,  # Monthly cost impact
                'immediate_action_threshold': 0.9
            },
            'notification_topics': {
                'high_priority': 'arn:aws:sns:us-east-1:123456789012:high-priority-service-updates',
                'medium_priority': 'arn:aws:sns:us-east-1:123456789012:medium-priority-service-updates'
            }
        }
        
        # Initialize tables
        self.announcements_table = self.dynamodb.Table('ServiceAnnouncements')
        self.evaluations_table = self.dynamodb.Table('ServiceEvaluations')
        self.workload_profiles_table = self.dynamodb.Table('WorkloadProfiles')
        
        # Setup logging
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)
    
    def setup_automation_infrastructure(self) -> Dict:
        """Set up the automation infrastructure"""
        
        infrastructure = {
            'lambda_functions': self.create_lambda_functions(),
            'eventbridge_rules': self.create_eventbridge_rules(),
            'dynamodb_tables': self.create_dynamodb_tables(),
            'sns_topics': self.create_sns_topics(),
            'cloudwatch_dashboards': self.create_monitoring_dashboards()
        }
        
        return infrastructure
    
    def create_lambda_functions(self) -> Dict:
        """Create Lambda functions for automation"""
        
        functions = {
            'announcement_monitor': {
                'function_name': 'ServiceAnnouncementMonitor',
                'description': 'Monitor AWS service announcements from RSS feeds',
                'runtime': 'python3.9',
                'handler': 'lambda_function.lambda_handler',
                'schedule': 'rate(1 hour)',  # Run every hour
                'environment_variables': {
                    'RSS_FEEDS': json.dumps(self.config['rss_feeds']),
                    'ANNOUNCEMENTS_TABLE': 'ServiceAnnouncements'
                }
            },
            'service_evaluator': {
                'function_name': 'ServiceEvaluator',
                'description': 'Evaluate new services against workload profiles',
                'runtime': 'python3.9',
                'handler': 'lambda_function.lambda_handler',
                'trigger': 'DynamoDB Stream from ServiceAnnouncements',
                'environment_variables': {
                    'WORKLOAD_PROFILES_TABLE': 'WorkloadProfiles',
                    'EVALUATIONS_TABLE': 'ServiceEvaluations'
                }
            },
            'recommendation_generator': {
                'function_name': 'RecommendationGenerator',
                'description': 'Generate adoption recommendations and notifications',
                'runtime': 'python3.9',
                'handler': 'lambda_function.lambda_handler',
                'trigger': 'DynamoDB Stream from ServiceEvaluations',
                'environment_variables': {
                    'HIGH_PRIORITY_TOPIC': self.config['notification_topics']['high_priority'],
                    'MEDIUM_PRIORITY_TOPIC': self.config['notification_topics']['medium_priority']
                }
            }
        }
        
        return functions
    
    def monitor_service_announcements(self) -> List[ServiceAnnouncement]:
        """Monitor and parse AWS service announcements"""
        
        announcements = []
        
        for feed_url in self.config['rss_feeds']:
            try:
                # Parse RSS feed
                feed = feedparser.parse(feed_url)
                
                for entry in feed.entries:
                    # Skip if already processed
                    if self.is_announcement_processed(entry.id):
                        continue
                    
                    # Parse announcement
                    announcement = self.parse_announcement(entry)
                    if announcement:
                        announcements.append(announcement)
                        
                        # Store in DynamoDB
                        self.store_announcement(announcement)
                        
                        self.logger.info(f"New announcement processed: {announcement.title}")
                
            except Exception as e:
                self.logger.error(f"Error processing feed {feed_url}: {str(e)}")
                continue
        
        return announcements
    
    def parse_announcement(self, entry) -> Optional[ServiceAnnouncement]:
        """Parse RSS entry into ServiceAnnouncement"""
        
        try:
            # Extract basic information
            title = entry.title
            description = entry.summary if hasattr(entry, 'summary') else entry.description
            announcement_date = datetime(*entry.published_parsed[:6])
            source_url = entry.link
            
            # Use NLP to extract service information
            service_info = self.extract_service_information(title, description)
            
            if not service_info:
                return None
            
            announcement = ServiceAnnouncement(
                announcement_id=self.generate_announcement_id(entry.id),
                title=title,
                description=description,
                service_name=service_info['service_name'],
                category=service_info['category'],
                announcement_date=announcement_date,
                source_url=source_url,
                key_features=service_info['key_features'],
                pricing_model=service_info.get('pricing_model'),
                availability_regions=service_info.get('regions', [])
            )
            
            return announcement
            
        except Exception as e:
            self.logger.error(f"Error parsing announcement: {str(e)}")
            return None
    
    def extract_service_information(self, title: str, description: str) -> Optional[Dict]:
        """Extract service information using NLP and pattern matching"""
        
        text = f"{title} {description}".lower()
        
        # Service name extraction patterns
        service_patterns = {
            'amazon': r'amazon\s+([a-z]+(?:\s+[a-z]+)*)',
            'aws': r'aws\s+([a-z]+(?:\s+[a-z]+)*)',
            'elastic': r'(elastic\s+[a-z]+(?:\s+[a-z]+)*)'
        }
        
        service_name = "Unknown Service"
        for pattern_type, pattern in service_patterns.items():
            matches = re.findall(pattern, text)
            if matches:
                service_name = matches[0].title()
                break
        
        # Category classification
        category_keywords = {
            ServiceCategory.COMPUTE: ['ec2', 'lambda', 'fargate', 'batch', 'compute'],
            ServiceCategory.STORAGE: ['s3', 'ebs', 'efs', 'fsx', 'storage'],
            ServiceCategory.DATABASE: ['rds', 'dynamodb', 'redshift', 'aurora', 'database'],
            ServiceCategory.NETWORKING: ['vpc', 'cloudfront', 'route53', 'elb', 'network'],
            ServiceCategory.SECURITY: ['iam', 'kms', 'secrets', 'security', 'encryption'],
            ServiceCategory.ANALYTICS: ['athena', 'glue', 'kinesis', 'analytics', 'data'],
            ServiceCategory.MACHINE_LEARNING: ['sagemaker', 'ml', 'ai', 'machine learning'],
            ServiceCategory.SERVERLESS: ['lambda', 'serverless', 'event-driven'],
            ServiceCategory.CONTAINERS: ['ecs', 'eks', 'fargate', 'container', 'kubernetes'],
            ServiceCategory.MANAGEMENT: ['cloudwatch', 'cloudtrail', 'config', 'management']
        }
        
        category = ServiceCategory.COMPUTE  # Default
        max_matches = 0
        
        for cat, keywords in category_keywords.items():
            matches = sum(1 for keyword in keywords if keyword in text)
            if matches > max_matches:
                max_matches = matches
                category = cat
        
        # Extract key features
        key_features = self.extract_key_features(description)
        
        # Extract pricing information
        pricing_model = self.extract_pricing_model(description)
        
        # Extract regions
        regions = self.extract_regions(description)
        
        return {
            'service_name': service_name,
            'category': category,
            'key_features': key_features,
            'pricing_model': pricing_model,
            'regions': regions
        }
    
    def extract_key_features(self, description: str) -> List[str]:
        """Extract key features from service description"""
        
        # Common feature keywords
        feature_patterns = [
            r'(cost[- ]effective?)',
            r'(high[- ]performance)',
            r'(scalable?)',
            r'(managed service)',
            r'(serverless)',
            r'(real[- ]time)',
            r'(machine learning)',
            r'(artificial intelligence)',
            r'(encryption)',
            r'(backup)',
            r'(monitoring)',
            r'(analytics)'
        ]
        
        features = []
        description_lower = description.lower()
        
        for pattern in feature_patterns:
            matches = re.findall(pattern, description_lower)
            features.extend(matches)
        
        return list(set(features))  # Remove duplicates
    
    def extract_pricing_model(self, description: str) -> Optional[str]:
        """Extract pricing model information"""
        
        pricing_patterns = {
            'pay-as-you-go': r'pay[- ]as[- ]you[- ]go',
            'on-demand': r'on[- ]demand',
            'reserved': r'reserved instances?',
            'spot': r'spot instances?',
            'free-tier': r'free tier',
            'subscription': r'subscription'
        }
        
        description_lower = description.lower()
        
        for model, pattern in pricing_patterns.items():
            if re.search(pattern, description_lower):
                return model
        
        return None
    
    def extract_regions(self, description: str) -> List[str]:
        """Extract availability regions"""
        
        # Common AWS regions
        region_patterns = [
            r'us[- ]east[- ]1',
            r'us[- ]west[- ][12]',
            r'eu[- ]west[- ][123]',
            r'ap[- ]southeast[- ][12]',
            r'all regions?',
            r'multiple regions?'
        ]
        
        regions = []
        description_lower = description.lower()
        
        for pattern in region_patterns:
            matches = re.findall(pattern, description_lower)
            regions.extend(matches)
        
        return regions
    
    def evaluate_service_for_workloads(self, announcement: ServiceAnnouncement) -> List[ServiceEvaluationResult]:
        """Evaluate new service against all workload profiles"""
        
        evaluations = []
        
        # Get all workload profiles
        workload_profiles = self.get_workload_profiles()
        
        for profile in workload_profiles:
            evaluation = self.evaluate_service_for_workload(announcement, profile)
            evaluations.append(evaluation)
            
            # Store evaluation result
            self.store_evaluation_result(evaluation)
        
        return evaluations
    
    def evaluate_service_for_workload(self, announcement: ServiceAnnouncement, 
                                    profile: WorkloadProfile) -> ServiceEvaluationResult:
        """Evaluate service relevance for specific workload"""
        
        # Calculate relevance score
        relevance_score = self.calculate_relevance_score(announcement, profile)
        
        # Determine relevance level
        if relevance_score >= self.config['evaluation_thresholds']['high_relevance']:
            relevance_level = RelevanceLevel.HIGH
        elif relevance_score >= self.config['evaluation_thresholds']['medium_relevance']:
            relevance_level = RelevanceLevel.MEDIUM
        else:
            relevance_level = RelevanceLevel.LOW
        
        # Identify potential benefits
        potential_benefits = self.identify_potential_benefits(announcement, profile)
        
        # Estimate cost impact
        estimated_cost_impact = self.estimate_cost_impact(announcement, profile)
        
        # Assess implementation complexity
        implementation_complexity = self.assess_implementation_complexity(announcement, profile)
        
        # Perform risk assessment
        risk_assessment = self.perform_risk_assessment(announcement, profile)
        
        # Generate recommendation
        recommendation = self.generate_adoption_recommendation(
            relevance_score, estimated_cost_impact, implementation_complexity, risk_assessment
        )
        
        # Create rationale
        rationale = self.create_evaluation_rationale(
            announcement, profile, relevance_score, potential_benefits, recommendation
        )
        
        # Calculate next review date
        next_review_date = self.calculate_next_review_date(recommendation, relevance_level)
        
        evaluation = ServiceEvaluationResult(
            evaluation_id=f"EVAL_{profile.workload_id}_{announcement.announcement_id}",
            workload_id=profile.workload_id,
            service_announcement=announcement,
            relevance_level=relevance_level,
            relevance_score=relevance_score,
            potential_benefits=potential_benefits,
            estimated_cost_impact=estimated_cost_impact,
            implementation_complexity=implementation_complexity,
            risk_assessment=risk_assessment,
            recommendation=recommendation,
            rationale=rationale,
            evaluation_date=datetime.now(),
            next_review_date=next_review_date
        )
        
        return evaluation
    
    def calculate_relevance_score(self, announcement: ServiceAnnouncement, 
                                profile: WorkloadProfile) -> float:
        """Calculate relevance score (0-1) for service-workload combination"""
        
        score = 0.0
        
        # Category alignment (30% weight)
        category_score = self.calculate_category_alignment(announcement.category, profile)
        score += category_score * 0.3
        
        # Service overlap (25% weight)
        service_overlap_score = self.calculate_service_overlap(announcement, profile)
        score += service_overlap_score * 0.25
        
        # Feature alignment (20% weight)
        feature_score = self.calculate_feature_alignment(announcement.key_features, profile)
        score += feature_score * 0.2
        
        # Cost profile alignment (15% weight)
        cost_score = self.calculate_cost_alignment(announcement, profile)
        score += cost_score * 0.15
        
        # Business criticality factor (10% weight)
        criticality_score = self.calculate_criticality_factor(profile.business_criticality)
        score += criticality_score * 0.1
        
        return min(1.0, score)  # Ensure score doesn't exceed 1.0
    
    def calculate_category_alignment(self, service_category: ServiceCategory, 
                                   profile: WorkloadProfile) -> float:
        """Calculate how well service category aligns with workload"""
        
        # Map workload components to service categories
        component_category_map = {
            'ec2': ServiceCategory.COMPUTE,
            'lambda': ServiceCategory.SERVERLESS,
            'rds': ServiceCategory.DATABASE,
            'dynamodb': ServiceCategory.DATABASE,
            's3': ServiceCategory.STORAGE,
            'cloudfront': ServiceCategory.NETWORKING,
            'elb': ServiceCategory.NETWORKING
        }
        
        workload_categories = set()
        for component in profile.architecture_components:
            component_lower = component.lower()
            for comp, category in component_category_map.items():
                if comp in component_lower:
                    workload_categories.add(category)
        
        # Direct match
        if service_category in workload_categories:
            return 1.0
        
        # Related categories
        related_categories = {
            ServiceCategory.COMPUTE: [ServiceCategory.SERVERLESS, ServiceCategory.CONTAINERS],
            ServiceCategory.SERVERLESS: [ServiceCategory.COMPUTE],
            ServiceCategory.DATABASE: [ServiceCategory.ANALYTICS, ServiceCategory.STORAGE],
            ServiceCategory.STORAGE: [ServiceCategory.DATABASE, ServiceCategory.ANALYTICS],
            ServiceCategory.NETWORKING: [ServiceCategory.SECURITY],
            ServiceCategory.SECURITY: [ServiceCategory.NETWORKING, ServiceCategory.MANAGEMENT]
        }
        
        if service_category in related_categories:
            for related_cat in related_categories[service_category]:
                if related_cat in workload_categories:
                    return 0.7  # Partial match
        
        return 0.1  # Minimal relevance
    
    def calculate_service_overlap(self, announcement: ServiceAnnouncement, 
                                profile: WorkloadProfile) -> float:
        """Calculate overlap between new service and current services"""
        
        current_services_lower = [service.lower() for service in profile.current_services]
        service_name_lower = announcement.service_name.lower()
        
        # Direct service name match
        for current_service in current_services_lower:
            if service_name_lower in current_service or current_service in service_name_lower:
                return 1.0
        
        # Feature-based overlap
        overlap_score = 0.0
        for feature in announcement.key_features:
            feature_lower = feature.lower()
            for current_service in current_services_lower:
                if feature_lower in current_service:
                    overlap_score += 0.2
        
        return min(1.0, overlap_score)
    
    def identify_potential_benefits(self, announcement: ServiceAnnouncement, 
                                  profile: WorkloadProfile) -> List[str]:
        """Identify potential benefits of adopting the new service"""
        
        benefits = []
        
        # Cost optimization benefits
        if 'cost' in announcement.description.lower() or announcement.pricing_model == 'pay-as-you-go':
            benefits.append("Potential cost reduction through optimized pricing model")
        
        # Performance benefits
        if any(perf_keyword in announcement.description.lower() 
               for perf_keyword in ['performance', 'faster', 'optimized', 'efficient']):
            benefits.append("Improved performance and efficiency")
        
        # Scalability benefits
        if any(scale_keyword in announcement.description.lower() 
               for scale_keyword in ['scalable', 'auto-scaling', 'elastic']):
            benefits.append("Enhanced scalability and elasticity")
        
        # Management benefits
        if 'managed' in announcement.description.lower():
            benefits.append("Reduced operational overhead through managed service")
        
        # Security benefits
        if any(sec_keyword in announcement.description.lower() 
               for sec_keyword in ['security', 'encryption', 'compliance']):
            benefits.append("Enhanced security and compliance capabilities")
        
        # Innovation benefits
        if any(innovation_keyword in announcement.description.lower() 
               for innovation_keyword in ['machine learning', 'ai', 'analytics']):
            benefits.append("Access to advanced capabilities and innovation")
        
        return benefits
    
    def generate_adoption_recommendation(self, relevance_score: float, cost_impact: float,
                                       complexity: str, risk_assessment: Dict) -> AdoptionRecommendation:
        """Generate adoption recommendation based on evaluation factors"""
        
        # High relevance and positive cost impact
        if (relevance_score >= self.config['evaluation_thresholds']['immediate_action_threshold'] 
            and cost_impact > 0 and complexity == 'Low'):
            return AdoptionRecommendation.IMMEDIATE
        
        # High relevance but needs careful evaluation
        if relevance_score >= self.config['evaluation_thresholds']['high_relevance']:
            if complexity in ['Low', 'Medium'] and risk_assessment.get('overall_risk', 'Medium') != 'High':
                return AdoptionRecommendation.PILOT
            else:
                return AdoptionRecommendation.EVALUATE
        
        # Medium relevance
        if relevance_score >= self.config['evaluation_thresholds']['medium_relevance']:
            return AdoptionRecommendation.EVALUATE
        
        # Low relevance but worth monitoring
        if relevance_score > 0.2:
            return AdoptionRecommendation.MONITOR
        
        # Not applicable
        return AdoptionRecommendation.IGNORE

def send_recommendations(self, evaluations: List[ServiceEvaluationResult]):
    """Send recommendations based on evaluation results"""
    
    # Group evaluations by priority
    high_priority = [e for e in evaluations if e.recommendation == AdoptionRecommendation.IMMEDIATE]
    medium_priority = [e for e in evaluations if e.recommendation == AdoptionRecommendation.PILOT]
    
    # Send high priority notifications
    if high_priority:
        self.send_high_priority_notification(high_priority)
    
    # Send medium priority notifications
    if medium_priority:
        self.send_medium_priority_notification(medium_priority)
    
    # Generate summary report
    self.generate_evaluation_summary_report(evaluations)

def send_high_priority_notification(self, evaluations: List[ServiceEvaluationResult]):
    """Send high priority notifications for immediate action items"""
    
    message = {
        "notification_type": "high_priority_service_evaluation",
        "timestamp": datetime.now().isoformat(),
        "summary": f"{len(evaluations)} high-priority service adoption opportunities identified",
        "evaluations": []
    }
    
    for evaluation in evaluations:
        message["evaluations"].append({
            "workload_id": evaluation.workload_id,
            "service_name": evaluation.service_announcement.service_name,
            "relevance_score": evaluation.relevance_score,
            "estimated_cost_impact": evaluation.estimated_cost_impact,
            "recommendation": evaluation.recommendation.value,
            "rationale": evaluation.rationale
        })
    
    try:
        self.sns_client.publish(
            TopicArn=self.config['notification_topics']['high_priority'],
            Message=json.dumps(message, indent=2),
            Subject="🚨 High Priority: New AWS Service Adoption Opportunities"
        )
        self.logger.info(f"Sent high priority notification for {len(evaluations)} evaluations")
    except Exception as e:
        self.logger.error(f"Error sending high priority notification: {str(e)}")

def create_automation_dashboard(self) -> Dict:
    """Create CloudWatch dashboard for monitoring automation"""
    
    dashboard_body = {
        "widgets": [
            {
                "type": "metric",
                "properties": {
                    "metrics": [
                        ["ServiceEvaluation", "AnnouncementsProcessed"],
                        ["ServiceEvaluation", "EvaluationsGenerated"],
                        ["ServiceEvaluation", "HighPriorityRecommendations"],
                        ["ServiceEvaluation", "MediumPriorityRecommendations"]
                    ],
                    "period": 3600,
                    "stat": "Sum",
                    "region": "us-east-1",
                    "title": "Service Evaluation Metrics"
                }
            },
            {
                "type": "log",
                "properties": {
                    "query": "SOURCE '/aws/lambda/ServiceAnnouncementMonitor'\n| fields @timestamp, @message\n| filter @message like /ERROR/\n| sort @timestamp desc\n| limit 20",
                    "region": "us-east-1",
                    "title": "Recent Errors",
                    "view": "table"
                }
            },
            {
                "type": "metric",
                "properties": {
                    "metrics": [
                        ["AWS/Lambda", "Duration", "FunctionName", "ServiceAnnouncementMonitor"],
                        ["AWS/Lambda", "Duration", "FunctionName", "ServiceEvaluator"],
                        ["AWS/Lambda", "Duration", "FunctionName", "RecommendationGenerator"]
                    ],
                    "period": 300,
                    "stat": "Average",
                    "region": "us-east-1",
                    "title": "Lambda Function Performance"
                }
            }
        ]
    }
    
    return {
        "dashboard_name": "ServiceEvaluationAutomation",
        "dashboard_body": json.dumps(dashboard_body)
    }

# Helper methods for data management
def is_announcement_processed(self, announcement_id: str) -> bool:
    """Check if announcement has already been processed"""
    try:
        response = self.announcements_table.get_item(
            Key={'announcement_id': announcement_id}
        )
        return 'Item' in response
    except Exception:
        return False

def store_announcement(self, announcement: ServiceAnnouncement):
    """Store announcement in DynamoDB"""
    try:
        self.announcements_table.put_item(
            Item={
                'announcement_id': announcement.announcement_id,
                'title': announcement.title,
                'description': announcement.description,
                'service_name': announcement.service_name,
                'category': announcement.category.value,
                'announcement_date': announcement.announcement_date.isoformat(),
                'source_url': announcement.source_url,
                'key_features': announcement.key_features,
                'pricing_model': announcement.pricing_model,
                'availability_regions': announcement.availability_regions
            }
        )
    except Exception as e:
        self.logger.error(f"Error storing announcement: {str(e)}")

def get_workload_profiles(self) -> List[WorkloadProfile]:
    """Get all workload profiles from DynamoDB"""
    try:
        response = self.workload_profiles_table.scan()
        profiles = []
        
        for item in response['Items']:
            profile = WorkloadProfile(
                workload_id=item['workload_id'],
                architecture_components=item.get('architecture_components', []),
                current_services=item.get('current_services', []),
                cost_profile=item.get('cost_profile', {}),
                performance_requirements=item.get('performance_requirements', {}),
                compliance_requirements=item.get('compliance_requirements', []),
                business_criticality=item.get('business_criticality', 'standard')
            )
            profiles.append(profile)
        
        return profiles
    except Exception as e:
        self.logger.error(f"Error getting workload profiles: {str(e)}")
        return []

def generate_announcement_id(self, source_id: str) -> str:
    """Generate unique announcement ID"""
    import hashlib
    return hashlib.md5(source_id.encode()).hexdigest()[:12]

def estimate_cost_impact(self, announcement: ServiceAnnouncement, 
                       profile: WorkloadProfile) -> float:
    """Estimate cost impact of adopting new service"""
    
    # This is a simplified estimation - in practice, you'd use more sophisticated models
    base_cost = profile.cost_profile.get('monthly_cost', 1000.0)
    
    # Positive impact factors
    if 'cost' in announcement.description.lower():
        return base_cost * 0.15  # Estimate 15% savings
    
    if announcement.pricing_model == 'pay-as-you-go':
        return base_cost * 0.10  # Estimate 10% savings
    
    if 'managed' in announcement.description.lower():
        return base_cost * 0.05  # Estimate 5% operational savings
    
    # Neutral or negative impact
    return 0.0

def assess_implementation_complexity(self, announcement: ServiceAnnouncement, 
                                   profile: WorkloadProfile) -> str:
    """Assess implementation complexity"""
    
    complexity_factors = 0
    
    # Check for integration complexity
    if len(profile.current_services) > 5:
        complexity_factors += 1
    
    # Check for compliance requirements
    if profile.compliance_requirements:
        complexity_factors += 1
    
    # Check for new technology
    if announcement.category not in [ServiceCategory.COMPUTE, ServiceCategory.STORAGE, ServiceCategory.DATABASE]:
        complexity_factors += 1
    
    if complexity_factors >= 2:
        return "High"
    elif complexity_factors == 1:
        return "Medium"
    else:
        return "Low"

def perform_risk_assessment(self, announcement: ServiceAnnouncement, 
                          profile: WorkloadProfile) -> Dict[str, str]:
    """Perform risk assessment for service adoption"""
    
    risks = {
        'technical_risk': 'Low',
        'operational_risk': 'Low',
        'business_risk': 'Low',
        'overall_risk': 'Low'
    }
    
    # Assess technical risk
    if announcement.category in [ServiceCategory.MACHINE_LEARNING, ServiceCategory.ANALYTICS]:
        risks['technical_risk'] = 'Medium'
    
    # Assess operational risk
    if profile.business_criticality == 'critical':
        risks['operational_risk'] = 'Medium'
    
    # Assess business risk
    if profile.cost_profile.get('monthly_cost', 0) > 10000:
        risks['business_risk'] = 'Medium'
    
    # Calculate overall risk
    risk_levels = [risks['technical_risk'], risks['operational_risk'], risks['business_risk']]
    if 'High' in risk_levels:
        risks['overall_risk'] = 'High'
    elif 'Medium' in risk_levels:
        risks['overall_risk'] = 'Medium'
    
    return risks

def create_evaluation_rationale(self, announcement: ServiceAnnouncement, 
                              profile: WorkloadProfile, relevance_score: float,
                              benefits: List[str], recommendation: AdoptionRecommendation) -> str:
    """Create rationale for evaluation recommendation"""
    
    rationale = f"Service '{announcement.service_name}' evaluated for workload '{profile.workload_id}' "
    rationale += f"with relevance score {relevance_score:.2f}. "
    
    if benefits:
        rationale += f"Potential benefits include: {', '.join(benefits[:3])}. "
    
    if recommendation == AdoptionRecommendation.IMMEDIATE:
        rationale += "Immediate adoption recommended due to high relevance and clear benefits."
    elif recommendation == AdoptionRecommendation.PILOT:
        rationale += "Pilot program recommended to validate benefits and assess implementation."
    elif recommendation == AdoptionRecommendation.EVALUATE:
        rationale += "Further evaluation recommended to assess fit and implementation approach."
    elif recommendation == AdoptionRecommendation.MONITOR:
        rationale += "Service should be monitored for future relevance as workload evolves."
    else:
        rationale += "Service not currently applicable to this workload."
    
    return rationale

def calculate_next_review_date(self, recommendation: AdoptionRecommendation, 
                             relevance_level: RelevanceLevel) -> datetime:
    """Calculate when to next review this service-workload combination"""
    
    if recommendation == AdoptionRecommendation.IMMEDIATE:
        return datetime.now() + timedelta(days=30)  # Review in 1 month
    elif recommendation == AdoptionRecommendation.PILOT:
        return datetime.now() + timedelta(days=60)  # Review in 2 months
    elif recommendation == AdoptionRecommendation.EVALUATE:
        return datetime.now() + timedelta(days=90)  # Review in 3 months
    elif recommendation == AdoptionRecommendation.MONITOR:
        return datetime.now() + timedelta(days=180)  # Review in 6 months
    else:
        return datetime.now() + timedelta(days=365)  # Review in 1 year

def store_evaluation_result(self, evaluation: ServiceEvaluationResult):
    """Store evaluation result in DynamoDB"""
    try:
        self.evaluations_table.put_item(
            Item={
                'evaluation_id': evaluation.evaluation_id,
                'workload_id': evaluation.workload_id,
                'service_name': evaluation.service_announcement.service_name,
                'relevance_level': evaluation.relevance_level.value,
                'relevance_score': evaluation.relevance_score,
                'potential_benefits': evaluation.potential_benefits,
                'estimated_cost_impact': evaluation.estimated_cost_impact,
                'implementation_complexity': evaluation.implementation_complexity,
                'recommendation': evaluation.recommendation.value,
                'rationale': evaluation.rationale,
                'evaluation_date': evaluation.evaluation_date.isoformat(),
                'next_review_date': evaluation.next_review_date.isoformat()
            }
        )
    except Exception as e:
        self.logger.error(f"Error storing evaluation result: {str(e)}")

# Initialize the automation system
automation = ServiceEvaluationAutomation()

# Set up the infrastructure
print("Setting up automation infrastructure...")
infrastructure = automation.setup_automation_infrastructure()

print("Infrastructure components created:")
for component_type, components in infrastructure.items():
    print(f"- {component_type}: {len(components) if isinstance(components, list) else 1} items")

# Create sample workload profiles
sample_workloads = [
    {
        'workload_id': 'ecommerce-platform',
        'architecture_components': ['EC2', 'RDS', 'S3', 'CloudFront', 'ELB'],
        'current_services': ['Amazon EC2', 'Amazon RDS', 'Amazon S3'],
        'cost_profile': {'monthly_cost': 5000.0},
        'performance_requirements': {'response_time': 2.0, 'availability': 99.9},
        'compliance_requirements': ['PCI-DSS'],
        'business_criticality': 'critical'
    },
    {
        'workload_id': 'data-analytics',
        'architecture_components': ['EMR', 'S3', 'Redshift', 'Glue'],
        'current_services': ['Amazon EMR', 'Amazon S3', 'Amazon Redshift'],
        'cost_profile': {'monthly_cost': 8000.0},
        'performance_requirements': {'processing_time': 3600, 'throughput': 1000},
        'compliance_requirements': [],
        'business_criticality': 'important'
    }
]

# Store workload profiles
for workload_data in sample_workloads:
    automation.workload_profiles_table.put_item(Item=workload_data)
    print(f"Stored workload profile: {workload_data['workload_id']}")

print("✅ Automation setup complete!")

# Process service announcements manually (for testing)
print("🔍 Monitoring AWS service announcements...")
announcements = automation.monitor_service_announcements()

print(f"Found {len(announcements)} new announcements:")
for announcement in announcements:
    print(f"- {announcement.title}")
    print(f"  Service: {announcement.service_name}")
    print(f"  Category: {announcement.category.value}")
    print(f"  Date: {announcement.announcement_date.strftime('%Y-%m-%d')}")
    print()

# Evaluate announcements against workloads
if announcements:
    print("📊 Evaluating services against workloads...")
    
    for announcement in announcements[:3]:  # Process first 3 announcements
        print(f"\nEvaluating: {announcement.service_name}")
        
        evaluations = automation.evaluate_service_for_workloads(announcement)
        
        # Display results
        for evaluation in evaluations:
            print(f"  Workload: {evaluation.workload_id}")
            print(f"  Relevance: {evaluation.relevance_level.value} ({evaluation.relevance_score:.2f})")
            print(f"  Recommendation: {evaluation.recommendation.value}")
            print(f"  Cost Impact: ${evaluation.estimated_cost_impact:.2f}")
            print(f"  Rationale: {evaluation.rationale[:100]}...")
            print()
        
        # Send recommendations
        automation.send_recommendations(evaluations)

def create_automated_evaluation_pipeline():
    """Create a complete automated evaluation pipeline"""
    
    automation = ServiceEvaluationAutomation()
    
    # Lambda function code for announcement monitoring
    announcement_monitor_code = '''
import json
import boto3
import feedparser
from datetime import datetime

def lambda_handler(event, context):
    """Lambda function to monitor AWS service announcements"""
    
    automation = ServiceEvaluationAutomation()
    
    try:
        # Monitor announcements
        announcements = automation.monitor_service_announcements()
        
        # Trigger evaluations for new announcements
        for announcement in announcements:
            # Send to evaluation queue
            sqs = boto3.client('sqs')
            sqs.send_message(
                QueueUrl=os.environ['EVALUATION_QUEUE_URL'],
                MessageBody=json.dumps({
                    'announcement_id': announcement.announcement_id,
                    'service_name': announcement.service_name,
                    'category': announcement.category.value
                })
            )
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'announcements_processed': len(announcements),
                'timestamp': datetime.now().isoformat()
            })
        }
        
    except Exception as e:
        print(f"Error in announcement monitoring: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }
    '''
    
    # Lambda function code for service evaluation
    service_evaluator_code = '''
import json
import boto3
from datetime import datetime

def lambda_handler(event, context):
    """Lambda function to evaluate services against workloads"""
    
    automation = ServiceEvaluationAutomation()
    
    try:
        # Process SQS messages
        evaluations_completed = 0
        
        for record in event['Records']:
            message = json.loads(record['body'])
            announcement_id = message['announcement_id']
            
            # Get announcement details
            announcement = automation.get_announcement(announcement_id)
            if not announcement:
                continue
            
            # Evaluate against all workloads
            evaluations = automation.evaluate_service_for_workloads(announcement)
            evaluations_completed += len(evaluations)
            
            # Send recommendations
            automation.send_recommendations(evaluations)
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'evaluations_completed': evaluations_completed,
                'timestamp': datetime.now().isoformat()
            })
        }
        
    except Exception as e:
        print(f"Error in service evaluation: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }
    '''
    
    return {
        'announcement_monitor_code': announcement_monitor_code,
        'service_evaluator_code': service_evaluator_code,
        'infrastructure_template': automation.create_automation_dashboard()
    }

# Create the pipeline
pipeline = create_automated_evaluation_pipeline()
print("🚀 Automated evaluation pipeline created!")
print("Deploy the Lambda functions and infrastructure to activate automation.")

EventBridge_Rules:
  announcement_monitoring:
    rule_name: "ServiceAnnouncementMonitoring"
    schedule_expression: "rate(1 hour)"
    target:
      lambda_function: "ServiceAnnouncementMonitor"
      input_transformer:
        input_paths:
          timestamp: "$.time"
        input_template: '{"trigger_time": "<timestamp>"}'
    
  evaluation_processing:
    rule_name: "ServiceEvaluationProcessing"
    event_pattern:
      source: ["aws.dynamodb"]
      detail_type: ["DynamoDB Stream Record"]
      detail:
        eventSource: ["aws:dynamodb"]
        eventName: ["INSERT"]
        dynamodb:
          Keys:
            announcement_id:
              S: [{"exists": true}]
    target:
      lambda_function: "ServiceEvaluator"
    
  recommendation_alerts:
    rule_name: "RecommendationAlerts"
    event_pattern:
      source: ["custom.service-evaluation"]
      detail_type: ["High Priority Recommendation"]
    targets:
      - sns_topic: "arn:aws:sns:us-east-1:123456789012:high-priority-alerts"
      - lambda_function: "RecommendationProcessor"

DynamoDB_Tables:
  service_announcements:
    table_name: "ServiceAnnouncements"
    partition_key: "announcement_id"
    attributes:
      - name: "announcement_id"
        type: "S"
      - name: "service_name"
        type: "S"
      - name: "category"
        type: "S"
    global_secondary_indexes:
      - index_name: "ServiceNameIndex"
        partition_key: "service_name"
        sort_key: "announcement_date"
    stream_specification:
      stream_enabled: true
      stream_view_type: "NEW_AND_OLD_IMAGES"
    
  service_evaluations:
    table_name: "ServiceEvaluations"
    partition_key: "evaluation_id"
    sort_key: "workload_id"
    attributes:
      - name: "evaluation_id"
        type: "S"
      - name: "workload_id"
        type: "S"
      - name: "recommendation"
        type: "S"
    global_secondary_indexes:
      - index_name: "WorkloadRecommendationIndex"
        partition_key: "workload_id"
        sort_key: "recommendation"
    
  workload_profiles:
    table_name: "WorkloadProfiles"
    partition_key: "workload_id"
    attributes:
      - name: "workload_id"
        type: "S"
      - name: "business_criticality"
        type: "S"
    global_secondary_indexes:
      - index_name: "CriticalityIndex"
        partition_key: "business_criticality"

SNS_Topics:
  high_priority_alerts:
    topic_name: "HighPriorityServiceAlerts"
    display_name: "High Priority Service Evaluation Alerts"
    subscriptions:
      - protocol: "email"
        endpoint: "architecture-team@company.com"
      - protocol: "sms"
        endpoint: "+1234567890"
    
  medium_priority_alerts:
    topic_name: "MediumPriorityServiceAlerts"
    display_name: "Medium Priority Service Evaluation Alerts"
    subscriptions:
      - protocol: "email"
        endpoint: "cost-optimization-team@company.com"

CloudWatch_Alarms:
  evaluation_errors:
    alarm_name: "ServiceEvaluationErrors"
    metric_name: "Errors"
    namespace: "AWS/Lambda"
    dimensions:
      FunctionName: "ServiceEvaluator"
    statistic: "Sum"
    period: 300
    evaluation_periods: 2
    threshold: 5
    comparison_operator: "GreaterThanThreshold"
    alarm_actions:
      - "arn:aws:sns:us-east-1:123456789012:lambda-errors"
    
  high_priority_recommendations:
    alarm_name: "HighPriorityRecommendations"
    metric_name: "HighPriorityRecommendations"
    namespace: "ServiceEvaluation"
    statistic: "Sum"
    period: 3600
    evaluation_periods: 1
    threshold: 3
    comparison_operator: "GreaterThanThreshold"
    alarm_actions:
      - "arn:aws:sns:us-east-1:123456789012:high-priority-alerts"