# Core Ash Resources for DSPEx
defmodule DSPEx.Resources.Program do
  use Ash.Resource, domain: DSPEx.Domain

  attributes do
    uuid_primary_key :id
    attribute :name, :string, allow_nil?: false
    attribute :signature_config, DSPEx.Types.SignatureConfig
    attribute :variable_space_id, :uuid
    attribute :optimization_metadata, :map, default: %{}
    attribute :execution_stats, :map, default: %{}
  end

  relationships do
    belongs_to :variable_space, DSPEx.Resources.VariableSpace
    has_many :optimization_runs, DSPEx.Resources.OptimizationRun
    has_many :executions, DSPEx.Resources.Execution
  end

  actions do
    defaults [:create, :read, :update, :destroy]
    
    action :execute_with_jido, :map do
      argument :inputs, :map, allow_nil?: false
      argument :variable_config, :map, default: %{}
      run DSPEx.Actions.ExecuteWithJido
    end
    
    action :optimize_variables, DSPEx.Resources.Program do
      argument :training_data, {:array, :map}, allow_nil?: false
      argument :optimization_strategy, :atom, default: :adaptive
      run DSPEx.Actions.OptimizeVariables
    end
  end

  calculations do
    calculate :current_performance, :float do
      DSPEx.Calculations.CurrentPerformance
    end
    
    calculate :variable_importance, {:array, :map} do
      DSPEx.Calculations.VariableImportance
    end
    
    calculate :cost_efficiency, :float do
      DSPEx.Calculations.CostEfficiency
    end
  end
end

defmodule DSPEx.Resources.VariableSpace do
  use Ash.Resource, domain: DSPEx.Domain

  attributes do
    uuid_primary_key :id
    attribute :name, :string
    attribute :variables, {:array, DSPEx.Types.Variable}
    attribute :constraints, {:array, :map}, default: []
    attribute :optimization_hints, :map, default: %{}
  end

  relationships do
    has_many :programs, DSPEx.Resources.Program
    has_many :configurations, DSPEx.Resources.VariableConfiguration
    has_many :optimization_runs, DSPEx.Resources.OptimizationRun
  end

  actions do
    action :generate_configuration, DSPEx.Resources.VariableConfiguration do
      argument :strategy, :atom, default: :adaptive
      argument :context, :map, default: %{}
      run DSPEx.Actions.GenerateVariableConfiguration
    end
    
    action :evaluate_configuration, :map do
      argument :configuration, :map, allow_nil?: false
      argument :program_id, :uuid, allow_nil?: false
      argument :evaluation_data, {:array, :map}, allow_nil?: false
      run DSPEx.Actions.EvaluateConfiguration
    end
  end
end

# Jido-Powered Program Execution
defmodule DSPEx.Actions.ExecuteWithJido do
  use Jido.Action,
    name: "dspex_execute_program",
    description: "Execute DSPEx program with variable resolution and robust error handling",
    schema: [
      program_id: [type: :uuid, required: true],
      inputs: [type: :map, required: true],
      variable_config: [type: :map, default: %{}],
      execution_options: [type: :map, default: %{}]
    ]

  @impl Jido.Action
  def run(params, context) do
    # Load program with Ash
    program = DSPEx.Resources.Program.get!(params.program_id, load: [:variable_space])
    
    # Resolve variables to concrete configuration
    resolved_config = resolve_variables(program.variable_space, params.variable_config)
    
    # Execute with Jido's robust error handling
    case execute_program_with_config(program, params.inputs, resolved_config, context) do
      {:ok, outputs} -> 
        # Record execution via Ash
        record_execution(program, params.inputs, outputs, resolved_config)
        
        # Emit Jido signal for real-time monitoring
        emit_execution_signal(program.id, outputs, context)
        
        {:ok, outputs}
      
      {:error, reason} -> 
        # Record failure and emit signal
        record_failure(program, params.inputs, reason, resolved_config)
        emit_failure_signal(program.id, reason, context)
        
        {:error, reason}
    end
  end

  defp resolve_variables(variable_space, config) do
    # Use Variable system to resolve configuration
    DSPEx.Variables.Resolver.resolve(variable_space.variables, config)
  end

  defp execute_program_with_config(program, inputs, config, context) do
    # Apply configuration to program
    configured_program = DSPEx.Configuration.apply_config(program, config)
    
    # Execute with timeout and retry
    case DSPEx.Program.forward(configured_program, inputs) do
      {:ok, outputs} -> {:ok, outputs}
      {:error, reason} -> handle_execution_error(reason, configured_program, inputs, context)
    end
  end
