import oci
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
import warnings
warnings.filterwarnings('ignore')

class OCIFinOpsAnalytics:
    def __init__(self, config_file="~/.oci/config"):
        """
        Initialize OCI FinOps Analytics with advanced ML capabilities
        """
        self.config = oci.config.from_file(config_file)
        self.usage_client = oci.usage_api.UsageapiClient(self.config)
        self.monitoring_client = oci.monitoring.MonitoringClient(self.config)
        self.analytics_client = oci.analytics.AnalyticsClient(self.config)
        
        # Initialize ML models for anomaly detection and forecasting
        self.anomaly_detector = IsolationForest(contamination=0.1, random_state=42)
        self.cost_forecaster = LinearRegression()
        self.scaler = StandardScaler()
        
    def collect_comprehensive_usage_data(self, tenancy_id, days_back=90):
        """
        Collect detailed usage and cost data across all OCI services
        """
        end_time = datetime.utcnow()
        start_time = end_time - timedelta(days=days_back)
        
        # Request detailed usage data
        request_usage_details = oci.usage_api.models.RequestSummarizedUsagesDetails(
            tenant_id=tenancy_id,
            time_usage_started=start_time,
            time_usage_ended=end_time,
            granularity="DAILY",
            group_by=["service", "resourceId", "compartmentName"]
        )
        
        try:
            usage_response = self.usage_client.request_summarized_usages(
                request_usage_details
            )
            
            # Convert to structured data
            usage_data = []
            for item in usage_response.data.items:
                usage_data.append({
                    'date': item.time_usage_started.date(),
                    'service': item.service,
                    'resource_id': item.resource_id,
                    'compartment': item.compartment_name,
                    'computed_amount': float(item.computed_amount) if item.computed_amount else 0,
                    'computed_quantity': float(item.computed_quantity) if item.computed_quantity else 0,
                    'unit': item.unit,
                    'currency': item.currency
                })
            
            return pd.DataFrame(usage_data)
            
        except Exception as e:
            print(f"Error collecting usage data: {e}")
            return pd.DataFrame()
    
    def perform_anomaly_detection(self, cost_data):
        """
        Use ML to detect cost anomalies and unusual spending patterns
        """
        # Prepare features for anomaly detection
        daily_costs = cost_data.groupby(['date', 'service'])['computed_amount'].sum().reset_index()
        
        # Create feature matrix
        features_list = []
        for service in daily_costs['service'].unique():
            service_data = daily_costs[daily_costs['service'] == service].copy()
            service_data = service_data.sort_values('date')
            
            # Calculate rolling statistics
            service_data['rolling_mean_7d'] = service_data['computed_amount'].rolling(7, min_periods=1).mean()
            service_data['rolling_std_7d'] = service_data['computed_amount'].rolling(7, min_periods=1).std()
            service_data['rolling_mean_30d'] = service_data['computed_amount'].rolling(30, min_periods=1).mean()
            
            # Calculate percentage change
            service_data['pct_change'] = service_data['computed_amount'].pct_change()
            service_data['days_since_start'] = (service_data['date'] - service_data['date'].min()).dt.days
            
            # Create features for anomaly detection
            features = service_data[['computed_amount', 'rolling_mean_7d', 'rolling_std_7d', 
                                   'rolling_mean_30d', 'pct_change', 'days_since_start']].fillna(0)
            
            if len(features) > 5:  # Need sufficient data points
                # Scale features
                features_scaled = self.scaler.fit_transform(features)
                
                # Detect anomalies
                anomalies = self.anomaly_detector.fit_predict(features_scaled)
                
                service_data['anomaly'] = anomalies
                service_data['anomaly_score'] = self.anomaly_detector.decision_function(features_scaled)
                
                features_list.append(service_data)
        
        if features_list:
            return pd.concat(features_list, ignore_index=True)
        else:
            return pd.DataFrame()
    
    def forecast_costs_with_ml(self, cost_data, forecast_days=30):
        """
        Generate ML-powered cost forecasts with confidence intervals
        """
        forecasts = {}
        
        # Group by service for individual forecasting
        for service in cost_data['service'].unique():
            service_data = cost_data[cost_data['service'] == service].copy()
            daily_costs = service_data.groupby('date')['computed_amount'].sum().reset_index()
            daily_costs = daily_costs.sort_values('date')
            
            if len(daily_costs) < 14:  # Need minimum data for reliable forecast
                continue
                
            # Prepare features for forecasting
            daily_costs['days_since_start'] = (daily_costs['date'] - daily_costs['date'].min()).dt.days
            daily_costs['day_of_week'] = daily_costs['date'].dt.dayofweek
            daily_costs['month'] = daily_costs['date'].dt.month
            daily_costs['rolling_mean_7d'] = daily_costs['computed_amount'].rolling(7, min_periods=1).mean()
            daily_costs['rolling_mean_14d'] = daily_costs['computed_amount'].rolling(14, min_periods=1).mean()
            
            # Features for training
            feature_cols = ['days_since_start', 'day_of_week', 'month', 'rolling_mean_7d', 'rolling_mean_14d']
            X = daily_costs[feature_cols].fillna(method='ffill').fillna(0)
            y = daily_costs['computed_amount']
            
            # Train forecasting model
            self.cost_forecaster.fit(X, y)
            
            # Generate forecasts
            last_date = daily_costs['date'].max()
            forecast_dates = [last_date + timedelta(days=i) for i in range(1, forecast_days + 1)]
            
            forecast_features = []
            for i, future_date in enumerate(forecast_dates):
                last_row = daily_costs.iloc[-1].copy()
                
                features = {
                    'days_since_start': last_row['days_since_start'] + i + 1,
                    'day_of_week': future_date.weekday(),
                    'month': future_date.month,
                    'rolling_mean_7d': last_row['rolling_mean_7d'],
                    'rolling_mean_14d': last_row['rolling_mean_14d']
                }
                forecast_features.append(features)
            
            forecast_df = pd.DataFrame(forecast_features)
            predictions = self.cost_forecaster.predict(forecast_df[feature_cols])
            
            # Calculate confidence intervals (simplified approach)
            residuals = y - self.cost_forecaster.predict(X)
            std_residual = np.std(residuals)
            
            forecasts[service] = {
                'dates': forecast_dates,
                'predictions': predictions,
                'lower_bound': predictions - 1.96 * std_residual,
                'upper_bound': predictions + 1.96 * std_residual,
                'model_score': self.cost_forecaster.score(X, y)
            }
        
        return forecasts
    
    def analyze_resource_efficiency(self, cost_data, performance_data=None):
        """
        Analyze resource efficiency and identify optimization opportunities
        """
        efficiency_insights = {
            'underutilized_resources': [],
            'oversized_instances': [],
            'cost_optimization_opportunities': [],
            'efficiency_scores': {}
        }
        
        # Analyze cost trends by resource
        resource_analysis = cost_data.groupby(['service', 'resource_id']).agg({
            'computed_amount': ['sum', 'mean', 'std'],
            'computed_quantity': ['sum', 'mean', 'std']
        }).reset_index()
        
        resource_analysis.columns = ['service', 'resource_id', 'total_cost', 'avg_daily_cost', 
                                   'cost_volatility', 'total_usage', 'avg_daily_usage', 'usage_volatility']
        
        # Identify underutilized resources (high cost, low usage variance)
        for _, resource in resource_analysis.iterrows():
            if resource['total_cost'] > 100:  # Focus on significant costs
                efficiency_score = resource['avg_daily_usage'] / (resource['total_cost'] / 30)  # Usage per dollar
                
                if resource['usage_volatility'] < resource['avg_daily_usage'] * 0.1:  # Low usage variance
                    efficiency_insights['underutilized_resources'].append({
                        'service': resource['service'],
                        'resource_id': resource['resource_id'],
                        'total_cost': resource['total_cost'],
                        'efficiency_score': efficiency_score,
                        'recommendation': 'Consider downsizing or scheduled shutdown'
                    })
                
                efficiency_insights['efficiency_scores'][resource['resource_id']] = efficiency_score
        
        return efficiency_insights
    
    def generate_intelligent_recommendations(self, cost_data, anomalies, forecasts, efficiency_analysis):
        """
        Generate AI-powered cost optimization recommendations
        """
        recommendations = {
            'immediate_actions': [],
            'strategic_initiatives': [],
            'budget_adjustments': [],
            'automation_opportunities': []
        }
        
        # Immediate actions based on anomalies
        if not anomalies.empty:
            recent_anomalies = anomalies[anomalies['anomaly'] == -1]
            recent_anomalies = recent_anomalies[recent_anomalies['date'] >= (datetime.now().date() - timedelta(days=7))]
            
            for _, anomaly in recent_anomalies.iterrows():
                recommendations['immediate_actions'].append({
                    'priority': 'HIGH',
                    'service': anomaly['service'],
                    'issue': f"Cost anomaly detected: ${anomaly['computed_amount']:.2f} vs expected ${anomaly['rolling_mean_7d']:.2f}",
                    'action': 'Investigate resource usage and check for misconfiguration',
                    'potential_savings': abs(anomaly['computed_amount'] - anomaly['rolling_mean_7d'])
                })
        
        # Strategic initiatives based on forecasts
        total_forecasted_cost = 0
        for service, forecast in forecasts.items():
            monthly_forecast = sum(forecast['predictions'])
            total_forecasted_cost += monthly_forecast
            
            if monthly_forecast > 10000:  # High-cost services
                recommendations['strategic_initiatives'].append({
                    'service': service,
                    'forecasted_monthly_cost': monthly_forecast,
                    'confidence': forecast['model_score'],
                    'recommendation': 'Consider reserved capacity or committed use discounts',
                    'potential_savings': monthly_forecast * 0.2  # Assume 20% savings potential
                })
        
        # Budget adjustments
        if total_forecasted_cost > 0:
            recommendations['budget_adjustments'].append({
                'current_trend': 'INCREASING' if total_forecasted_cost > cost_data['computed_amount'].sum() else 'STABLE',
                'forecasted_monthly_spend': total_forecasted_cost,
                'recommended_budget': total_forecasted_cost * 1.15,  # 15% buffer
                'confidence_level': 'MEDIUM'
            })
        
        # Automation opportunities based on efficiency analysis
        for resource in efficiency_analysis['underutilized_resources'][:5]:  # Top 5 opportunities
            recommendations['automation_opportunities'].append({
                'resource_id': resource['resource_id'],
                'service': resource['service'],
                'automation_type': 'AUTO_SCALING',
                'estimated_savings': resource['total_cost'] * 0.3,  # Conservative 30% savings
                'implementation_complexity': 'MEDIUM'
            })
        
        return recommendations

