defmodule DSPex.Python.ScalingController do
  @moduledoc """
  Central controller for dynamic pool scaling decisions.
  
  Features:
  - Real-time load monitoring
  - Predictive scaling based on patterns
  - ML-driven scaling decisions
  - Multi-dimensional scaling (workers, resources, pools)
  """
  
  use GenServer
  require Logger
  
  defstruct [
    :scaling_policies,      # Map of pool_id -> scaling_policy
    :metrics_collector,     # Real-time metrics collection
    :predictor,            # Load prediction ML model
    :scaling_history,      # Historical scaling decisions
    :active_scaling_ops,   # Currently active scaling operations
    :constraints          # System and business constraints
  ]
  
  @scaling_intervals %{
    fast: 15_000,      # 15 seconds for critical scaling
    normal: 60_000,    # 1 minute for standard scaling
    slow: 300_000      # 5 minutes for predictive scaling
  }
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def trigger_scaling_evaluation(pool_id, reason \\ :periodic) do
    GenServer.cast(__MODULE__, {:evaluate_scaling, pool_id, reason})
  end
  
  def get_scaling_recommendations(pool_id) do
    GenServer.call(__MODULE__, {:get_recommendations, pool_id})
  end
  
  def apply_scaling_decision(pool_id, scaling_decision) do
    GenServer.call(__MODULE__, {:apply_scaling, pool_id, scaling_decision}, 30_000)
  end
  
  # Real-time scaling evaluation
  def handle_cast({:evaluate_scaling, pool_id, reason}, state) do
    scaling_decision = evaluate_scaling_need(pool_id, reason, state)
    
    case scaling_decision do
      {:scale_up, config} ->
        execute_scale_up(pool_id, config)
        
      {:scale_down, config} ->
        execute_scale_down(pool_id, config)
        
      {:optimize_resources, config} ->
        execute_resource_optimization(pool_id, config)
        
      :no_action ->
        :ok
    end
    
    {:noreply, update_scaling_history(state, pool_id, scaling_decision)}
  end
end

defmodule DSPex.Python.ScalingPolicy do
  @moduledoc """
  Defines scaling policies for different pool types and scenarios.
  """
  
  defstruct [
    :pool_id,
    :min_workers,          # Minimum number of workers
    :max_workers,          # Maximum number of workers
    :target_utilization,   # Target utilization percentage (0.0-1.0)
    :scale_up_threshold,   # Utilization threshold to trigger scale-up
    :scale_down_threshold, # Utilization threshold to trigger scale-down
    :scale_up_cooldown,    # Cooldown period after scale-up (ms)
    :scale_down_cooldown,  # Cooldown period after scale-down (ms)
    :scaling_increment,    # Number of workers to add/remove per scaling event
    :predictive_enabled,   # Enable predictive scaling
    :cost_optimization,    # Enable cost-based scaling decisions
    :time_based_rules,     # Schedule-based scaling rules
    :emergency_scaling     # Emergency scaling configuration
  ]
  
  @policy_templates %{
    conservative: %__MODULE__{
      scale_up_threshold: 0.8,
      scale_down_threshold: 0.3,
      scale_up_cooldown: 300_000,    # 5 minutes
      scale_down_cooldown: 600_000,  # 10 minutes
      scaling_increment: 1,
      predictive_enabled: false
    },
    
    aggressive: %__MODULE__{
      scale_up_threshold: 0.6,
      scale_down_threshold: 0.2,
      scale_up_cooldown: 60_000,     # 1 minute
      scale_down_cooldown: 180_000,  # 3 minutes
      scaling_increment: 2,
      predictive_enabled: true
    },
    
    cost_optimized: %__MODULE__{
      scale_up_threshold: 0.9,
      scale_down_threshold: 0.1,
      scale_up_cooldown: 180_000,    # 3 minutes
      scale_down_cooldown: 300_000,  # 5 minutes
      scaling_increment: 1,
      cost_optimization: true,
      predictive_enabled: true
    },
    
    high_performance: %__MODULE__{
      scale_up_threshold: 0.5,
      scale_down_threshold: 0.4,
      scale_up_cooldown: 30_000,     # 30 seconds
      scale_down_cooldown: 120_000,  # 2 minutes
      scaling_increment: 3,
      emergency_scaling: %{
        threshold: 0.95,
        max_emergency_workers: 10,
        emergency_timeout: 15_000
      }
    }
  }
  
  def create_policy(pool_id, template, overrides \\ %{}) do
    base_policy = Map.get(@policy_templates, template, @policy_templates.conservative)
    
    %{base_policy | pool_id: pool_id}
    |> Map.merge(overrides)
  end