end

# Event-Driven Optimization Monitoring
defmodule DSPEx.OptimizationSignalBus do
  use Jido.Signal.Bus,
    name: :dspex_optimization_bus,
    adapters: [
      {Jido.Signal.Adapters.Logger, level: :info},
      {Jido.Signal.Adapters.Telemetry, prefix: [:dspex]},
      {DSPEx.Signal.Adapters.LiveView, topic: "optimization"},
      {DSPEx.Signal.Adapters.Database, store: DSPEx.Repo}
    ]

  def optimization_started(run_id, program_id, variable_space) do
    emit(%Jido.Signal{
      type: "dspex.optimization.started",
      data: %{
        run_id: run_id,
        program_id: program_id,
        variable_count: length(variable_space.variables),
        timestamp: DateTime.utc_now()
      }
    })
  end

  def configuration_evaluated(run_id, configuration, evaluation_result) do
    emit(%Jido.Signal{
      type: "dspex.optimization.configuration.evaluated",
      data: %{
        run_id: run_id,
        configuration: configuration,
        performance_score: evaluation_result.performance_score,
        cost_score: evaluation_result.cost_score,
        latency_score: evaluation_result.latency_score,
        pareto_rank: evaluation_result.pareto_rank,
        timestamp: DateTime.utc_now()
      }
    })
  end

  def optimization_completed(run_id, best_configuration, pareto_frontier) do
    emit(%Jido.Signal{
      type: "dspex.optimization.completed",
      data: %{
        run_id: run_id,
        best_configuration: best_configuration,
        pareto_frontier_size: length(pareto_frontier),
        optimization_duration: calculate_duration(run_id),
        timestamp: DateTime.utc_now()
      }
    })
  end
end

# Universal Variable System with Ash Integration
defmodule DSPEx.Variables.Variable do
  use Ash.Resource, domain: DSPEx.Variables.Domain

  attributes do
    uuid_primary_key :id
    attribute :name, :atom, allow_nil?: false
    attribute :type, DSPEx.Types.VariableType, allow_nil?: false
    attribute :choices, {:array, :union, types: [:string, :atom, :module]}, default: []
    attribute :range, DSPEx.Types.Range
    attribute :default_value, :union, types: [:string, :integer, :float, :boolean, :atom]
    attribute :constraints, :map, default: %{}
    attribute :description, :string
    attribute :cost_weight, :float, default: 1.0
    attribute :performance_weight, :float, default: 1.0
    attribute :metadata, :map, default: %{}
  end

  relationships do
    belongs_to :variable_space, DSPEx.Resources.VariableSpace
    has_many :evaluations, DSPEx.Variables.Evaluation
    has_many :performance_records, DSPEx.Variables.PerformanceRecord
  end

  actions do
    action :sample_value, :union do
      argument :strategy, :atom, default: :uniform
      argument :context, :map, default: %{}
      run DSPEx.Variables.Actions.SampleValue
    end
    
    action :validate_value, :boolean do
      argument :value, :union, allow_nil?: false
      run DSPEx.Variables.Actions.ValidateValue
    end
    
    action :record_performance, DSPEx.Variables.PerformanceRecord do
      argument :configuration, :map, allow_nil?: false
      argument :performance_metrics, :map, allow_nil?: false
      run DSPEx.Variables.Actions.RecordPerformance
    end
  end

  calculations do
    calculate :optimal_value_estimate, :union do
      DSPEx.Variables.Calculations.OptimalValueEstimate
    end
    
    calculate :performance_correlation, :float do
      DSPEx.Variables.Calculations.PerformanceCorrelation
    end
  end
end