def create_advanced_cost_dashboard(finops_analytics, tenancy_id):
    """
    Create a comprehensive FinOps dashboard with AI insights
    """
    print("🔄 Collecting comprehensive usage data...")
    cost_data = finops_analytics.collect_comprehensive_usage_data(tenancy_id, days_back=60)
    
    if cost_data.empty:
        print("❌ No cost data available")
        return
    
    print(f"✅ Collected {len(cost_data)} cost records")
    
    print("🤖 Performing AI-powered anomaly detection...")
    anomalies = finops_analytics.perform_anomaly_detection(cost_data)
    
    print("📈 Generating ML-powered cost forecasts...")
    forecasts = finops_analytics.forecast_costs_with_ml(cost_data, forecast_days=30)
    
    print("⚡ Analyzing resource efficiency...")
    efficiency_analysis = finops_analytics.analyze_resource_efficiency(cost_data)
    
    print("🧠 Generating intelligent recommendations...")
    recommendations = finops_analytics.generate_intelligent_recommendations(
        cost_data, anomalies, forecasts, efficiency_analysis
    )
    
    # Display results
    print("\n" + "="*60)
    print("FINOPS INTELLIGENCE DASHBOARD")
    print("="*60)
    
    # Cost Summary
    total_cost = cost_data['computed_amount'].sum()
    avg_daily_cost = cost_data.groupby('date')['computed_amount'].sum().mean()
    
    print(f"\n💰 COST SUMMARY")
    print(f"Total Cost (60 days): ${total_cost:,.2f}")
    print(f"Average Daily Cost: ${avg_daily_cost:,.2f}")
    print(f"Projected Monthly Cost: ${avg_daily_cost * 30:,.2f}")
    
    # Top services by cost
    top_services = cost_data.groupby('service')['computed_amount'].sum().sort_values(ascending=False).head(5)
    print(f"\n📊 TOP 5 SERVICES BY COST:")
    for service, cost in top_services.items():
        percentage = (cost / total_cost) * 100
        print(f"  {service}: ${cost:,.2f} ({percentage:.1f}%)")
    
    # Anomaly alerts
    if not anomalies.empty:
        recent_anomalies = anomalies[anomalies['anomaly'] == -1]
        recent_anomalies = recent_anomalies[recent_anomalies['date'] >= (datetime.now().date() - timedelta(days=7))]
        
        if not recent_anomalies.empty:
            print(f"\n🚨 RECENT COST ANOMALIES ({len(recent_anomalies)}):")
            for _, anomaly in recent_anomalies.head(3).iterrows():
                print(f"  {anomaly['service']}: ${anomaly['computed_amount']:.2f} on {anomaly['date']}")
                print(f"    Expected: ${anomaly['rolling_mean_7d']:.2f} (Deviation: {((anomaly['computed_amount']/anomaly['rolling_mean_7d'])-1)*100:.1f}%)")
    
    # Forecast summary
    if forecasts:
        print(f"\n📈 30-DAY COST FORECASTS:")
        for service, forecast in list(forecasts.items())[:3]:
            monthly_forecast = sum(forecast['predictions'])
            confidence = forecast['model_score']
            print(f"  {service}: ${monthly_forecast:,.2f} (Confidence: {confidence:.2f})")
    
    # Immediate recommendations
    if recommendations['immediate_actions']:
        print(f"\n⚡ IMMEDIATE ACTIONS REQUIRED:")
        for action in recommendations['immediate_actions'][:3]:
            print(f"  🔥 {action['priority']}: {action['issue']}")
            print(f"     Potential Savings: ${action['potential_savings']:.2f}")
    
    # Efficiency insights
    if efficiency_analysis['underutilized_resources']:
        print(f"\n💡 TOP OPTIMIZATION OPPORTUNITIES:")
        for resource in efficiency_analysis['underutilized_resources'][:3]:
            print(f"  {resource['service']} - {resource['resource_id'][:20]}...")
            print(f"    Cost: ${resource['total_cost']:.2f}, Efficiency Score: {resource['efficiency_score']:.3f}")
    
    return {
        'cost_data': cost_data,
        'anomalies': anomalies,
        'forecasts': forecasts,
        'efficiency_analysis': efficiency_analysis,
        'recommendations': recommendations
    }