end

defmodule DSPex.Python.LoadPredictor do
  @moduledoc """
  ML-based load prediction for proactive scaling decisions.
  """
  
  use GenServer
  
  defstruct [
    :model,              # Trained ML model for prediction
    :feature_extractors, # Functions to extract features from metrics
    :prediction_cache,   # Cache of recent predictions
    :training_data,      # Historical data for model training
    :accuracy_metrics    # Model accuracy tracking
  ]
  
  def predict_load(pool_id, time_horizon_minutes) do
    GenServer.call(__MODULE__, {:predict_load, pool_id, time_horizon_minutes})
  end
  
  def train_model(pool_id, historical_data) do
    GenServer.cast(__MODULE__, {:train_model, pool_id, historical_data})
  end
  
  # Feature extraction for ML model
  defp extract_features(pool_metrics, time_context) do
    %{
      # Current state features
      current_utilization: pool_metrics.utilization,
      current_queue_length: pool_metrics.queue_length,
      current_response_time: pool_metrics.avg_response_time,
      current_error_rate: pool_metrics.error_rate,
      
      # Temporal features
      hour_of_day: time_context.hour,
      day_of_week: time_context.day_of_week,
      day_of_month: time_context.day_of_month,
      is_weekend: time_context.is_weekend,
      is_holiday: time_context.is_holiday,
      
      # Historical trend features
      utilization_trend_1h: calculate_trend(pool_metrics.utilization_history, 60),
      utilization_trend_24h: calculate_trend(pool_metrics.utilization_history, 1440),
      request_rate_trend: calculate_trend(pool_metrics.request_rate_history, 60),
      
      # Seasonal features
      seasonal_factor: calculate_seasonal_factor(time_context),
      weekly_pattern: get_weekly_pattern(time_context),
      daily_pattern: get_daily_pattern(time_context),
      
      # External context features
      system_load: get_system_load(),
      memory_pressure: get_memory_pressure(),
      network_latency: get_network_latency()
    }
  end
  
  # Load prediction using trained model
  defp predict_future_load(features, time_horizon) do
    # Simplified prediction logic - in practice, use proper ML library
    base_prediction = features.current_utilization
    
    # Apply trend adjustment
    trend_adjustment = features.utilization_trend_1h * (time_horizon / 60)
    
    # Apply seasonal adjustment
    seasonal_adjustment = features.seasonal_factor
    
    # Apply external factors
    external_adjustment = calculate_external_adjustment(features)
    
    predicted_utilization = base_prediction + trend_adjustment + 
                           seasonal_adjustment + external_adjustment
    
    # Clamp to valid range
    max(0.0, min(1.0, predicted_utilization))
  end
end