# Multi-Objective Optimization with Pareto Analysis
defmodule DSPEx.Optimization.MultiObjectiveOptimizer do
  use Ash.Resource, domain: DSPEx.Domain

  attributes do
    uuid_primary_key :id
    attribute :objectives, {:array, :map}, default: []
    attribute :pareto_frontier, {:array, :map}, default: []
    attribute :optimization_strategy, :atom, default: :adaptive
    attribute :convergence_criteria, :map, default: %{}
  end

  actions do
    action :optimize, :map do
      argument :program_id, :uuid, allow_nil?: false
      argument :variable_space_id, :uuid, allow_nil?: false
      argument :training_data, {:array, :map}, allow_nil?: false
      argument :budget, :integer, default: 100
      run DSPEx.Optimization.Actions.MultiObjectiveOptimize
    end
  end

  calculations do
    calculate :convergence_status, :atom do
      DSPEx.Optimization.Calculations.ConvergenceStatus
    end
    
    calculate :best_trade_offs, {:array, :map} do
      DSPEx.Optimization.Calculations.BestTradeOffs
    end
  end
end

# DSPEx Agent Framework using Jido
defmodule DSPEx.Agents.ProgramAgent do
  use Jido.Agent,
    name: "dspex_program_agent",
    description: "Stateful DSPEx program with conversation memory and adaptive behavior"

  def initial_state(config) do
    %{
      program_id: config.program_id,
      variable_configuration: config.variable_configuration,
      conversation_history: [],
      performance_metrics: %{},
      adaptive_learning_enabled: config.adaptive_learning || false,
      optimization_budget: config.optimization_budget || 10
    }
  end

  def handle_signal(%Jido.Signal{type: "dspex.execute"} = signal, state) do
    # Execute DSPEx program with current configuration
    execution_result = execute_program(state.program_id, signal.data.inputs, state.variable_configuration)
    
    # Update conversation history
    updated_state = update_conversation_history(state, signal.data.inputs, execution_result)
    
    # Adaptive learning: adjust configuration based on performance
    final_state = if state.adaptive_learning_enabled do
      adapt_configuration(updated_state, execution_result)
    else
      updated_state
    end
    
    response_signal = %Jido.Signal{
      type: "dspex.execution.completed",
      data: execution_result,
      correlation_id: signal.correlation_id
    }
    
    {:ok, [response_signal], final_state}
  end

  def handle_signal(%Jido.Signal{type: "dspex.optimize"} = signal, state) do
    # Trigger background optimization
    optimization_task = Task.Supervisor.async_nolink(DSPEx.TaskSupervisor, fn ->
      DSPEx.Optimization.optimize_configuration(
        state.program_id,
        signal.data.training_data,
        state.optimization_budget
      )
    end)
    
    # Continue processing while optimization runs in background
    updated_state = %{state | current_optimization: optimization_task}
    
    {:ok, [], updated_state}
  end

  defp adapt_configuration(state, execution_result) do
    # Simple adaptation: if performance is poor, trigger mini-optimization
    if execution_result.performance_score < 0.7 do
      # Trigger adaptive optimization with small budget
      new_config = DSPEx.Variables.AdaptiveOptimizer.quick_optimize(
        state.program_id,
        state.variable_configuration,
        [execution_result],
        budget: 5
      )
      
      %{state | variable_configuration: new_config}
    else
      state
    end
  end
end

# Enterprise API with Automatic GraphQL Generation
defmodule DSPExWeb.Schema do
  use Absinthe.Schema
  use AshGraphql, domains: [DSPEx.Domain, DSPEx.Variables.Domain]

  query do
    # Automatically generated queries for all Ash resources
  end

  mutation do
    # Automatically generated mutations
  end

  subscription do
    field :optimization_progress, :optimization_run do
      arg :run_id, non_null(:id)
      
      config fn args, _info ->
        {:ok, topic: "optimization:#{args.run_id}"}
      end
    end

    field :variable_performance_updates, :variable_performance_record do
      arg :variable_id, non_null(:id)
      
      config fn args, _info ->
        {:ok, topic: "variable:#{args.variable_id}"}
      end
    end

    field :pareto_frontier_updates, :pareto_point do
      arg :optimization_id, non_null(:id)
      
      config fn args, _info ->
        {:ok, topic: "pareto:#{args.optimization_id}"}
      end
    end
  end
end

