COST07-BP03 - Select third-party agreements with cost-efficient terms

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

@dataclass
class ThirdPartyService:
    service_name: str
    vendor: str
    category: str
    pricing_model: str
    current_monthly_cost: float
    contract_term: str
    renewal_date: datetime
    usage_metrics: Dict
    alternatives: List[str]

@dataclass
class PricingModel:
    model_type: str  # subscription, usage-based, per-seat, hybrid
    base_cost: float
    variable_cost: float
    minimum_commitment: float
    volume_discounts: List[Dict]
    contract_terms: Dict

@dataclass
class VendorRecommendation:
    service_name: str
    current_vendor: str
    recommended_action: str  # negotiate, switch, consolidate, eliminate
    potential_savings: float
    implementation_effort: str
    risk_level: str
    rationale: str

class ThirdPartyCostOptimizer:
    def __init__(self):
        self.ce_client = boto3.client('ce')
        self.marketplace = boto3.client('marketplace-catalog')
        self.license_manager = boto3.client('license-manager')
        
        # Service categories for analysis
        self.service_categories = {
            'security': ['security_tools', 'compliance', 'monitoring'],
            'data_analytics': ['data_processing', 'business_intelligence', 'machine_learning'],
            'development': ['ci_cd', 'testing', 'code_analysis'],
            'operations': ['monitoring', 'logging', 'automation'],
            'business_applications': ['crm', 'erp', 'collaboration']
        }
        
    def analyze_third_party_costs(self, services: List[ThirdPartyService]) -> Dict:
        """Analyze third-party service costs and generate optimization recommendations"""
        
        analysis_results = {
            'analysis_date': datetime.now().isoformat(),
            'total_services': len(services),
            'service_analysis': {},
            'category_analysis': {},
            'recommendations': [],
            'cost_summary': {},
            'contract_analysis': {}
        }
        
        # Analyze each service
        for service in services:
            service_analysis = self.analyze_single_service(service)
            analysis_results['service_analysis'][service.service_name] = service_analysis
        
        # Analyze by category
        analysis_results['category_analysis'] = self.analyze_by_category(services)
        
        # Generate recommendations
        analysis_results['recommendations'] = self.generate_vendor_recommendations(services)
        
        # Cost summary
        analysis_results['cost_summary'] = self.create_cost_summary(services)
        
        # Contract analysis
        analysis_results['contract_analysis'] = self.analyze_contract_terms(services)
        
        return analysis_results
    
    def analyze_single_service(self, service: ThirdPartyService) -> Dict:
        """Analyze a single third-party service"""
        
        analysis = {
            'service_name': service.service_name,
            'vendor': service.vendor,
            'current_monthly_cost': service.current_monthly_cost,
            'annual_cost': service.current_monthly_cost * 12,
            'usage_efficiency': self.calculate_usage_efficiency(service),
            'pricing_model_analysis': self.analyze_pricing_model(service),
            'contract_status': self.analyze_contract_status(service),
            'alternatives_analysis': self.analyze_alternatives(service),
            'optimization_opportunities': []
        }
        
        # Identify optimization opportunities
        if analysis['usage_efficiency'] < 0.7:
            analysis['optimization_opportunities'].append({
                'type': 'usage_optimization',
                'description': 'Low usage efficiency detected',
                'potential_savings': service.current_monthly_cost * 0.3
            })
        
        if analysis['contract_status']['renewal_within_90_days']:
            analysis['optimization_opportunities'].append({
                'type': 'contract_renegotiation',
                'description': 'Contract renewal opportunity',
                'potential_savings': service.current_monthly_cost * 0.15
            })
        
        return analysis
    
    def calculate_usage_efficiency(self, service: ThirdPartyService) -> float:
        """Calculate usage efficiency for a service"""
        
        if not service.usage_metrics:
            return 0.5  # Default neutral score
        
        # Calculate efficiency based on service type
        if service.pricing_model == 'per-seat':
            active_users = service.usage_metrics.get('active_users', 0)
            licensed_users = service.usage_metrics.get('licensed_users', 1)
            return active_users / licensed_users if licensed_users > 0 else 0
        
        elif service.pricing_model == 'usage-based':
            actual_usage = service.usage_metrics.get('actual_usage', 0)
            committed_usage = service.usage_metrics.get('committed_usage', 1)
            return actual_usage / committed_usage if committed_usage > 0 else 0
        
        elif service.pricing_model == 'subscription':
            feature_utilization = service.usage_metrics.get('feature_utilization', 50)
            return feature_utilization / 100
        
        return 0.5
    
    def analyze_pricing_model(self, service: ThirdPartyService) -> Dict:
        """Analyze the pricing model of a service"""
        
        analysis = {
            'current_model': service.pricing_model,
            'cost_predictability': self.assess_cost_predictability(service.pricing_model),
            'scaling_efficiency': self.assess_scaling_efficiency(service.pricing_model),
            'alternative_models': self.identify_alternative_pricing_models(service),
            'optimization_potential': 0
        }
        
        # Calculate optimization potential
        if service.pricing_model == 'per-seat' and service.usage_metrics.get('active_users', 0) < service.usage_metrics.get('licensed_users', 1) * 0.7:
            analysis['optimization_potential'] = 0.3
        elif service.pricing_model == 'subscription' and service.usage_metrics.get('feature_utilization', 50) < 50:
            analysis['optimization_potential'] = 0.2
        
        return analysis
    
    def analyze_contract_terms(self, services: List[ThirdPartyService]) -> Dict:
        """Analyze contract terms across all services"""
        
        contract_analysis = {
            'total_contracts': len(services),
            'renewal_schedule': {},
            'contract_terms_summary': {},
            'negotiation_opportunities': [],
            'consolidation_opportunities': []
        }
        
        # Analyze renewal schedule
        for service in services:
            renewal_month = service.renewal_date.strftime('%Y-%m')
            if renewal_month not in contract_analysis['renewal_schedule']:
                contract_analysis['renewal_schedule'][renewal_month] = []
            contract_analysis['renewal_schedule'][renewal_month].append({
                'service': service.service_name,
                'vendor': service.vendor,
                'monthly_cost': service.current_monthly_cost
            })
        
        # Identify negotiation opportunities
        for service in services:
            days_to_renewal = (service.renewal_date - datetime.now()).days
            if days_to_renewal <= 90:
                contract_analysis['negotiation_opportunities'].append({
                    'service': service.service_name,
                    'vendor': service.vendor,
                    'days_to_renewal': days_to_renewal,
                    'annual_value': service.current_monthly_cost * 12,
                    'negotiation_priority': self.calculate_negotiation_priority(service)
                })
        
        # Identify consolidation opportunities
        vendor_services = {}
        for service in services:
            if service.vendor not in vendor_services:
                vendor_services[service.vendor] = []
            vendor_services[service.vendor].append(service)
        
        for vendor, vendor_service_list in vendor_services.items():
            if len(vendor_service_list) > 1:
                total_spend = sum(s.current_monthly_cost * 12 for s in vendor_service_list)
                contract_analysis['consolidation_opportunities'].append({
                    'vendor': vendor,
                    'services_count': len(vendor_service_list),
                    'total_annual_spend': total_spend,
                    'potential_discount': total_spend * 0.1  # Assume 10% volume discount
                })
        
        return contract_analysis
    
    def generate_vendor_recommendations(self, services: List[ThirdPartyService]) -> List[VendorRecommendation]:
        """Generate vendor optimization recommendations"""
        
        recommendations = []
        
        for service in services:
            # Analyze current service
            usage_efficiency = self.calculate_usage_efficiency(service)
            contract_status = self.analyze_contract_status(service)
            alternatives = self.analyze_alternatives(service)
            
            # Generate recommendations based on analysis
            if usage_efficiency < 0.5:
                recommendations.append(VendorRecommendation(
                    service_name=service.service_name,
                    current_vendor=service.vendor,
                    recommended_action='optimize_usage',
                    potential_savings=service.current_monthly_cost * 0.3,
                    implementation_effort='low',
                    risk_level='low',
                    rationale=f'Low usage efficiency ({usage_efficiency:.1%}) indicates over-provisioning'
                ))
            
            if contract_status['renewal_within_90_days'] and service.current_monthly_cost > 1000:
                recommendations.append(VendorRecommendation(
                    service_name=service.service_name,
                    current_vendor=service.vendor,
                    recommended_action='renegotiate_contract',
                    potential_savings=service.current_monthly_cost * 0.15,
                    implementation_effort='medium',
                    risk_level='low',
                    rationale='Contract renewal opportunity for high-value service'
                ))
            
            # Check for better alternatives
            if alternatives['aws_native_alternative']:
                cost_comparison = self.compare_with_aws_native(service, alternatives['aws_native_alternative'])
                if cost_comparison['potential_savings'] > 0:
                    recommendations.append(VendorRecommendation(
                        service_name=service.service_name,
                        current_vendor=service.vendor,
                        recommended_action='switch_to_aws_native',
                        potential_savings=cost_comparison['potential_savings'],
                        implementation_effort=cost_comparison['implementation_effort'],
                        risk_level=cost_comparison['risk_level'],
                        rationale=f'AWS native alternative could save ${cost_comparison["potential_savings"]:.2f}/month'
                    ))
        
        # Sort recommendations by potential savings
        recommendations.sort(key=lambda x: x.potential_savings, reverse=True)
        
        return recommendations
    
    def create_marketplace_cost_analysis(self) -> Dict:
        """Analyze AWS Marketplace costs and optimization opportunities"""
        
        marketplace_analysis = {
            'analysis_date': datetime.now().isoformat(),
            'marketplace_spending': {},
            'product_analysis': {},
            'optimization_opportunities': [],
            'pricing_model_recommendations': {}
        }
        
        # Get marketplace spending data
        try:
            end_date = datetime.now()
            start_date = end_date - timedelta(days=90)
            
            response = self.ce_client.get_cost_and_usage(
                TimePeriod={
                    'Start': start_date.strftime('%Y-%m-%d'),
                    'End': end_date.strftime('%Y-%m-%d')
                },
                Granularity='MONTHLY',
                Metrics=['BlendedCost'],
                GroupBy=[
                    {'Type': 'DIMENSION', 'Key': 'SERVICE'},
                    {'Type': 'DIMENSION', 'Key': 'USAGE_TYPE'}
                ],
                Filter={
                    'Dimensions': {
                        'Key': 'SERVICE',
                        'Values': ['AWSMarketplace']
                    }
                }
            )
            
            # Process marketplace spending data
            for result in response['ResultsByTime']:
                month = result['TimePeriod']['Start']
                marketplace_analysis['marketplace_spending'][month] = {}
                
                for group in result['Groups']:
                    service_name = group['Keys'][0]
                    usage_type = group['Keys'][1]
                    cost = float(group['Metrics']['BlendedCost']['Amount'])
                    
                    if service_name not in marketplace_analysis['marketplace_spending'][month]:
                        marketplace_analysis['marketplace_spending'][month][service_name] = 0
                    marketplace_analysis['marketplace_spending'][month][service_name] += cost
            
        except Exception as e:
            print(f"Error retrieving marketplace data: {e}")
        
        return marketplace_analysis
    
    def implement_third_party_cost_governance(self) -> Dict:
        """Implement governance framework for third-party costs"""
        
        governance_framework = {
            'approval_workflows': self.create_approval_workflows(),
            'cost_controls': self.create_cost_controls(),
            'monitoring_framework': self.create_monitoring_framework(),
            'vendor_management': self.create_vendor_management_process()
        }
        
        return governance_framework
    
    def create_approval_workflows(self) -> Dict:
        """Create approval workflows for third-party services"""
        
        workflows = {
            'new_service_approval': {
                'triggers': ['New third-party service request'],
                'approval_levels': [
                    {
                        'level': 1,
                        'approver': 'Team Lead',
                        'threshold': 500,  # Monthly cost threshold
                        'criteria': ['Business justification', 'Cost analysis']
                    },
                    {
                        'level': 2,
                        'approver': 'Finance Manager',
                        'threshold': 2000,
                        'criteria': ['Budget impact', 'Alternative analysis']
                    },
                    {
                        'level': 3,
                        'approver': 'CTO/CFO',
                        'threshold': 10000,
                        'criteria': ['Strategic alignment', 'ROI analysis']
                    }
                ]
            },
            'contract_renewal_approval': {
                'triggers': ['Contract renewal within 90 days'],
                'required_analysis': [
                    'Usage efficiency review',
                    'Cost trend analysis',
                    'Alternative evaluation',
                    'Negotiation strategy'
                ]
            },
            'cost_increase_approval': {
                'triggers': ['Monthly cost increase > 20%'],
                'immediate_actions': [
                    'Usage analysis',
                    'Vendor communication',
                    'Cost optimization review'
                ]
            }
        }
        
        return workflows
    
    def create_vendor_scorecard_system(self) -> Dict:
        """Create comprehensive vendor scorecard system"""
        
        scorecard_system = {
            'evaluation_criteria': {
                'cost_efficiency': {
                    'weight': 0.3,
                    'metrics': [
                        'Total cost of ownership',
                        'Price competitiveness',
                        'Hidden costs assessment',
                        'Volume discount availability'
                    ]
                },
                'service_quality': {
                    'weight': 0.25,
                    'metrics': [
                        'Service availability',
                        'Performance metrics',
                        'Feature completeness',
                        'User satisfaction'
                    ]
                },
                'contract_terms': {
                    'weight': 0.2,
                    'metrics': [
                        'Contract flexibility',
                        'Termination terms',
                        'Pricing transparency',
                        'SLA commitments'
                    ]
                },
                'vendor_relationship': {
                    'weight': 0.15,
                    'metrics': [
                        'Support responsiveness',
                        'Account management',
                        'Strategic partnership',
                        'Innovation roadmap'
                    ]
                },
                'risk_factors': {
                    'weight': 0.1,
                    'metrics': [
                        'Vendor stability',
                        'Security compliance',
                        'Data privacy',
                        'Business continuity'
                    ]
                }
            },
            'scoring_methodology': {
                'scale': '1-5 (5 being best)',
                'frequency': 'Quarterly',
                'review_process': 'Cross-functional team review',
                'action_thresholds': {
                    'excellent': 4.5,
                    'good': 3.5,
                    'needs_improvement': 2.5,
                    'critical': 1.5
                }
            }
        }
        
        return scorecard_system
    
    def analyze_contract_status(self, service: ThirdPartyService) -> Dict:
        """Analyze contract status for a service"""
        
        days_to_renewal = (service.renewal_date - datetime.now()).days
        
        return {
            'renewal_date': service.renewal_date.isoformat(),
            'days_to_renewal': days_to_renewal,
            'renewal_within_90_days': days_to_renewal <= 90,
            'contract_term': service.contract_term,
            'auto_renewal': True,  # Would be determined from contract terms
            'negotiation_window': days_to_renewal <= 120
        }
    
    def analyze_alternatives(self, service: ThirdPartyService) -> Dict:
        """Analyze alternatives for a service"""
        
        # This would implement comprehensive alternative analysis
        # For demonstration, returning sample data
        
        return {
            'aws_native_alternative': self.find_aws_native_alternative(service),
            'competitor_alternatives': self.find_competitor_alternatives(service),
            'open_source_alternatives': self.find_open_source_alternatives(service),
            'build_vs_buy_analysis': self.analyze_build_vs_buy(service)
        }
    
    def find_aws_native_alternative(self, service: ThirdPartyService) -> Optional[Dict]:
        """Find AWS native alternatives for a service"""
        
        # Mapping of common third-party services to AWS alternatives
        aws_alternatives = {
            'monitoring': {
                'service': 'Amazon CloudWatch',
                'estimated_cost_reduction': 0.3,
                'feature_parity': 0.8
            },
            'logging': {
                'service': 'Amazon CloudWatch Logs',
                'estimated_cost_reduction': 0.4,
                'feature_parity': 0.9
            },
            'security_scanning': {
                'service': 'Amazon Inspector',
                'estimated_cost_reduction': 0.5,
                'feature_parity': 0.7
            }
        }
        
        return aws_alternatives.get(service.category)