defmodule DSPex.Python.PatternRecognition do
  @moduledoc """
  Identifies recurring load patterns for predictive scaling.
  """
  
  def analyze_historical_patterns(pool_id, days_back \\ 30) do
    historical_data = fetch_historical_metrics(pool_id, days_back)
    
    patterns = %{
      daily_patterns: identify_daily_patterns(historical_data),
      weekly_patterns: identify_weekly_patterns(historical_data),
      traffic_spikes: identify_traffic_spikes(historical_data),
      maintenance_windows: identify_low_traffic_periods(historical_data),
      seasonal_trends: identify_seasonal_trends(historical_data)
    }
    
    # Score pattern reliability
    Enum.map(patterns, fn {pattern_type, pattern_data} ->
      reliability_score = calculate_pattern_reliability(pattern_data)
      {pattern_type, Map.put(pattern_data, :reliability, reliability_score)}
    end)
    |> Enum.into(%{})
  end
  
  defp identify_daily_patterns(data) do
    # Group data by hour of day
    hourly_data = 
      data
      |> Enum.group_by(fn point -> point.timestamp |> DateTime.from_unix!() |> Map.get(:hour) end)
      |> Enum.map(fn {hour, points} ->
        avg_utilization = Enum.reduce(points, 0, & &1.utilization + &2) / length(points)
        {hour, avg_utilization}
      end)
      |> Enum.into(%{})
    
    # Identify peak and low traffic hours
    {peak_hours, low_hours} = categorize_traffic_hours(hourly_data)
    
    %{
      hourly_averages: hourly_data,
      peak_hours: peak_hours,
      low_traffic_hours: low_hours,
      pattern_strength: calculate_daily_pattern_strength(hourly_data)
    }
  end
  
  defp identify_traffic_spikes(data) do
    # Define spike as >2 standard deviations above mean
    mean_utilization = calculate_mean_utilization(data)
    std_deviation = calculate_std_deviation(data)
    spike_threshold = mean_utilization + (2 * std_deviation)
    
    spikes = 
      data
      |> Enum.filter(fn point -> point.utilization > spike_threshold end)
      |> Enum.map(fn spike ->
        %{
          timestamp: spike.timestamp,
          peak_utilization: spike.utilization,
          duration: estimate_spike_duration(spike, data),
          preceding_conditions: analyze_spike_preconditions(spike, data)
        }
      end)
    
    %{
      spike_events: spikes,
      average_spike_magnitude: calculate_average_spike_magnitude(spikes),
      spike_frequency: calculate_spike_frequency(spikes),
      common_spike_triggers: identify_common_spike_triggers(spikes)
    }
  end
end

defmodule DSPex.Python.WorkerAutoScaler do
  @moduledoc """
  Handles automatic scaling of worker pools based on demand.
  """
  
  def scale_pool(pool_id, scaling_decision) do
    case scaling_decision do
      {:scale_up, worker_count} ->
        scale_up_workers(pool_id, worker_count)
        
      {:scale_down, worker_count} ->
        scale_down_workers(pool_id, worker_count)
        
      {:optimize_existing, optimization} ->
        optimize_existing_workers(pool_id, optimization)
    end
  end
  
  defp scale_up_workers(pool_id, worker_count) do
    Logger.info("Scaling up pool #{pool_id} by #{worker_count} workers")
    
    # Pre-warm workers concurrently for faster startup
    warm_up_tasks = for i <- 1..worker_count do
      Task.async(fn ->
        worker_id = generate_worker_id(pool_id, i)
        
        case DSPex.Python.WorkerSupervisor.start_worker(worker_id) do
          {:ok, worker_pid} ->
            # Apply resource limits and monitoring
            apply_scaling_optimizations(worker_id, worker_pid)
            {:ok, worker_id}
            
          {:error, reason} ->
            Logger.error("Failed to start worker #{worker_id}: #{inspect(reason)}")
            {:error, reason}
        end
      end)
    end
    
    # Wait for all workers to start
    results = Task.await_many(warm_up_tasks, 30_000)
    successful_workers = Enum.filter(results, &match?({:ok, _}, &1))
    
    # Update pool configuration
    update_pool_size(pool_id, length(successful_workers))
    
    # Record scaling metrics
    record_scaling_event(pool_id, :scale_up, length(successful_workers))
    
    {:ok, length(successful_workers)}
  end
  
  defp scale_down_workers(pool_id, worker_count) do
    Logger.info("Scaling down pool #{pool_id} by #{worker_count} workers")
    
    # Select workers for termination based on criteria
    workers_to_remove = select_workers_for_removal(pool_id, worker_count)
    
    # Graceful shutdown with request completion
    shutdown_tasks = Enum.map(workers_to_remove, fn worker_id ->
      Task.async(fn ->
        graceful_worker_shutdown(worker_id)
      end)
    end)
    
    # Wait for graceful shutdowns
    Task.await_many(shutdown_tasks, 60_000)
    
    # Update pool configuration
    update_pool_size(pool_id, -worker_count)
    
    # Record scaling metrics
    record_scaling_event(pool_id, :scale_down, worker_count)
    
    {:ok, worker_count}
  end
  
  defp select_workers_for_removal(pool_id, count) do
    workers = DSPex.Python.Pool.list_workers(pool_id)
    
    # Score workers for removal based on:
    # - Current workload (prefer idle workers)
    # - Health status (prefer degraded workers)
    # - Age (prefer older workers that might have accumulated issues)
    # - Resource usage (prefer high-resource workers if downsizing)
    
    worker_scores = Enum.map(workers, fn worker_id ->
      score = calculate_removal_score(worker_id)
      {worker_id, score}
    end)
    
    worker_scores
    |> Enum.sort_by(fn {_id, score} -> score end, :desc)  # Highest score = best candidate for removal
    |> Enum.take(count)
    |> Enum.map(fn {worker_id, _score} -> worker_id end)
  end
  
  defp graceful_worker_shutdown(worker_id) do
    # Wait for current requests to complete
    wait_for_worker_idle(worker_id, timeout: 30_000)
    
    # Remove from pool availability
    DSPex.Python.Pool.remove_worker(worker_id)
    
    # Stop worker process
    DSPex.Python.WorkerSupervisor.stop_worker(worker_id)
    
    # Clean up monitoring
    DSPex.Python.ResourceMonitor.stop_monitoring(worker_id)
  end