from oci.resource_manager import ResourceManagerClient
from oci.identity import IdentityClient
from oci.budget import BudgetClient
import json

class OCIFinOpsGovernance:
    def __init__(self, config_file="~/.oci/config"):
        """
        Initialize automated governance framework for cost control
        """
        self.config = oci.config.from_file(config_file)
        self.budget_client = BudgetClient(self.config)
        self.identity_client = IdentityClient(self.config)
        self.resource_manager_client = ResourceManagerClient(self.config)
    
    def create_intelligent_budgets(self, compartment_id, forecasted_costs):
        """
        Create adaptive budgets based on ML forecasts
        """
        budgets_created = []
        
        for service, forecast_data in forecasted_costs.items():
            monthly_forecast = sum(forecast_data['predictions'])
            
            # Calculate adaptive budget with confidence intervals
            upper_bound = sum(forecast_data['upper_bound'])
            recommended_budget = upper_bound * 1.1  # 10% buffer above upper bound
            
            # Create budget
            budget_details = oci.budget.models.CreateBudgetDetails(
                compartment_id=compartment_id,
                display_name=f"AI-Driven Budget - {service}",
                description=f"Intelligent budget based on ML forecast for {service}",
                amount=recommended_budget,
                reset_period="MONTHLY",
                budget_processing_period_start_offset=1,
                processing_period_type="INVOICE",
                targets=[compartment_id],
                target_type="COMPARTMENT"
            )
            
            try:
                budget_response = self.budget_client.create_budget(budget_details)
                
                # Create alert rules
                alert_rules = [
                    {
                        'threshold': 70,
                        'threshold_type': 'PERCENTAGE',
                        'type': 'ACTUAL',
                        'message': f'AI Alert: {service} spending at 70% of forecasted budget'
                    },
                    {
                        'threshold': 90,
                        'threshold_type': 'PERCENTAGE', 
                        'type': 'ACTUAL',
                        'message': f'Critical: {service} spending at 90% of forecasted budget'
                    },
                    {
                        'threshold': 100,
                        'threshold_type': 'PERCENTAGE',
                        'type': 'FORECAST',
                        'message': f'Forecast Alert: {service} projected to exceed budget'
                    }
                ]
                
                self._create_budget_alerts(budget_response.data.id, alert_rules)
                
                budgets_created.append({
                    'service': service,
                    'budget_id': budget_response.data.id,
                    'amount': recommended_budget,
                    'forecast_accuracy': forecast_data['model_score']
                })
                
            except Exception as e:
                print(f"Failed to create budget for {service}: {e}")
        
        return budgets_created
    
    def _create_budget_alerts(self, budget_id, alert_rules):
        """
        Create comprehensive alert rules for budget monitoring
        """
        for rule in alert_rules:
            alert_rule_details = oci.budget.models.CreateAlertRuleDetails(
                budget_id=budget_id,
                type=rule['type'],
                threshold=rule['threshold'],
                threshold_type=rule['threshold_type'],
                display_name=f"AI Alert - {rule['threshold']}% {rule['type']}",
                message=rule['message'],
                description=f"Automated alert generated by AI-driven FinOps system"
            )
            
            try:
                self.budget_client.create_alert_rule(alert_rule_details)
            except Exception as e:
                print(f"Failed to create alert rule: {e}")
    
    def implement_cost_policies(self, compartment_id, efficiency_analysis):
        """
        Implement automated cost control policies based on efficiency analysis
        """
        policies = []
        
        # Policy for underutilized resources
        if efficiency_analysis['underutilized_resources']:
            underutilized_policy = {
                'name': 'Underutilized Resource Management',
                'rules': [
                    'Require approval for instances with efficiency score < 0.1',
                    'Automatic shutdown of unused resources after 7 days',
                    'Mandatory rightsizing assessment for resources with efficiency < 0.2'
                ],
                'enforcement': 'AUTOMATIC'
            }
            policies.append(underutilized_policy)
        
        # Policy for cost anomalies
        anomaly_policy = {
            'name': 'Cost Anomaly Response',
            'rules': [
                'Automatic notification for cost increases > 50%',
                'Require justification for anomalous spending',
                'Emergency budget freeze for critical anomalies'
            ],
            'enforcement': 'SEMI_AUTOMATIC'
        }
        policies.append(anomaly_policy)
        
        # Policy for resource optimization
        optimization_policy = {
            'name': 'Continuous Cost Optimization',
            'rules': [
                'Weekly efficiency assessment for all resources',
                'Automatic reserved capacity recommendations',
                'Mandatory cost-benefit analysis for new deployments'
            ],
            'enforcement': 'ADVISORY'
        }
        policies.append(optimization_policy)
        
        return policies
    
    def setup_automated_actions(self, compartment_id, recommendations):
        """
        Configure automated actions based on AI recommendations
        """
        automated_actions = []
        
        for opportunity in recommendations.get('automation_opportunities', []):
            if opportunity['automation_type'] == 'AUTO_SCALING':
                action = {
                    'resource_id': opportunity['resource_id'],
                    'action_type': 'CONFIGURE_AUTOSCALING',
                    'parameters': {
                        'min_instances': 1,
                        'max_instances': 10,
                        'target_utilization': 70,
                        'scale_down_enabled': True
                    },
                    'estimated_savings': opportunity['estimated_savings'],
                    'status': 'PENDING_APPROVAL'
                }
                automated_actions.append(action)
        
        return automated_actions