# Real-Time Optimization Dashboard
defmodule DSPExWeb.OptimizationLive do
  use DSPExWeb, :live_view

  def mount(_params, _session, socket) do
    # Subscribe to optimization signals
    DSPEx.OptimizationSignalBus.subscribe("dspex.optimization.*")
    DSPEx.OptimizationSignalBus.subscribe("dspex.variable.*")
    
    {:ok, assign(socket, 
      optimizations: load_active_optimizations(),
      pareto_frontiers: %{},
      variable_performance: %{},
      real_time_updates: true
    )}
  end

  def handle_info({:signal, %Jido.Signal{type: "dspex.optimization.configuration.evaluated"} = signal}, socket) do
    # Update Pareto frontier visualization in real-time
    updated_frontiers = update_pareto_visualization(socket.assigns.pareto_frontiers, signal)
    
    {:noreply, assign(socket, pareto_frontiers: updated_frontiers)}
  end

  def handle_info({:signal, %Jido.Signal{type: "dspex.variable.performance.updated"} = signal}, socket) do
    # Update variable performance metrics
    updated_performance = update_variable_performance(socket.assigns.variable_performance, signal)
    
    {:noreply, assign(socket, variable_performance: updated_performance)}
  end

  def render(assigns) do
    ~H"""
    <div class="optimization-dashboard">
      <.live_component module={DSPExWeb.ParetoFrontierComponent} 
        id="pareto-frontier" 
        frontiers={@pareto_frontiers} />
      
      <.live_component module={DSPExWeb.VariableImportanceComponent} 
        id="variable-importance" 
        performance_data={@variable_performance} />
      
      <.live_component module={DSPExWeb.OptimizationProgressComponent} 
        id="optimization-progress" 
        optimizations={@optimizations} />
    </div>
    """
  end
end

# Continuous Learning System for Variables
defmodule DSPEx.Variables.ContinuousLearner do
  use GenServer
  use Jido.Signal.Handler

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  def init(_opts) do
    # Subscribe to performance signals
    DSPEx.OptimizationSignalBus.subscribe("dspex.execution.*")
    DSPEx.OptimizationSignalBus.subscribe("dspex.optimization.*")
    
    {:ok, %{
      performance_models: %{},
      learning_rate: 0.1,
      adaptation_threshold: 0.05,
      model_update_frequency: 100
    }}
  end

  def handle_signal(%Jido.Signal{type: "dspex.execution.completed"} = signal, state) do
    # Extract variable configuration and performance
    config = signal.data.variable_configuration
    performance = signal.data.performance_metrics
    
    # Update performance models for each variable
    updated_models = update_variable_performance_models(
      state.performance_models,
      config,
      performance,
      state.learning_rate
    )
    
    # Check if any variable needs recalibration
    variables_to_recalibrate = identify_recalibration_candidates(
      updated_models,
      state.adaptation_threshold
    )
    
    # Trigger recalibration if needed
    if length(variables_to_recalibrate) > 0 do
      trigger_variable_recalibration(variables_to_recalibrate)
    end
    
    {:ok, %{state | performance_models: updated_models}}
  end

  defp update_variable_performance_models(models, config, performance, learning_rate) do
    Enum.reduce(config, models, fn {variable_name, value}, acc_models ->
      current_model = Map.get(acc_models, variable_name, %{values: %{}, performance_history: []})
      
      # Update value performance tracking
      updated_values = Map.update(current_model.values, value, [performance], fn existing ->
        # Exponential moving average
        [performance | Enum.take(existing, 99)]
      end)
      
      # Update overall performance history
      updated_history = [performance | Enum.take(current_model.performance_history, 999)]
      
      # Calculate performance trends
      trends = calculate_performance_trends(updated_history)
      
      updated_model = %{
        values: updated_values,
        performance_history: updated_history,
        trends: trends,
        last_updated: DateTime.utc_now()
      }
      
      Map.put(acc_models, variable_name, updated_model)
    end)
  end

  defp identify_recalibration_candidates(models, threshold) do
    models
    |> Enum.filter(fn {_variable_name, model} ->
      # Check if performance trend indicates need for recalibration
      performance_variance = calculate_performance_variance(model.performance_history)
      trend_slope = Map.get(model.trends, :slope, 0)
      
      # Recalibrate if high variance or declining performance
      performance_variance > threshold or trend_slope < -threshold
    end)
    |> Enum.map(fn {variable_name, _model} -> variable_name end)
  end

  defp trigger_variable_recalibration(variable_names) do
    # Launch background recalibration tasks
    Enum.each(variable_names, fn variable_name ->
      Task.Supervisor.start_child(DSPEx.TaskSupervisor, fn ->
        DSPEx.Variables.Recalibrator.recalibrate_variable(variable_name)
      end)
    end)
  end