end

defmodule DSPex.Python.ResourceAwareScaling do
  @moduledoc """
  Considers system resources when making scaling decisions.
  """
  
  def evaluate_scaling_feasibility(scaling_request) do
    current_resources = get_current_resource_usage()
    required_resources = estimate_required_resources(scaling_request)
    available_resources = calculate_available_resources(current_resources)
    
    feasibility = %{
      memory_feasible: available_resources.memory >= required_resources.memory,
      cpu_feasible: available_resources.cpu >= required_resources.cpu,
      network_feasible: available_resources.network >= required_resources.network,
      storage_feasible: available_resources.storage >= required_resources.storage
    }
    
    overall_feasible = Enum.all?(Map.values(feasibility))
    
    case overall_feasible do
      true ->
        {:ok, scaling_request}
        
      false ->
        # Suggest alternative scaling approach
        alternative = suggest_alternative_scaling(scaling_request, feasibility)
        {:limited, alternative}
    end
  end
  
  defp estimate_required_resources(scaling_request) do
    case scaling_request do
      {:scale_up, worker_count} ->
        per_worker_resources = get_average_worker_resource_usage()
        
        %{
          memory: per_worker_resources.memory * worker_count,
          cpu: per_worker_resources.cpu * worker_count,
          network: per_worker_resources.network * worker_count,
          storage: per_worker_resources.storage * worker_count
        }
        
      {:scale_down, worker_count} ->
        # Negative values indicate resource reclamation
        per_worker_resources = get_average_worker_resource_usage()
        
        %{
          memory: -per_worker_resources.memory * worker_count,
          cpu: -per_worker_resources.cpu * worker_count,
          network: -per_worker_resources.network * worker_count,
          storage: -per_worker_resources.storage * worker_count
        }
    end
  end
  
  defp suggest_alternative_scaling(original_request, feasibility_constraints) do
    case original_request do
      {:scale_up, requested_count} ->
        # Calculate maximum feasible worker count
        max_feasible = calculate_max_feasible_workers(feasibility_constraints)
        
        if max_feasible > 0 do
          {:scale_up, max_feasible}
        else
          # Suggest resource optimization instead
          {:optimize_resources, %{
            target: :memory_efficiency,
            expected_capacity_gain: 0.2
          }}
        end
        
      {:scale_down, _} ->
        # Scale down is usually feasible
        original_request
    end
  end
end