from oci.monitoring import MonitoringClient
from oci.logging import LoggingManagementClient
import asyncio
from datetime import datetime, timedelta

class OCIFinOpsObservability:
    def __init__(self, config_file="~/.oci/config"):
        """
        Initialize advanced observability for cost correlation
        """
        self.config = oci.config.from_file(config_file)
        self.monitoring_client = MonitoringClient(self.config)
        self.logging_client = LoggingManagementClient(self.config)
    
    def create_cost_performance_correlation(self, compartment_id, resource_ids):
        """
        Correlate cost metrics with performance metrics for efficiency analysis
        """
        end_time = datetime.utcnow()
        start_time = end_time - timedelta(days=7)
        
        correlations = {}
        
        for resource_id in resource_ids:
            try:
                # Get cost metrics
                cost_query = oci.monitoring.models.SummarizeMetricsDataDetails(
                    namespace="oci_billing",
                    query=f'costs[1d].sum() where resourceId = "{resource_id}"',
                    compartment_id=compartment_id,
                    start_time=start_time,
                    end_time=end_time
                )
                
                cost_response = self.monitoring_client.summarize_metrics_data(cost_query)
                
                # Get performance metrics (CPU, Memory, Network)
                performance_queries = {
                    'cpu': f'CpuUtilization[1d].mean() where resourceId = "{resource_id}"',
                    'memory': f'MemoryUtilization[1d].mean() where resourceId = "{resource_id}"',
                    'network': f'NetworksBytesIn[1d].sum() where resourceId = "{resource_id}"'
                }
                
                performance_data = {}
                for metric_name, query in performance_queries.items():
                    perf_query = oci.monitoring.models.SummarizeMetricsDataDetails(
                        namespace="oci_computeagent",
                        query=query,
                        compartment_id=compartment_id,
                        start_time=start_time,
                        end_time=end_time
                    )
                    
                    try:
                        perf_response = self.monitoring_client.summarize_metrics_data(perf_query)
                        performance_data[metric_name] = perf_response.data
                    except Exception:
                        performance_data[metric_name] = None
                
                # Calculate efficiency metrics
                if cost_response.data and performance_data['cpu']:
                    cost_per_cpu_hour = self._calculate_cost_efficiency(
                        cost_response.data, performance_data['cpu']
                    )
                    
                    correlations[resource_id] = {
                        'cost_data': cost_response.data,
                        'performance_data': performance_data,
                        'efficiency_metrics': {
                            'cost_per_cpu_hour': cost_per_cpu_hour,
                            'utilization_trend': self._analyze_utilization_trend(performance_data['cpu']),
                            'efficiency_score': self._calculate_efficiency_score(cost_response.data, performance_data)
                        }
                    }
                
            except Exception as e:
                print(f"Error analyzing resource {resource_id}: {e}")
        
        return correlations
    
    def _calculate_cost_efficiency(self, cost_data, cpu_data):
        """
        Calculate cost efficiency based on actual utilization
        """
        if not cost_data or not cpu_data:
            return 0
        
        total_cost = sum([point.value for series in cost_data for point in series.aggregated_datapoints])
        avg_cpu = sum([point.value for series in cpu_data for point in series.aggregated_datapoints]) / len([point.value for series in cpu_data for point in series.aggregated_datapoints])
        
        # Cost per utilized CPU hour
        if avg_cpu > 0:
            return total_cost / (avg_cpu / 100)
        return float('inf')
    
    def _analyze_utilization_trend(self, cpu_data):
        """
        Analyze utilization trends to identify optimization opportunities
        """
        if not cpu_data:
            return "UNKNOWN"
        
        values = [point.value for series in cpu_data for point in series.aggregated_datapoints]
        
        if not values:
            return "NO_DATA"
        
        avg_utilization = sum(values) / len(values)
        
        if avg_utilization < 20:
            return "UNDERUTILIZED"
        elif avg_utilization > 80:
            return "OVERUTILIZED"
        else:
            return "OPTIMAL"
    
    def _calculate_efficiency_score(self, cost_data, performance_data):
        """
        Calculate overall efficiency score (0-100)
        """
        try:
            # Simple efficiency calculation based on cost vs utilization
            total_cost = sum([point.value for series in cost_data for point in series.aggregated_datapoints])
            
            cpu_values = [point.value for series in performance_data.get('cpu', []) for point in series.aggregated_datapoints] if performance_data.get('cpu') else [0]
            avg_cpu = sum(cpu_values) / len(cpu_values) if cpu_values else 0
            
            # Efficiency score: higher utilization with reasonable cost = higher score
            if total_cost > 0 and avg_cpu > 0:
                efficiency = (avg_cpu / 100) * (100 / (total_cost + 1))  # Normalize cost impact
                return min(100, efficiency * 100)
            
            return 0
        except Exception:
            return 0