end

# Static Analysis for DSPEx Programs
defmodule DSPEx.StaticAnalysis.Compiler do
  @moduledoc """
  BAML-inspired static analysis for DSPEx programs.
  Provides compile-time validation and IDE integration.
  """

  defmacro defprogram(name, do: block) do
    quote do
      @program_name unquote(name)
      @before_compile DSPEx.StaticAnalysis.Compiler
      
      unquote(block)
    end
  end

  defmacro __before_compile__(env) do
    program_ast = Module.get_attribute(env.module, :program_definition)
    
    # Perform static analysis
    analysis_result = analyze_program(program_ast, env)
    
    # Generate optimized code
    optimized_code = optimize_program(program_ast, analysis_result)
    
    # Generate validation functions
    validation_code = generate_validations(program_ast, analysis_result)
    
    quote do
      unquote(optimized_code)
      unquote(validation_code)
      
      def __program_analysis__, do: unquote(Macro.escape(analysis_result))
    end
  end

  defp analyze_program(ast, env) do
    %{
      variable_dependencies: analyze_variable_dependencies(ast),
      performance_characteristics: estimate_performance(ast),
      cost_analysis: analyze_cost_profile(ast),
      optimization_opportunities: identify_optimizations(ast),
      type_safety_analysis: analyze_type_safety(ast, env),
      compatibility_matrix: analyze_compatibility(ast)
    }
  end

  defp generate_validations(ast, analysis) do
    quote do
      def validate_configuration(config) do
        # Generated validation based on static analysis
        with {:ok, _} <- validate_variable_types(config),
             {:ok, _} <- validate_dependencies(config),
             {:ok, _} <- validate_constraints(config) do
          {:ok, config}
        end
      end
      
      def estimate_performance(config) do
        # Generated performance estimation
        base_performance = unquote(analysis.performance_characteristics.base_score)
        variable_impact = calculate_variable_impact(config, unquote(Macro.escape(analysis.variable_dependencies)))
        
        base_performance * variable_impact
      end
      
      def estimate_cost(config) do
        # Generated cost estimation
        unquote(generate_cost_estimation(analysis.cost_analysis))
      end
    end
  end
end

# Usage Example
defmodule MyApp.IntelligentQA do
  use DSPEx.StaticAnalysis.Compiler

  defprogram :intelligent_qa do
    signature MySignatures.QuestionAnswering
    
    variables do
      discrete :adapter, choices: [:json, :markdown, :chat]
      discrete :reasoning, choices: [:predict, :cot, :pot]
      continuous :temperature, range: {0.1, 1.5}
      discrete :provider, choices: [:openai, :anthropic, :groq]
    end
    
    constraints do
      # Provider-specific constraints
      constraint :provider_model_compatibility do
        if variable(:provider) == :groq do
          variable(:reasoning) in [:predict, :cot]  # PoT not supported on Groq
        end
      end
      
      # Performance constraints
      constraint :latency_optimization do
        if variable(:reasoning) == :pot do
          variable(:provider) != :groq  # Avoid high-latency combination
        end
      end
    end
    
    optimization do
      objectives [:accuracy, :cost, :latency]
      weights %{accuracy: 0.5, cost: 0.3, latency: 0.2}
      
      # Static analysis can determine optimal strategies
      prefer_strategy :bayesian_optimization when variable_count() > 5
      prefer_strategy :grid_search when discrete_space_size() < 50
    end
  end
end