Vendor_Cost_Analysis:
  analysis_id: "VENDOR-COST-2024-001"
  analysis_date: "2024-01-15"
  analysis_period: "Q4 2023"
  
  vendor_portfolio:
    total_vendors: 15
    total_monthly_cost: 8500.00
    total_annual_cost: 102000.00
    
  vendor_breakdown:
    security_tools:
      - vendor: "SecurityVendor A"
        services: ["SIEM", "Vulnerability Scanning"]
        monthly_cost: 2500.00
        contract_term: "3 years"
        renewal_date: "2024-06-30"
        usage_efficiency: 0.65
        
    monitoring_tools:
      - vendor: "MonitoringVendor B"
        services: ["APM", "Infrastructure Monitoring"]
        monthly_cost: 1800.00
        contract_term: "1 year"
        renewal_date: "2024-03-15"
        usage_efficiency: 0.85
        
    development_tools:
      - vendor: "DevVendor C"
        services: ["CI/CD", "Code Analysis"]
        monthly_cost: 1200.00
        contract_term: "2 years"
        renewal_date: "2024-12-31"
        usage_efficiency: 0.45
        
  optimization_opportunities:
    immediate_actions:
      - action: "Renegotiate SecurityVendor A contract"
        potential_savings: 375.00
        effort: "Medium"
        timeline: "30 days"
        
      - action: "Optimize DevVendor C usage"
        potential_savings: 360.00
        effort: "Low"
        timeline: "14 days"
        
    strategic_initiatives:
      - action: "Evaluate AWS native alternatives"
        potential_savings: 1200.00
        effort: "High"
        timeline: "90 days"
        
      - action: "Consolidate monitoring tools"
        potential_savings: 600.00
        effort: "Medium"
        timeline: "60 days"
        
  contract_calendar:
    q1_2024:
      - service: "MonitoringVendor B"
        action: "Renewal negotiation"
        annual_value: 21600.00
        
    q2_2024:
      - service: "SecurityVendor A"
        action: "Contract renegotiation"
        annual_value: 30000.00
        
  savings_summary:
    total_potential_savings: 2535.00
    percentage_savings: 29.8
    implementation_timeline: "90 days"
    risk_level: "Low-Medium"