defmodule DSPex.Python.ScheduledScaling do
  @moduledoc """
  Handles pre-planned scaling based on time schedules and known events.
  """
  
  use GenServer
  
  defstruct [
    :scaling_schedules,  # Map of pool_id -> list of scheduled scaling events
    :active_timers,      # Currently active timers
    :timezone,          # Timezone for schedule interpretation
    :override_policies   # Override policies for emergency situations
  ]
  
  def schedule_scaling_event(pool_id, schedule, scaling_action) do
    GenServer.call(__MODULE__, {:schedule_event, pool_id, schedule, scaling_action})
  end
  
  def add_recurring_schedule(pool_id, cron_expression, scaling_action) do
    GenServer.call(__MODULE__, {:add_recurring, pool_id, cron_expression, scaling_action})
  end
  
  # Example scheduled scaling configurations
  @default_schedules %{
    business_hours: %{
      scale_up: %{
        time: "08:00",
        days: [:monday, :tuesday, :wednesday, :thursday, :friday],
        action: {:scale_to, 8}
      },
      scale_down: %{
        time: "18:00",
        days: [:monday, :tuesday, :wednesday, :thursday, :friday],
        action: {:scale_to, 4}
      }
    },
    
    weekend_schedule: %{
      weekend_scale_down: %{
        time: "22:00",
        days: [:friday],
        action: {:scale_to, 2}
      },
      weekend_scale_up: %{
        time: "08:00",
        days: [:monday],
        action: {:scale_to, 6}
      }
    },
    
    maintenance_window: %{
      pre_maintenance: %{
        time: "02:00",
        days: [:sunday],
        action: {:scale_to, 1},
        duration: 120  # 2 hours
      }
    }
  }
  
  defp evaluate_scheduled_scaling(pool_id, current_time) do
    schedules = get_active_schedules(pool_id, current_time)
    
    # Find applicable schedules for current time
    applicable_schedules = 
      schedules
      |> Enum.filter(fn schedule -> schedule_applies?(schedule, current_time) end)
      |> Enum.sort_by(fn schedule -> schedule.priority end, :desc)
    
    # Apply highest priority schedule
    case applicable_schedules do
      [schedule | _] ->
        execute_scheduled_scaling(pool_id, schedule)
        
      [] ->
        :no_scheduled_scaling
    end
  end
end

defmodule DSPex.Python.EventDrivenScaling do
  @moduledoc """
  Responds to external events and triggers for scaling decisions.
  """
  
  def handle_scaling_trigger(trigger_type, trigger_data) do
    case trigger_type do
      :load_spike_detected ->
        handle_load_spike(trigger_data)
        
      :api_rate_limit_approached ->
        handle_rate_limit_pressure(trigger_data)
        
      :error_rate_increase ->
        handle_error_rate_spike(trigger_data)
        
      :external_event ->
        handle_external_event(trigger_data)
        
      :cost_threshold_exceeded ->
        handle_cost_optimization(trigger_data)
    end
  end
  
  defp handle_load_spike(spike_data) do
    pool_id = spike_data.pool_id
    current_utilization = spike_data.utilization
    spike_magnitude = spike_data.magnitude
    
    # Calculate required scaling
    required_capacity_increase = calculate_spike_capacity_requirement(spike_magnitude)
    additional_workers = calculate_workers_needed(required_capacity_increase)
    
    # Apply emergency scaling if spike is severe
    if spike_magnitude > 0.8 do
      apply_emergency_scaling(pool_id, additional_workers)
    else
      apply_standard_scaling(pool_id, additional_workers)
    end
  end
  
  defp handle_rate_limit_pressure(rate_limit_data) do
    # When approaching API rate limits, scale down or implement backoff
    pool_id = rate_limit_data.pool_id
    current_rate = rate_limit_data.current_rate
    limit = rate_limit_data.limit
    
    utilization_ratio = current_rate / limit
    
    cond do
      utilization_ratio > 0.9 ->
        # Emergency: scale down workers to reduce API calls
        scale_down_count = calculate_rate_limit_scale_down(pool_id, utilization_ratio)
        DSPex.Python.WorkerAutoScaler.scale_pool(pool_id, {:scale_down, scale_down_count})
        
      utilization_ratio > 0.7 ->
        # Warning: implement request throttling
        implement_request_throttling(pool_id)
        
      true ->
        :no_action_needed
    end
  end
  
  defp apply_emergency_scaling(pool_id, worker_count) do
    Logger.warn("Applying emergency scaling: +#{worker_count} workers for pool #{pool_id}")
    
    # Use fastest possible scaling method
    scaling_opts = [
      priority: :emergency,
      timeout: 15_000,         # Faster timeout
      parallel_startup: true,   # Start all workers in parallel
      skip_warmup: true        # Skip non-essential warmup steps
    ]
    
    DSPex.Python.WorkerAutoScaler.scale_pool(
      pool_id, 
      {:scale_up, worker_count}, 
      scaling_opts
    )
    
    # Set auto-scale-down timer to prevent over-provisioning
    schedule_auto_scale_down(pool_id, worker_count, after: 600_000)  # 10 minutes
  end