# Distributed Optimization Coordinator
defmodule DSPEx.Distributed.OptimizationCoordinator do
  use GenServer
  use Jido.Agent, name: "distributed_optimization_coordinator"

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  def init(opts) do
    # Connect to other nodes in the cluster
    cluster_nodes = Keyword.get(opts, :cluster_nodes, [])
    Enum.each(cluster_nodes, &Node.connect/1)
    
    # Subscribe to node events
    :net_kernel.monitor_nodes(true)
    
    {:ok, %{
      active_optimizations: %{},
      node_capabilities: %{},
      work_distribution: %{},
      fault_tolerance_config: Keyword.get(opts, :fault_tolerance, %{})
    }}
  end

  def distribute_optimization(program_id, variable_space, training_data, budget) do
    GenServer.call(__MODULE__, {
      :distribute_optimization, 
      program_id, 
      variable_space, 
      training_data, 
      budget
    })
  end

  def handle_call({:distribute_optimization, program_id, variable_space, training_data, budget}, _from, state) do
    # Analyze cluster capabilities
    available_nodes = [Node.self() | Node.list()]
    node_capabilities = assess_node_capabilities(available_nodes)
    
    # Partition optimization space
    optimization_partitions = partition_optimization_space(
      variable_space, 
      budget, 
      length(available_nodes)
    )
    
    # Distribute work across nodes
    distributed_tasks = 
      optimization_partitions
      |> Enum.zip(available_nodes)
      |> Enum.map(fn {partition, node} ->
        start_distributed_optimization_task(node, program_id, partition, training_data)
      end)
    
    # Track optimization
    optimization_id = generate_optimization_id()
    updated_state = %{state | 
      active_optimizations: Map.put(state.active_optimizations, optimization_id, %{
        program_id: program_id,
        tasks: distributed_tasks,
        started_at: DateTime.utc_now(),
        partitions: optimization_partitions
      })
    }
    
    {:reply, {:ok, optimization_id}, updated_state}
  end

  defp start_distributed_optimization_task(node, program_id, partition, training_data) do
    # Start remote optimization task with fault tolerance
    Task.Supervisor.async({DSPEx.TaskSupervisor, node}, fn ->
      try do
        DSPEx.Optimization.LocalOptimizer.optimize(
          program_id,
          partition.variable_space,
          training_data,
          partition.budget
        )
      rescue
        error ->
          # Report error back to coordinator
          DSPEx.Distributed.OptimizationCoordinator.report_task_failure(
            Node.self(),
            program_id,
            error
          )
          {:error, error}
      end
    end)
  end

  def handle_info({:nodedown, node}, state) do
    # Handle node failure - redistribute work
    failed_optimizations = find_optimizations_on_node(state.active_optimizations, node)
    
    updated_state = Enum.reduce(failed_optimizations, state, fn optimization_id, acc_state ->
      redistribute_failed_optimization(optimization_id, node, acc_state)
    end)
    
    {:noreply, updated_state}
  end

  defp redistribute_failed_optimization(optimization_id, failed_node, state) do
    optimization = Map.get(state.active_optimizations, optimization_id)
    
    # Find partition that was running on failed node
    failed_partition = find_partition_on_node(optimization.partitions, failed_node)
    
    # Redistribute to available node
    available_nodes = [Node.self() | Node.list()] -- [failed_node]
    
    if length(available_nodes) > 0 do
      backup_node = Enum.random(available_nodes)
      
      # Start replacement task
      replacement_task = start_distributed_optimization_task(
        backup_node,
        optimization.program_id,
        failed_partition,
        [] # Use cached training data
      )
      
      # Update optimization tracking
      updated_tasks = optimization.tasks
        |> Enum.reject(fn task -> task.node == failed_node end)
        |> Kernel.++([replacement_task])
      
      updated_optimization = %{optimization | tasks: updated_tasks}
      
      %{state | 
        active_optimizations: Map.put(state.active_optimizations, optimization_id, updated_optimization)
      }
    else
      # No available nodes - optimization fails
      state
    end
  end
end