async def implement_comprehensive_finops(tenancy_id, compartment_id):
    """
    Complete implementation of advanced FinOps on OCI
    """
    print("🚀 Initializing Advanced OCI FinOps Implementation")
    print("="*60)
    
    # Initialize all components
    finops_analytics = OCIFinOpsAnalytics()
    finops_governance = OCIFinOpsGovernance()
    finops_observability = OCIFinOpsObservability()
    
    # Step 1: Comprehensive cost analysis
    print("\n📊 Step 1: Advanced Cost Analysis")
    dashboard_data = create_advanced_cost_dashboard(finops_analytics, tenancy_id)
    
    if not dashboard_data:
        print("❌ Unable to proceed without cost data")
        return
    
    # Step 2: Implement governance
    print("\n🛡️  Step 2: Implementing Automated Governance")
    budgets = finops_governance.create_intelligent_budgets(
        compartment_id, dashboard_data['forecasts']
    )
    print(f"✅ Created {len(budgets)} intelligent budgets")
    
    policies = finops_governance.implement_cost_policies(
        compartment_id, dashboard_data['efficiency_analysis']
    )
    print(f"✅ Implemented {len(policies)} cost control policies")
    
    # Step 3: Setup observability
    print("\n👁️  Step 3: Advanced Observability Setup")
    services_to_monitor = ['compute', 'database', 'storage', 'networking']
    monitoring_configs = finops_observability.setup_intelligent_monitoring(
        compartment_id, services_to_monitor
    )
    print(f"✅ Configured monitoring for {len(services_to_monitor)} services")
    
    # Step 4: Generate final recommendations
    print("\n🎯 Step 4: Strategic Recommendations")
    print("="*40)
    
    recommendations = dashboard_data['recommendations']
    
    print("💰 IMMEDIATE COST SAVINGS OPPORTUNITIES:")
    total_immediate_savings = 0
    for action in recommendations['immediate_actions']:
        print(f"  • {action['issue']}")
        print(f"    Potential Savings: ${action['potential_savings']:.2f}")
        total_immediate_savings += action['potential_savings']
    
    print(f"\n💡 STRATEGIC INITIATIVES:")
    total_strategic_savings = 0
    for initiative in recommendations['strategic_initiatives']:
        print(f"  • {initiative['service']}: ${initiative['potential_savings']:.2f} monthly savings")
        total_strategic_savings += initiative['potential_savings']
    
    print(f"\n🤖 AUTOMATION OPPORTUNITIES:")
    total_automation_savings = 0
    for automation in recommendations['automation_opportunities']:
        print(f"  • {automation['automation_type']} for {automation['service']}")
        print(f"    Estimated Annual Savings: ${automation['estimated_savings'] * 12:.2f}")
        total_automation_savings += automation['estimated_savings'] * 12
    
    print("\n" + "="*60)
    print("FINOPS IMPLEMENTATION SUMMARY")
    print("="*60)
    print(f"💰 Immediate Savings Potential: ${total_immediate_savings:,.2f}")
    print(f"📈 Strategic Savings (Monthly): ${total_strategic_savings:,.2f}")
    print(f"🤖 Automation Savings (Annual): ${total_automation_savings:,.2f}")
    print(f"🎯 Total Annual Impact: ${(total_immediate_savings + total_strategic_savings * 12 + total_automation_savings):,.2f}")
    
    return {
        'analytics_data': dashboard_data,
        'governance': {'budgets': budgets, 'policies': policies},
        'observability': monitoring_configs,
        'recommendations': recommendations,
        'total_savings_potential': total_immediate_savings + total_strategic_savings * 12 + total_automation_savings
    }