def create_vendor_evaluation_framework():
    """Create comprehensive vendor evaluation framework"""
    
    framework = {
        'evaluation_phases': {
            'initial_screening': {
                'criteria': [
                    'Basic functionality requirements',
                    'Pricing transparency',
                    'Security compliance',
                    'Vendor stability'
                ],
                'pass_threshold': 0.7
            },
            'detailed_evaluation': {
                'criteria': [
                    'Total cost of ownership analysis',
                    'Feature comparison matrix',
                    'Integration complexity assessment',
                    'Support and SLA evaluation'
                ],
                'scoring_method': 'weighted_average'
            },
            'pilot_testing': {
                'duration': '30-60 days',
                'success_criteria': [
                    'Functionality validation',
                    'Performance benchmarks',
                    'Cost validation',
                    'User acceptance'
                ]
            }
        },
        
        'cost_analysis_methodology': {
            'direct_costs': [
                'License fees',
                'Subscription costs',
                'Usage-based charges',
                'Implementation costs'
            ],
            'indirect_costs': [
                'Training costs',
                'Integration effort',
                'Operational overhead',
                'Opportunity costs'
            ],
            'hidden_costs': [
                'Data egress fees',
                'Premium support costs',
                'Compliance requirements',
                'Vendor lock-in risks'
            ]
        },
        
        'negotiation_strategies': {
            'preparation': [
                'Market research and benchmarking',
                'Usage pattern analysis',
                'Alternative options identification',
                'Internal stakeholder alignment'
            ],
            'negotiation_points': [
                'Volume discounts',
                'Multi-year commitments',
                'Flexible usage terms',
                'Performance guarantees',
                'Termination clauses'
            ],
            'success_metrics': [
                'Cost reduction achieved',
                'Contract flexibility gained',
                'Risk mitigation improvements',
                'Service level enhancements'
            ]
        }
    }
    
    return framework