# Production Deployment Manager
defmodule DSPEx.Production.DeploymentManager do
  use Ash.Resource, domain: DSPEx.Production.Domain

  attributes do
    uuid_primary_key :id
    attribute :name, :string, allow_nil?: false
    attribute :program_id, :uuid, allow_nil?: false
    attribute :optimized_configuration, :map, allow_nil?: false
    attribute :deployment_strategy, :atom, default: :blue_green
    attribute :auto_scaling_config, :map, default: %{}
    attribute :monitoring_config, :map, default: %{}
    attribute :rollback_config, :map, default: %{}
    attribute :status, :atom, default: :pending
  end

  relationships do
    belongs_to :program, DSPEx.Resources.Program
    has_many :deployment_instances, DSPEx.Production.DeploymentInstance
    has_many :performance_metrics, DSPEx.Production.PerformanceMetric
  end

  actions do
    action :deploy, DSPEx.Production.DeploymentManager do
      argument :environment, :atom, allow_nil?: false
      argument :deployment_options, :map, default: %{}
      run DSPEx.Production.Actions.Deploy
    end
    
    action :scale, DSPEx.Production.DeploymentManager do
      argument :target_capacity, :integer, allow_nil?: false
      argument :scaling_strategy, :atom, default: :gradual
      run DSPEx.Production.Actions.Scale
    end
    
    action :rollback, DSPEx.Production.DeploymentManager do
      argument :reason, :string, allow_nil?: false
      run DSPEx.Production.Actions.Rollback
    end
  end

  calculations do
    calculate :health_score, :float do
      DSPEx.Production.Calculations.HealthScore
    end
    
    calculate :performance_trend, :map do
      DSPEx.Production.Calculations.PerformanceTrend
    end
    
    calculate :cost_efficiency, :float do
      DSPEx.Production.Calculations.CostEfficiency
    end
  end
end

# Health Monitoring System
defmodule DSPEx.Production.HealthMonitor do
  use GenServer
  use Jido.Signal.Handler

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  def init(_opts) do
    # Subscribe to production signals
    DSPEx.OptimizationSignalBus.subscribe("dspex.production.*")
    
    # Schedule periodic health checks
    :timer.send_interval(30_000, :health_check)  # Every 30 seconds
    
    {:ok, %{
      deployment_health: %{},
      alert_thresholds: %{
        error_rate: 0.05,
        latency_p95: 5000,
        cost_spike: 2.0
      },
      alert_history: []
    }}
  end

  def handle_info(:health_check, state) do
    # Check health of all active deployments
    active_deployments = DSPEx.Production.DeploymentManager.list_active!()
    
    health_results = 
      active_deployments
      |> Task.async_stream(fn deployment ->
        check_deployment_health(deployment)
      end, max_concurrency: 10)
      |> Enum.map(fn {:ok, result} -> result end)
    
    # Update health state
    updated_health = 
      health_results
      |> Enum.reduce(state.deployment_health, fn {deployment_id, health}, acc ->
        Map.put(acc, deployment_id, health)
      end)
    
    # Check for alerts
    alerts = check_for_alerts(health_results, state.alert_thresholds)
    
    # Send alerts if needed
    if length(alerts) > 0 do
      send_alerts(alerts)
    end
    
    {:noreply, %{state | 
      deployment_health: updated_health,
      alert_history: alerts ++ Enum.take(state.alert_history, 100)
    }}
  end

  defp check_deployment_health(deployment) do
    # Collect comprehensive health metrics
    health_metrics = %{
      error_rate: calculate_error_rate(deployment),
      latency_p95: calculate_latency_p95(deployment),
      throughput: calculate_throughput(deployment),
      cost_per_request: calculate_cost_per_request(deployment),
      memory_usage: get_memory_usage(deployment),
      cpu_usage: get_cpu_usage(deployment),
      active_connections: get_active_connections(deployment)
    }
    
    # Calculate overall health score
    health_score = calculate_health_score(health_metrics)
    
    {deployment.id, %{
      metrics: health_metrics,
      health_score: health_score,
      status: determine_health_status(health_score),
      last_checked: DateTime.utc_now()
    }}
  end

  defp send_alerts(alerts) do
    # Send alerts through multiple channels
    Enum.each(alerts, fn alert ->
      # Slack notification
      DSPEx.Notifications.Slack.send_alert(alert)
      
      # Email notification for critical alerts
      if alert.severity == :critical do
        DSPEx.Notifications.Email.send_alert(alert)
      end
      
      # Database logging
      DSPEx.Production.Alert.create!(alert)
      
      # Signal bus notification
      DSPEx.OptimizationSignalBus.emit(%Jido.Signal{
        type: "dspex.production.alert",
        data: alert
      })
    end)
  end
end