end

# config/config.exs
config :dspex, DSPex.Python.DynamicScaling,
  # Global scaling settings
  enabled: true,
  evaluation_interval: 60_000,        # Evaluate scaling every minute
  
  # Predictive scaling
  predictive_scaling: %{
    enabled: true,
    prediction_horizon: 30,           # Predict 30 minutes ahead
    confidence_threshold: 0.8,        # Only act on >80% confidence predictions
    model_retraining_interval: 86400  # Retrain model daily
  },
  
  # Resource constraints
  resource_limits: %{
    max_total_workers: 100,           # System-wide worker limit
    max_memory_usage: 16_000,         # 16GB max memory
    max_cpu_cores: 32,                # 32 cores max
    emergency_reserve: 0.1            # Keep 10% resources in reserve
  },
  
  # Scaling policies by pool type
  scaling_policies: %{
    general: :conservative,
    embedding: :aggressive,
    generation: :high_performance,
    classification: :cost_optimized
  },
  
  # Time-based scaling
  scheduled_scaling: %{
    enabled: true,
    timezone: "UTC",
    default_schedules: [:business_hours, :weekend_schedule]
  },
  
  # Event-driven scaling
  event_scaling: %{
    enabled: true,
    spike_detection_threshold: 0.7,   # Detect spikes at 70% utilization
    emergency_scaling_threshold: 0.9, # Emergency scaling at 90%
    auto_scale_down_delay: 300_000    # Auto scale down after 5 minutes
  }

defmodule DSPex.Python.IntegratedScalingManager do
  @moduledoc """
  Integrates dynamic scaling with multi-pool load balancing.
  """
  
  def coordinate_scaling_across_pools(scaling_demand) do
    # Consider scaling impact across all pools
    pools = DSPex.Python.PoolRegistry.get_all_pools()
    
    # Calculate optimal scaling distribution
    scaling_plan = create_multi_pool_scaling_plan(pools, scaling_demand)
    
    # Execute coordinated scaling
    scaling_results = Enum.map(scaling_plan, fn {pool_id, scaling_action} ->
      Task.async(fn ->
        DSPex.Python.WorkerAutoScaler.scale_pool(pool_id, scaling_action)
      end)
    end)
    
    # Wait for all scaling operations to complete
    Task.await_many(scaling_results, 60_000)
    
    # Update load balancing weights based on new pool sizes
    update_load_balancing_weights(scaling_plan)
  end
  
  defp create_multi_pool_scaling_plan(pools, demand) do
    # Distribute scaling across pools based on:
    # 1. Pool specialization and demand type
    # 2. Current pool utilization
    # 3. Scaling policies and constraints
    # 4. Resource availability
    
    pools
    |> Enum.map(fn pool ->
      pool_demand = calculate_pool_specific_demand(pool, demand)
      scaling_action = determine_optimal_scaling(pool, pool_demand)
      {pool.pool_id, scaling_action}
    end)
    |> Enum.filter(fn {_pool_id, action} -> action != :no_scaling end)
  end
end

defmodule DSPex.Python.ScalingMetrics do
  def get_scaling_dashboard_data do
    %{
      current_scaling_status: get_current_scaling_status(),
      scaling_history: get_scaling_history(24), # Last 24 hours
      prediction_accuracy: get_prediction_accuracy_metrics(),
      resource_efficiency: get_resource_efficiency_metrics(),
      cost_metrics: get_scaling_cost_metrics(),
      upcoming_scaling_events: get_upcoming_scheduled_scaling()
    }
  end
  
  defp get_current_scaling_status do
    pools = DSPex.Python.PoolRegistry.get_all_pools()
    
    Enum.map(pools, fn pool ->
      stats = DSPex.Python.Pool.get_stats(pool.pool_id)
      policy = get_scaling_policy(pool.pool_id)
      
      %{
        pool_id: pool.pool_id,
        current_workers: stats.workers,
        target_utilization: policy.target_utilization,
        current_utilization: stats.busy / max(stats.workers, 1),
        scaling_headroom: policy.max_workers - stats.workers,
        last_scaling_event: get_last_scaling_event(pool.pool_id),
        next_evaluation: get_next_evaluation_time(pool.pool_id)
      }
    end)
  end
  
  defp get_resource_efficiency_metrics do
    %{
      average_utilization: calculate_average_utilization(),
      resource_waste_percentage: calculate_resource_waste(),
      scaling_accuracy: calculate_scaling_accuracy(),
      cost_efficiency: calculate_cost_efficiency(),
      predictive_scaling_success_rate: calculate_prediction_success_rate()
    }
  end
end

# Scaling operation events
:telemetry.execute(
  [:dspex, :scaling, :operation, :completed],
  %{
    pool_id: pool_id,
    operation: :scale_up,
    workers_added: count,
    duration: duration_ms,
    success_rate: success_rate
  },
  %{trigger: trigger_reason, strategy: scaling_strategy}
)

# Prediction accuracy events
:telemetry.execute(
  [:dspex, :scaling, :prediction, :accuracy],
  %{
    pool_id: pool_id,
    predicted_load: predicted,
    actual_load: actual,
    accuracy_score: accuracy,
    prediction_horizon: horizon_minutes
  },
  %{model_version: version, confidence: confidence}
)

# Resource efficiency events
:telemetry.execute(
  [:dspex, :scaling, :efficiency, :measured],
  %{
    pool_id: pool_id,
    resource_utilization: utilization,
    cost_efficiency: efficiency,
    waste_percentage: waste
  },
  %{measurement_period: period, scaling_events: events}
)

defmodule DSPex.Python.ScalingSimulationTest do
  use ExUnit.Case, async: false
  
  test "handles traffic spike with predictive scaling" do
    pool_id = :test_scaling_pool
    
    # Enable predictive scaling
    configure_predictive_scaling(pool_id, enabled: true)
    
    # Simulate gradual load increase leading to spike
    simulate_load_pattern(pool_id, [
      {0, 0.2},     # Start at 20% utilization
      {60, 0.4},    # Increase to 40% after 1 minute
      {120, 0.8},   # Jump to 80% after 2 minutes (spike)
      {180, 0.9},   # Peak at 90%
      {240, 0.3}    # Return to 30%
    ])
    
    # Verify scaling responded appropriately
    scaling_events = get_scaling_events(pool_id)
    
    # Should have scaled up before hitting peak
    pre_spike_scaling = Enum.find(scaling_events, fn event ->
      event.timestamp < 180 and event.action == :scale_up
    end)
    
    assert pre_spike_scaling != nil, "Should have scaled up before traffic spike"
    
    # Should have scaled down after traffic returned to normal
    post_spike_scaling = Enum.find(scaling_events, fn event ->
      event.timestamp > 240 and event.action == :scale_down
    end)
    
    assert post_spike_scaling != nil, "Should have scaled down after traffic spike"
  end
  
  test "respects resource constraints during scaling" do
    # Set low resource limits
    configure_resource_limits(max_memory: 1000, max_workers: 5)
    
    # Request large scaling operation
    scaling_request = {:scale_up, 10}
    
    # Should be limited by resource constraints
    {:limited, actual_scaling} = DSPex.Python.ResourceAwareScaling.evaluate_scaling_feasibility(scaling_request)
    
    {:scale_up, actual_count} = actual_scaling
    assert actual_count <= 5, "Should respect max worker limit"
  end
end