defmodule Foundation.MABEAM.Protocols.Selector do
  @moduledoc """
  Intelligent protocol selection based on coordination requirements
  """
  
  @protocol_matrix %{
    # Simple coordination (2-5 agents, low fault tolerance)
    {2..5, :low_fault, :standard} => :simple_consensus,
    
    # Hierarchical coordination (6+ agents, scalability needed) 
    {6..50, :medium_fault, :standard} => :hierarchical_consensus,
    
    # Byzantine coordination (fault tolerance critical)
    {4..20, :high_fault, :standard} => :byzantine_consensus,
    
    # Economic coordination (resource optimization needed)
    {2..100, :any_fault, :economic} => :market_coordination,
    
    # ML-specific coordination
    {2..50, :any_fault, :ml_ensemble} => :ensemble_learning,
    {3..20, :any_fault, :ml_optimization} => :hyperparameter_optimization,
    {2..10, :any_fault, :ml_reasoning} => :reasoning_consensus,
    
    # Distributed coordination (cluster deployment)
    {10..1000, :any_fault, :distributed} => :distributed_coordination
  }
  
  def select_protocol(coordination_spec) do
    participant_count = length(coordination_spec.participants)
    fault_tolerance = coordination_spec.fault_tolerance || :low_fault
    coordination_type = coordination_spec.type || :standard
    
    # Find matching protocol
    case find_matching_protocol(participant_count, fault_tolerance, coordination_type) do
      nil ->
        {:error, :no_suitable_protocol}
        
      protocol ->
        {:ok, protocol}
    end
  end
  
  defp find_matching_protocol(count, fault_tolerance, type) do
    Enum.find_value(@protocol_matrix, fn {{range, fault, coord_type}, protocol} ->
      if count in range and 
         (fault == fault_tolerance or fault == :any_fault) and
         (coord_type == type or coord_type == :standard or fault_tolerance == :any_fault) do
        protocol
      end
    end)
  end
end

defmodule Foundation.MABEAM.Protocols.HierarchicalConsensus do
  @moduledoc """
  Hierarchical consensus for large agent teams (6+ agents)
  
  Features:
  - Multi-level delegation trees
  - Automatic representative selection
  - Load balancing across hierarchy levels
  - Fault tolerance with representative replacement
  - Scalable to hundreds of agents
  """
  
  use GenServer
  require Logger
  
  defstruct [
    :coordination_id,
    :proposal,
    :participants,
    :hierarchy,
    :delegation_strategy,
    :consensus_threshold,
    :timeout,
    :started_at,
    :current_level,
    :level_results,
    :status
  ]
  
  def start_coordination(coordination_id, coordination_spec, opts) do
    GenServer.start_link(__MODULE__, {coordination_id, coordination_spec, opts})
  end
  
  def init({coordination_id, coordination_spec, opts}) do
    # Build hierarchy structure
    hierarchy = build_hierarchy(
      coordination_spec.participants,
      opts[:cluster_size] || 5,
      opts[:max_levels] || 4
    )
    
    state = %__MODULE__{
      coordination_id: coordination_id,
      proposal: coordination_spec.proposal,
      participants: coordination_spec.participants,
      hierarchy: hierarchy,
      delegation_strategy: opts[:delegation_strategy] || :expertise_based,
      consensus_threshold: coordination_spec.consensus_threshold || 0.7,
      timeout: coordination_spec.timeout || 30_000,
      started_at: DateTime.utc_now(),
      current_level: 0,
      level_results: %{},
      status: :starting
    }
    
    # Start coordination at leaf level
    send(self(), :start_level_coordination)
    
    # Set overall timeout
    Process.send_after(self(), :coordination_timeout, state.timeout)
    
    Logger.info("Started hierarchical consensus: #{coordination_id} with #{length(coordination_spec.participants)} participants")
    
    {:ok, state}
  end
  
  def handle_info(:start_level_coordination, state) do
    case start_level_coordination(state.current_level, state) do
      {:ok, new_state} ->
        {:noreply, %{new_state | status: :coordinating}}
        
      {:error, reason} ->
        notify_completion({:error, reason}, state)
        {:stop, :normal, state}
    end
  end
  
  def handle_info({:level_complete, level, results}, state) do
    # Store level results
    updated_state = %{state | 
      level_results: Map.put(state.level_results, level, results)
    }
    
    # Check if we need to continue to next level
    case should_continue_to_next_level?(level, results, updated_state) do
      true ->
        next_level = level + 1
        
        case start_level_coordination(next_level, %{updated_state | current_level: next_level}) do
          {:ok, final_state} ->
            {:noreply, final_state}
            
          {:error, reason} ->
            notify_completion({:error, reason}, updated_state)
            {:stop, :normal, updated_state}
        end
        
      false ->
        # Coordination complete
        final_result = compile_final_result(updated_state)
        notify_completion({:ok, final_result}, updated_state)
        {:stop, :normal, updated_state}
    end
  end
  
  def handle_info(:coordination_timeout, state) do
    Logger.warning("Hierarchical consensus timeout: #{state.coordination_id}")
    notify_completion({:error, :timeout}, state)
    {:stop, :normal, state}
  end
  
  # Private implementation
  defp build_hierarchy(participants, cluster_size, max_levels) do
    # Build hierarchical structure
    hierarchy = participants
    |> Enum.chunk_every(cluster_size)
    |> build_hierarchy_levels([], 0, max_levels)
    
    Logger.debug("Built hierarchy: #{inspect(hierarchy)}")
    hierarchy
  end
  
  defp build_hierarchy_levels([], acc, _level, _max_levels), do: Enum.reverse(acc)
  defp build_hierarchy_levels([single_cluster], acc, level, _max_levels) when length(single_cluster) <= 1 do
    # Single element at top - hierarchy complete
    Enum.reverse([%{level: level, clusters: [single_cluster]} | acc])
  end
  defp build_hierarchy_levels(clusters, acc, level, max_levels) when level >= max_levels do
    # Max levels reached - flatten remaining
    flat_cluster = List.flatten(clusters)
    Enum.reverse([%{level: level, clusters: [flat_cluster]} | acc])
  end
  defp build_hierarchy_levels(clusters, acc, level, max_levels) do
    # Create representatives for each cluster
    representatives = Enum.map(clusters, fn cluster ->
      select_cluster_representative(cluster)
    end)
    
    level_info = %{
      level: level,
      clusters: clusters,
      representatives: representatives
    }
    
    # Continue with representatives for next level
    next_clusters = [representatives]
    build_hierarchy_levels(next_clusters, [level_info | acc], level + 1, max_levels)
  end
  
  defp select_cluster_representative(cluster) do
    # Select representative based on agent capabilities/reputation
    cluster
    |> Enum.map(fn agent_id ->
      {agent_id, get_agent_coordination_score(agent_id)}
    end)
    |> Enum.max_by(fn {_agent_id, score} -> score end)
    |> elem(0)
  end
  
  defp get_agent_coordination_score(agent_id) do
    case Foundation.MABEAM.Registry.lookup_agent(agent_id) do
      {:ok, agent_info} ->
        # Calculate score based on performance, reputation, availability
        base_score = 0.5
        performance_score = Map.get(agent_info, :performance_score, 0.5)
        reputation_score = get_agent_reputation_score(agent_id)
        availability_score = get_agent_availability_score(agent_id)
        
        (base_score + performance_score + reputation_score + availability_score) / 4
        
      {:error, _} ->
        0.0
    end
  end
  
  defp start_level_coordination(level, state) do
    level_info = Enum.find(state.hierarchy, fn l -> l.level == level end)
    
    case level_info do
      nil ->
        {:error, :invalid_level}
        
      %{clusters: clusters} ->
        # Start coordination within each cluster
        cluster_coordinators = Enum.map(clusters, fn cluster ->
          start_cluster_coordination(cluster, level, state)
        end)
        
        # Monitor cluster coordinators
        Enum.each(cluster_coordinators, fn coordinator_pid ->
          Process.monitor(coordinator_pid)
        end)
        
        {:ok, state}
    end
  end
  
  defp start_cluster_coordination(cluster, level, state) do
    # Start coordination within a single cluster
    spawn_link(fn ->
      result = coordinate_cluster(cluster, state.proposal, state)
      send(self(), {:cluster_result, level, cluster, result})
    end)
  end
  
  defp coordinate_cluster(cluster, proposal, state) do
    # Simple consensus within cluster
    case length(cluster) do
      1 ->
        # Single agent - automatic agreement
        {:ok, %{decision: :agree, agents: cluster, confidence: 1.0}}
        
      n when n <= 5 ->
        # Small cluster - direct consensus
        perform_direct_consensus(cluster, proposal, state)
        
      _ ->
        # Large cluster - delegate to sub-coordinator
        {:error, :cluster_too_large}
    end
  end
  
  defp perform_direct_consensus(agents, proposal, state) do
    # Collect votes from all agents
    votes = Enum.map(agents, fn agent_id ->
      case request_agent_vote(agent_id, proposal, state.timeout) do
        {:ok, vote} -> {agent_id, vote}
        {:error, _} -> {agent_id, %{decision: :abstain, confidence: 0.0}}
      end
    end)
    
    # Analyze votes
    analyze_cluster_votes(votes, state.consensus_threshold)
  end
  
  defp request_agent_vote(agent_id, proposal, timeout) do
    case Foundation.MABEAM.Registry.lookup_agent(agent_id) do
      {:ok, agent_info} ->
        # Send vote request to agent
        try do
          vote_request = %{
            type: :coordination_vote,
            proposal: proposal,
            timeout: timeout
          }
          
          case GenServer.call(agent_info.pid, vote_request, timeout) do
            {:vote, vote_data} ->
              {:ok, vote_data}
              
            _ ->
              {:error, :invalid_response}
          end
        catch
          :exit, _ ->
            {:error, :agent_timeout}
        end
        
      {:error, reason} ->
        {:error, reason}
    end
  end
  
  defp analyze_cluster_votes(votes, consensus_threshold) do
    total_votes = length(votes)
    
    # Calculate weighted consensus
    {agree_count, agree_confidence} = calculate_agreement_metrics(votes, :agree)
    {disagree_count, disagree_confidence} = calculate_agreement_metrics(votes, :disagree)
    
    agree_ratio = agree_count / total_votes
    
    cond do
      agree_ratio >= consensus_threshold ->
        {:ok, %{
          decision: :agree,
          confidence: agree_confidence,
          vote_ratio: agree_ratio,
          detailed_votes: votes
        }}
        
      disagree_count / total_votes >= consensus_threshold ->
        {:ok, %{
          decision: :disagree,
          confidence: disagree_confidence,
          vote_ratio: 1 - agree_ratio,
          detailed_votes: votes
        }}
        
      true ->
        {:ok, %{
          decision: :no_consensus,
          confidence: 0.5,
          vote_ratio: agree_ratio,
          detailed_votes: votes
        }}
    end
  end
  
  defp calculate_agreement_metrics(votes, target_decision) do
    matching_votes = Enum.filter(votes, fn {_agent, vote} ->
      vote.decision == target_decision
    end)
    
    count = length(matching_votes)
    
    avg_confidence = if count > 0 do
      matching_votes
      |> Enum.map(fn {_agent, vote} -> vote.confidence || 0.5 end)
      |> Enum.sum()
      |> Kernel./(count)
    else
      0.0
    end
    
    {count, avg_confidence}
  end
  
  defp should_continue_to_next_level?(level, results, state) do
    # Check if consensus reached at this level
    case results do
      {:ok, %{decision: :agree}} ->
        # Agreement reached - continue up hierarchy
        level < get_max_level(state.hierarchy) - 1
        
      {:ok, %{decision: :disagree}} ->
        # Clear disagreement - stop coordination
        false
        
      {:ok, %{decision: :no_consensus}} ->
        # No consensus - escalate to next level
        level < get_max_level(state.hierarchy) - 1
        
      {:error, _} ->
        # Error - stop coordination
        false
    end
  end
  
  defp get_max_level(hierarchy) do
    hierarchy
    |> Enum.map(& &1.level)
    |> Enum.max()
  end
  
  defp compile_final_result(state) do
    # Compile results from all levels
    final_decision = determine_final_decision(state.level_results)
    
    %{
      coordination_id: state.coordination_id,
      decision: final_decision,
      hierarchy_results: state.level_results,
      participants: state.participants,
      duration: DateTime.diff(DateTime.utc_now(), state.started_at, :microsecond)
    }
  end
  
  defp determine_final_decision(level_results) do
    # Get highest level result
    highest_level = level_results |> Map.keys() |> Enum.max()
    
    case Map.get(level_results, highest_level) do
      {:ok, %{decision: decision}} -> decision
      _ -> :no_consensus
    end
  end
  
  defp notify_completion(result, state) do
    send(Foundation.MABEAM.Coordination, {:coordination_complete, state.coordination_id, result})
  end
  
  defp get_agent_reputation_score(agent_id) do
    case Foundation.MABEAM.Economics.get_agent_reputation(agent_id) do
      {:ok, reputation} -> reputation.overall_score
      {:error, _} -> 0.5
    end
  end
  
  defp get_agent_availability_score(agent_id) do
    case Foundation.MABEAM.Registry.get_agent_health(agent_id) do
      {:ok, %{status: :healthy}} -> 1.0
      {:ok, %{status: :overloaded}} -> 0.3
      _ -> 0.0
    end
  end
end

defmodule Foundation.MABEAM.Protocols.ByzantineConsensus do
  @moduledoc """
  Byzantine fault tolerant consensus using PBFT algorithm
  
  Features:
  - Tolerates up to f faulty nodes in 3f+1 system
  - Three-phase consensus protocol (pre-prepare, prepare, commit)
  - View change mechanism for leader failures
  - Cryptographic message authentication
  - Deterministic ordering of requests
  """
  
  use GenServer
  require Logger
  
  defstruct [
    :coordination_id,
    :proposal,
    :participants,
    :view_number,
    :sequence_number,
    :primary_node,
    :phase,
    :message_log,
    :prepare_votes,
    :commit_votes,
    :timeout_timers,
    :status,
    :f_value,  # Maximum number of faulty nodes
    :started_at
  ]
  
  def start_coordination(coordination_id, coordination_spec, opts) do
    GenServer.start_link(__MODULE__, {coordination_id, coordination_spec, opts})
  end
  
  def init({coordination_id, coordination_spec, opts}) do
    participants = coordination_spec.participants
    f_value = calculate_f_value(length(participants))
    
    # Verify we have enough nodes for Byzantine tolerance
    if length(participants) < 3 * f_value + 1 do
      Logger.error("Insufficient nodes for Byzantine consensus: need #{3 * f_value + 1}, have #{length(participants)}")
      {:stop, :insufficient_nodes}
    else
      state = %__MODULE__{
        coordination_id: coordination_id,
        proposal: coordination_spec.proposal,
        participants: participants,
        view_number: 0,
        sequence_number: 1,
        primary_node: select_primary_node(participants, 0),
        phase: :pre_prepare,
        message_log: [],
        prepare_votes: %{},
        commit_votes: %{},
        timeout_timers: %{},
        status: :starting,
        f_value: f_value,
        started_at: DateTime.utc_now()
      }
      
      # Start consensus if we are the primary
      if am_primary?(state) do
        send(self(), :start_pre_prepare_phase)
      end
      
      # Set overall timeout
      Process.send_after(self(), :consensus_timeout, opts[:timeout] || 60_000)
      
      Logger.info("Started Byzantine consensus: #{coordination_id} as #{if am_primary?(state), do: "primary", else: "backup"}")
      
      {:ok, state}
    end
  end
  
  # Pre-prepare phase (primary only)
  def handle_info(:start_pre_prepare_phase, state) when state.phase == :pre_prepare do
    if am_primary?(state) do
      # Create pre-prepare message
      pre_prepare_msg = create_pre_prepare_message(state)
      
      # Broadcast to all backup nodes
      broadcast_to_backups(pre_prepare_msg, state)
      
      # Log our own message
      new_state = log_message(state, pre_prepare_msg)
      
      # Move to prepare phase
      updated_state = %{new_state | phase: :prepare}
      
      # Start prepare phase timeout
      timeout_ref = Process.send_after(self(), {:phase_timeout, :prepare}, 15_000)
      final_state = %{updated_state | 
        timeout_timers: Map.put(updated_state.timeout_timers, :prepare, timeout_ref)
      }
      
      {:noreply, final_state}
    else
      {:noreply, state}
    end
  end
  
  # Handle incoming Byzantine messages
  def handle_cast({:byzantine_message, message}, state) do
    case validate_message(message, state) do
      {:ok, validated_message} ->
        new_state = process_byzantine_message(validated_message, state)
        {:noreply, new_state}
        
      {:error, reason} ->
        Logger.warning("Invalid Byzantine message: #{inspect(reason)}")
        {:noreply, state}
    end
  end
  
  # Phase timeouts
  def handle_info({:phase_timeout, phase}, state) when state.phase == phase do
    Logger.warning("Byzantine consensus phase timeout: #{phase}")
    
    case phase do
      :prepare ->
        # Prepare phase timeout - might need view change
        if should_trigger_view_change?(state) do
          start_view_change(state)
        else
          {:noreply, state}
        end
        
      :commit ->
        # Commit phase timeout - consensus failed
        notify_completion({:error, :commit_timeout}, state)
        {:stop, :normal, state}
    end
  end
  
  def handle_info(:consensus_timeout, state) do
    Logger.warning("Byzantine consensus overall timeout: #{state.coordination_id}")
    notify_completion({:error, :timeout}, state)
    {:stop, :normal, state}
  end
  
  # Private implementation
  defp calculate_f_value(node_count) do
    # f = floor((n-1)/3) where n is total nodes
    div(node_count - 1, 3)
  end
  
  defp select_primary_node(participants, view_number) do
    # Deterministic primary selection based on view number
    index = rem(view_number, length(participants))
    Enum.at(participants, index)
  end
  
  defp am_primary?(state) do
    state.primary_node == node()
  end
  
  defp create_pre_prepare_message(state) do
    %{
      type: :pre_prepare,
      view: state.view_number,
      sequence: state.sequence_number,
      proposal: state.proposal,
      primary: state.primary_node,
      timestamp: DateTime.utc_now(),
      signature: sign_message(%{
        view: state.view_number,
        sequence: state.sequence_number,
        proposal: state.proposal
      })
    }
  end
  
  defp broadcast_to_backups(message, state) do
    backup_nodes = Enum.reject(state.participants, &(&1 == node()))
    
    Enum.each(backup_nodes, fn backup_node ->
      send_byzantine_message(backup_node, message)
    end)
  end
  
  defp send_byzantine_message(target_node, message) do
    # Send message to Byzantine consensus process on target node
    case :rpc.call(target_node, GenServer, :cast, [
      Foundation.MABEAM.Protocols.ByzantineConsensus,
      {:byzantine_message, message}
    ]) do
      {:badrpc, reason} ->
        Logger.warning("Failed to send Byzantine message to #{target_node}: #{inspect(reason)}")
        
      _ ->
        :ok
    end
  end
  
  defp validate_message(message, state) do
    cond do
      not is_map(message) ->
        {:error, :invalid_format}
        
      not verify_message_signature(message) ->
        {:error, :invalid_signature}
        
      message.view != state.view_number ->
        {:error, :wrong_view}
        
      message.sequence != state.sequence_number ->
        {:error, :wrong_sequence}
        
      true ->
        {:ok, message}
    end
  end
  
  defp process_byzantine_message(message, state) do
    case message.type do
      :pre_prepare ->
        process_pre_prepare(message, state)
        
      :prepare ->
        process_prepare(message, state)
        
      :commit ->
        process_commit(message, state)
        
      :view_change ->
        process_view_change(message, state)
        
      _ ->
        Logger.warning("Unknown Byzantine message type: #{message.type}")
        state
    end
  end
  
  defp process_pre_prepare(message, state) when state.phase == :pre_prepare do
    if message.primary == state.primary_node do
      # Valid pre-prepare from current primary
      prepare_message = create_prepare_message(message, state)
      
      # Broadcast prepare message
      broadcast_to_all(prepare_message, state)
      
      # Log messages and update state
      state
      |> log_message(message)
      |> log_message(prepare_message)
      |> Map.put(:phase, :prepare)
      |> start_prepare_timeout()
    else
      Logger.warning("Pre-prepare from wrong primary: #{message.primary}")
      state
    end
  end
  defp process_pre_prepare(_message, state), do: state
  
  defp process_prepare(message, state) when state.phase == :prepare do
    # Count prepare votes
    sender = message.sender
    new_prepare_votes = Map.put(state.prepare_votes, sender, message)
    updated_state = %{state | prepare_votes: new_prepare_votes}
    
    # Check if we have enough prepare votes (2f+1)
    if map_size(new_prepare_votes) >= 2 * state.f_value + 1 do
      # Move to commit phase
      commit_message = create_commit_message(message, updated_state)
      broadcast_to_all(commit_message, updated_state)
      
      updated_state
      |> log_message(commit_message)
      |> Map.put(:phase, :commit)
      |> start_commit_timeout()
    else
      updated_state
    end
  end
  defp process_prepare(_message, state), do: state
  
  defp process_commit(message, state) when state.phase == :commit do
    # Count commit votes
    sender = message.sender
    new_commit_votes = Map.put(state.commit_votes, sender, message)
    updated_state = %{state | commit_votes: new_commit_votes}
    
    # Check if we have enough commit votes (2f+1)
    if map_size(new_commit_votes) >= 2 * state.f_value + 1 do
      # Consensus reached!
      result = %{
        decision: :commit,
        proposal: state.proposal,
        view: state.view_number,
        sequence: state.sequence_number,
        participants: state.participants,
        duration: DateTime.diff(DateTime.utc_now(), state.started_at, :microsecond)
      }
      
      notify_completion({:ok, result}, updated_state)
      updated_state
    else
      updated_state
    end
  end
  defp process_commit(_message, state), do: state
  
  defp create_prepare_message(pre_prepare_msg, state) do
    %{
      type: :prepare,
      view: state.view_number,
      sequence: state.sequence_number,
      digest: create_message_digest(pre_prepare_msg),
      sender: node(),
      timestamp: DateTime.utc_now(),
      signature: sign_prepare_message(state.view_number, state.sequence_number, pre_prepare_msg)
    }
  end
  
  defp create_commit_message(prepare_msg, state) do
    %{
      type: :commit,
      view: state.view_number,
      sequence: state.sequence_number,
      digest: prepare_msg.digest,
      sender: node(),
      timestamp: DateTime.utc_now(),
      signature: sign_commit_message(state.view_number, state.sequence_number, prepare_msg)
    }
  end
  
  defp broadcast_to_all(message, state) do
    Enum.each(state.participants, fn participant ->
      if participant != node() do
        send_byzantine_message(participant, message)
      end
    end)
  end
  
  defp log_message(state, message) do
    %{state | message_log: [message | state.message_log]}
  end
  
  defp start_prepare_timeout(state) do
    timeout_ref = Process.send_after(self(), {:phase_timeout, :prepare}, 15_000)
    %{state | timeout_timers: Map.put(state.timeout_timers, :prepare, timeout_ref)}
  end
  
  defp start_commit_timeout(state) do
    timeout_ref = Process.send_after(self(), {:phase_timeout, :commit}, 15_000)
    %{state | timeout_timers: Map.put(state.timeout_timers, :commit, timeout_ref)}
  end
  
  defp should_trigger_view_change?(state) do
    # Trigger view change if prepare phase fails
    state.phase == :prepare and map_size(state.prepare_votes) < 2 * state.f_value + 1
  end
  
  defp start_view_change(state) do
    Logger.info("Starting view change from view #{state.view_number}")
    
    view_change_msg = %{
      type: :view_change,
      view: state.view_number + 1,
      sequence: state.sequence_number,
      sender: node(),
      timestamp: DateTime.utc_now()
    }
    
    broadcast_to_all(view_change_msg, state)
    
    new_state = %{state |
      view_number: state.view_number + 1,
      primary_node: select_primary_node(state.participants, state.view_number + 1),
      phase: :view_change,
      prepare_votes: %{},
      commit_votes: %{}
    }
    
    {:noreply, new_state}
  end
  
  defp process_view_change(_message, state) do
    # Simplified view change processing
    # In production, this would involve more complex view change protocol
    state
  end
  
  defp sign_message(message_data) do
    # Cryptographic signature for message authentication
    # In production, use proper cryptographic signing
    :crypto.hash(:sha256, :erlang.term_to_binary(message_data))
    |> Base.encode16(case: :lower)
  end
  
  defp verify_message_signature(message) do
    # Verify cryptographic signature
    # In production, implement proper signature verification
    Map.has_key?(message, :signature) and is_binary(message.signature)
  end
  
  defp sign_prepare_message(view, sequence, pre_prepare_msg) do
    sign_message(%{type: :prepare, view: view, sequence: sequence, digest: create_message_digest(pre_prepare_msg)})
  end
  
  defp sign_commit_message(view, sequence, prepare_msg) do
    sign_message(%{type: :commit, view: view, sequence: sequence, digest: prepare_msg.digest})
  end
  
  defp create_message_digest(message) do
    :crypto.hash(:sha256, :erlang.term_to_binary(message))
    |> Base.encode16(case: :lower)
  end
  
  defp notify_completion(result, state) do
    send(Foundation.MABEAM.Coordination, {:coordination_complete, state.coordination_id, result})
  end
end

defmodule Foundation.MABEAM.Protocols.EnsembleLearning do
  @moduledoc """
  ML-native coordination for ensemble learning workflows
  
  Features:
  - Weighted voting, stacking, and boosting strategies
  - Performance-based weight adjustment
  - Cost-aware ensemble composition
  - Real-time ensemble optimization
  - Automatic model selection and replacement
  """
  
  use GenServer
  require Logger
  
  defstruct [
    :coordination_id,
    :task_spec,
    :agent_pool,
    :ensemble_strategy,
    :model_weights,
    :performance_history,
    :cost_budget,
    :quality_threshold,
    :ensemble_composition,
    :status,
    :started_at
  ]
  
  def start_coordination(coordination_id, coordination_spec, opts) do
    GenServer.start_link(__MODULE__, {coordination_id, coordination_spec, opts})
  end
  
  def init({coordination_id, coordination_spec, opts}) do
    state = %__MODULE__{
      coordination_id: coordination_id,
      task_spec: coordination_spec.task_spec,
      agent_pool: coordination_spec.participants,
      ensemble_strategy: opts[:strategy] || :weighted_voting,
      model_weights: initialize_model_weights(coordination_spec.participants),
      performance_history: %{},
      cost_budget: opts[:cost_budget] || %{max_cost: 1.0},
      quality_threshold: opts[:quality_threshold] || 0.8,
      ensemble_composition: [],
      status: :initializing,
      started_at: DateTime.utc_now()
    }
    
    # Start ensemble coordination
    send(self(), :initialize_ensemble)
    
    {:ok, state}
  end
  
  def handle_info(:initialize_ensemble, state) do
    case initialize_ensemble_composition(state) do
      {:ok, composition, new_state} ->
        updated_state = %{new_state | 
          ensemble_composition: composition,
          status: :coordinating
        }
        
        # Start ensemble execution
        send(self(), :execute_ensemble)
        
        {:noreply, updated_state}
        
      {:error, reason} ->
        notify_completion({:error, reason}, state)
        {:stop, :normal, state}
    end
  end
  
  def handle_info(:execute_ensemble, state) do
    case execute_ensemble_coordination(state) do
      {:ok, results, new_state} ->
        # Process ensemble results
        final_result = aggregate_ensemble_results(results, new_state)
        
        # Update performance history
        updated_state = update_ensemble_performance(new_state, results, final_result)
        
        notify_completion({:ok, final_result}, updated_state)
        {:stop, :normal, updated_state}
        
      {:error, reason} ->
        notify_completion({:error, reason}, state)
        {:stop, :normal, state}
    end
  end
  
  # Handle individual model results
  def handle_cast({:model_result, agent_id, result}, state) do
    # Process individual model result
    updated_state = process_model_result(agent_id, result, state)
    
    # Check if all models have completed
    if all_models_completed?(updated_state) do
      send(self(), :finalize_ensemble)
    end
    
    {:noreply, updated_state}
  end
  
  # Private implementation
  defp initialize_ensemble_composition(state) do
    # Select optimal ensemble composition based on strategy
    case state.ensemble_strategy do
      :weighted_voting ->
        initialize_weighted_voting_ensemble(state)
        
      :stacking ->
        initialize_stacking_ensemble(state)
        
      :boosting ->
        initialize_boosting_ensemble(state)
        
      :cost_optimal ->
        initialize_cost_optimal_ensemble(state)
        
      _ ->
        {:error, :unknown_ensemble_strategy}
    end
  end
  
  defp initialize_weighted_voting_ensemble(state) do
    # Create weighted voting ensemble
    composition = Enum.map(state.agent_pool, fn agent_id ->
      initial_weight = Map.get(state.model_weights, agent_id, 1.0)
      
      %{
        agent_id: agent_id,
        model_type: get_agent_model_type(agent_id),
        weight: initial_weight,
        cost: get_agent_cost(agent_id),
        expected_performance: get_agent_expected_performance(agent_id)
      }
    end)
    
    # Filter by cost budget
    budget_filtered = filter_by_cost_budget(composition, state.cost_budget)
    
    {:ok, budget_filtered, state}
  end
  
  defp initialize_stacking_ensemble(state) do
    # Create stacking ensemble with meta-learner
    base_models = Enum.take(state.agent_pool, -1)  # All but last agent
    meta_learner = List.last(state.agent_pool)
    
    composition = [
      %{
        type: :base_models,
        agents: Enum.map(base_models, fn agent_id ->
          %{
            agent_id: agent_id,
            model_type: get_agent_model_type(agent_id),
            role: :base_learner
          }
        end)
      },
      %{
        type: :meta_learner,
        agent_id: meta_learner,
        model_type: get_agent_model_type(meta_learner),
        role: :meta_learner
      }
    ]
    
    {:ok, composition, state}
  end
  
  defp initialize_cost_optimal_ensemble(state) do
    # Use economic optimization to select ensemble
    optimization_spec = %{
      objective: :maximize_quality_per_cost,
      constraints: state.cost_budget,
      agent_pool: state.agent_pool,
      quality_threshold: state.quality_threshold
    }
    
    case Foundation.MABEAM.Economics.optimize_ensemble_selection(optimization_spec) do
      {:ok, optimal_composition} ->
        {:ok, optimal_composition, state}
        
      {:error, reason} ->
        {:error, reason}
    end
  end
  
  defp execute_ensemble_coordination(state) do
    # Execute ensemble based on composition strategy
    case state.ensemble_strategy do
      :weighted_voting ->
        execute_weighted_voting(state)
        
      :stacking ->
        execute_stacking(state)
        
      :boosting ->
        execute_boosting(state)
        
      _ ->
        execute_parallel_ensemble(state)
    end
  end
  
  defp execute_weighted_voting(state) do
    # Execute all models in parallel
    model_tasks = Enum.map(state.ensemble_composition, fn model_spec ->
      Task.async(fn ->
        execute_model_task(model_spec.agent_id, state.task_spec)
      end)
    end)
    
    # Wait for all models to complete
    results = Task.await_many(model_tasks, 30_000)
    
    # Combine results with weights
    weighted_results = Enum.zip(state.ensemble_composition, results)
    |> Enum.map(fn {model_spec, result} ->
      %{
        agent_id: model_spec.agent_id,
        result: result,
        weight: model_spec.weight,
        cost: model_spec.cost
      }
    end)
    
    {:ok, weighted_results, state}
  end
  
  defp execute_stacking(state) do
    # Phase 1: Execute base models
    base_models = get_base_models(state.ensemble_composition)
    
    base_results = Enum.map(base_models, fn model_spec ->
      execute_model_task(model_spec.agent_id, state.task_spec)
    end)
    
    # Phase 2: Execute meta-learner with base model predictions
    meta_learner = get_meta_learner(state.ensemble_composition)
    meta_task = create_meta_task(state.task_spec, base_results)
    
    meta_result = execute_model_task(meta_learner.agent_id, meta_task)
    
    stacking_result = %{
      base_results: base_results,
      meta_result: meta_result,
      strategy: :stacking
    }
    
    {:ok, stacking_result, state}
  end
  
  defp execute_model_task(agent_id, task_spec) do
    case Foundation.MABEAM.Registry.lookup_agent(agent_id) do
      {:ok, agent_info} ->
        try do
          # Send task to agent
          task_request = %{
            type: :ml_task,
            task_spec: task_spec,
            timeout: 30_000
          }
          
          case GenServer.call(agent_info.pid, task_request, 35_000) do
            {:task_result, result} ->
              {:ok, result}
              
            {:error, reason} ->
              {:error, reason}
              
            _ ->
              {:error, :invalid_response}
          end
        catch
          :exit, reason ->
            {:error, {:task_timeout, reason}}
        end
        
      {:error, reason} ->
        {:error, {:agent_not_found, reason}}
    end
  end
  
  defp aggregate_ensemble_results(results, state) do
    case state.ensemble_strategy do
      :weighted_voting ->
        aggregate_weighted_voting_results(results)
        
      :stacking ->
        aggregate_stacking_results(results)
        
      :boosting ->
        aggregate_boosting_results(results)
        
      _ ->
        aggregate_simple_voting_results(results)
    end
  end
  
  defp aggregate_weighted_voting_results(weighted_results) do
    # Calculate weighted average of predictions
    total_weight = Enum.sum(Enum.map(weighted_results, & &1.weight))
    
    # Aggregate predictions based on type
    case detect_prediction_type(weighted_results) do
      :classification ->
        aggregate_classification_votes(weighted_results, total_weight)
        
      :regression ->
        aggregate_regression_predictions(weighted_results, total_weight)
        
      :text_generation ->
        aggregate_text_generation_results(weighted_results)
        
      _ ->
        aggregate_generic_results(weighted_results, total_weight)
    end
  end
  
  defp aggregate_classification_votes(weighted_results, total_weight) do
    # Weighted voting for classification
    class_votes = Enum.reduce(weighted_results, %{}, fn %{result: {:ok, prediction}, weight: weight}, acc ->
      class = prediction.class
      current_weight = Map.get(acc, class, 0)
      Map.put(acc, class, current_weight + weight)
    end)
    
    # Select class with highest weighted vote
    winning_class = Enum.max_by(class_votes, fn {_class, weight} -> weight end) |> elem(0)
    confidence = Map.get(class_votes, winning_class) / total_weight
    
    %{
      type: :classification,
      prediction: winning_class,
      confidence: confidence,
      vote_distribution: class_votes,
      ensemble_metadata: %{
        total_weight: total_weight,
        participating_models: length(weighted_results)
      }
    }
  end
  
  defp aggregate_regression_predictions(weighted_results, total_weight) do
    # Weighted average for regression
    weighted_sum = Enum.reduce(weighted_results, 0, fn %{result: {:ok, prediction}, weight: weight}, acc ->
      acc + prediction.value * weight
    end)
    
    prediction = weighted_sum / total_weight
    
    # Calculate prediction uncertainty
    variance = calculate_ensemble_variance(weighted_results, prediction)
    
    %{
      type: :regression,
      prediction: prediction,
      uncertainty: :math.sqrt(variance),
      ensemble_metadata: %{
        total_weight: total_weight,
        participating_models: length(weighted_results),
        variance: variance
      }
    }
  end
  
  defp aggregate_text_generation_results(weighted_results) do
    # For text generation, use highest-weighted result or consensus
    valid_results = Enum.filter(weighted_results, fn %{result: result} ->
      match?({:ok, _}, result)
    end)
    
    case valid_results do
      [] ->
        %{type: :text_generation, error: :no_valid_results}
        
      results ->
        # Select highest-weighted result
        best_result = Enum.max_by(results, & &1.weight)
        
        %{
          type: :text_generation,
          prediction: best_result.result |> elem(1),
          confidence: best_result.weight,
          alternative_results: Enum.take(results, 3),  # Keep top 3 alternatives
          ensemble_metadata: %{
            total_models: length(weighted_results),
            valid_models: length(valid_results)
          }
        }
    end
  end
  
  defp update_ensemble_performance(state, results, final_result) do
    # Update performance tracking for future weight adjustments
    performance_updates = Enum.map(results, fn result_data ->
      case result_data do
        %{agent_id: agent_id, result: {:ok, prediction}} ->
          performance_score = calculate_individual_performance(prediction, final_result)
          {agent_id, performance_score}
          
        %{agent_id: agent_id, result: {:error, _}} ->
          {agent_id, 0.0}  # Penalty for errors
      end
    end)
    
    # Update performance history
    new_performance_history = Enum.reduce(performance_updates, state.performance_history, fn {agent_id, score}, acc ->
      current_history = Map.get(acc, agent_id, [])
      updated_history = [score | Enum.take(current_history, 99)]  # Keep last 100 scores
      Map.put(acc, agent_id, updated_history)
    end)
    
    # Update model weights based on recent performance
    new_weights = update_model_weights(state.model_weights, new_performance_history)
    
    %{state |
      performance_history: new_performance_history,
      model_weights: new_weights
    }
  end
  
  defp update_model_weights(current_weights, performance_history) do
    Enum.map(current_weights, fn {agent_id, current_weight} ->
      case Map.get(performance_history, agent_id) do
        nil ->
          {agent_id, current_weight}
          
        scores ->
          # Calculate moving average performance
          avg_performance = Enum.sum(scores) / length(scores)
          
          # Adjust weight based on performance (exponential moving average)
          alpha = 0.1  # Learning rate
          new_weight = (1 - alpha) * current_weight + alpha * avg_performance
          
          {agent_id, new_weight}
      end
    end)
    |> Map.new()
  end
  
  defp initialize_model_weights(agent_pool) do
    # Initialize equal weights for all agents
    agent_pool
    |> Enum.map(fn agent_id -> {agent_id, 1.0} end)
    |> Map.new()
  end
  
  defp get_agent_model_type(agent_id) do
    case Foundation.MABEAM.Registry.lookup_agent(agent_id) do
      {:ok, agent_info} ->
        Map.get(agent_info, :model_type, :unknown)
        
      {:error, _} ->
        :unknown
    end
  end
  
  defp get_agent_cost(agent_id) do
    case Foundation.MABEAM.Economics.get_agent_costs(agent_id) do
      {:ok, costs} -> costs.per_request || 0.01
      {:error, _} -> 0.01
    end
  end
  
  defp get_agent_expected_performance(agent_id) do
    case Foundation.MABEAM.Economics.get_agent_reputation(agent_id) do
      {:ok, reputation} -> reputation.performance || 0.7
      {:error, _} -> 0.7
    end
  end
  
  defp notify_completion(result, state) do
    send(Foundation.MABEAM.Coordination, {:coordination_complete, state.coordination_id, result})
  end
end

defmodule Foundation.MABEAM.Protocols.MarketCoordination do
  @moduledoc """
  Market-based coordination using economic mechanisms
  
  Features:
  - Real-time resource auctions
  - Dynamic pricing based on demand
  - Reputation-based bidding weights
  - Anti-gaming measures
  - Multi-round negotiations
  """
  
  use GenServer
  require Logger
  
  defstruct [
    :coordination_id,
    :resource_spec,
    :market_participants,
    :auction_type,
    :current_round,
    :max_rounds,
    :bid_history,
    :market_prices,
    :reputation_weights,
    :anti_gaming,
    :status,
    :started_at
  ]
  
  def start_coordination(coordination_id, coordination_spec, opts) do
    GenServer.start_link(__MODULE__, {coordination_id, coordination_spec, opts})
  end
  
  def init({coordination_id, coordination_spec, opts}) do
    state = %__MODULE__{
      coordination_id: coordination_id,
      resource_spec: coordination_spec.resource_spec,
      market_participants: coordination_spec.participants,
      auction_type: opts[:auction_type] || :english,
      current_round: 1,
      max_rounds: opts[:max_rounds] || 5,
      bid_history: [],
      market_prices: initialize_market_prices(coordination_spec.resource_spec),
      reputation_weights: load_reputation_weights(coordination_spec.participants),
      anti_gaming: initialize_anti_gaming_measures(),
      status: :initializing,
      started_at: DateTime.utc_now()
    }
    
    # Start market coordination
    send(self(), :start_auction_round)
    
    {:ok, state}
  end
  
  def handle_info(:start_auction_round, state) do
    Logger.info("Starting auction round #{state.current_round} for #{state.coordination_id}")
    
    # Broadcast auction round to participants
    auction_announcement = create_auction_announcement(state)
    broadcast_auction_announcement(auction_announcement, state)
    
    # Set round timeout
    round_timeout = calculate_round_timeout(state.auction_type, state.current_round)
    Process.send_after(self(), :round_timeout, round_timeout)
    
    {:noreply, %{state | status: :bidding}}
  end
  
  def handle_info(:round_timeout, state) do
    # Process bids for current round
    round_results = process_round_bids(state)
    
    case should_continue_auction?(round_results, state) do
      true ->
        # Continue to next round
        next_round_state = prepare_next_round(state, round_results)
        send(self(), :start_auction_round)
        {:noreply, next_round_state}
        
      false ->
        # Auction complete
        final_results = finalize_auction_results(state, round_results)
        notify_completion({:ok, final_results}, state)
        {:stop, :normal, state}
    end
  end
  
  # Handle incoming bids
  def handle_cast({:submit_bid, bid}, state) when state.status == :bidding do
    case validate_bid(bid, state) do
      {:ok, validated_bid} ->
        # Apply reputation weighting
        weighted_bid = apply_reputation_weighting(validated_bid, state)
        
        # Check anti-gaming measures
        case check_anti_gaming(weighted_bid, state) do
          :ok ->
            updated_state = record_bid(weighted_bid, state)
            {:noreply, updated_state}
            
          {:error, reason} ->
            Logger.warning("Bid rejected due to anti-gaming: #{inspect(reason)}")
            {:noreply, state}
        end
        
      {:error, reason} ->
        Logger.warning("Invalid bid: #{inspect(reason)}")
        {:noreply, state}
    end
  end
  
  def handle_cast({:submit_bid, _bid}, state) do
    # Bidding not currently active
    {:noreply, state}
  end
  
  # Private implementation
  defp create_auction_announcement(state) do
    %{
      auction_id: state.coordination_id,
      round: state.current_round,
      auction_type: state.auction_type,
      resource_spec: state.resource_spec,
      current_market_price: get_current_market_price(state),
      bid_requirements: get_bid_requirements(state),
      round_timeout: calculate_round_timeout(state.auction_type, state.current_round),
      reputation_bonuses: calculate_reputation_bonuses(state)
    }
  end
  
  defp broadcast_auction_announcement(announcement, state) do
    Enum.each(state.market_participants, fn participant ->
      case Foundation.MABEAM.Registry.lookup_agent(participant) do
        {:ok, agent_info} ->
          send(agent_info.pid, {:auction_announcement, announcement})
          
        {:error, _} ->
          Logger.warning("Could not notify auction participant: #{participant}")
      end
    end)
  end
  
  defp validate_bid(bid, state) do
    cond do
      not is_map(bid) ->
        {:error, :invalid_format}
        
      not Map.has_key?(bid, :amount) ->
        {:error, :missing_amount}
        
      not Map.has_key?(bid, :agent_id) ->
        {:error, :missing_agent_id}
        
      bid.amount <= 0 ->
        {:error, :invalid_amount}
        
      bid.agent_id not in state.market_participants ->
        {:error, :unauthorized_participant}
        
      state.auction_type == :english and not valid_english_bid?(bid, state) ->
        {:error, :bid_too_low}
        
      true ->
        {:ok, bid}
    end
  end
  
  defp valid_english_bid?(bid, state) do
    current_highest = get_current_highest_bid(state)
    minimum_increment = get_minimum_bid_increment(state)
    
    bid.amount >= current_highest + minimum_increment
  end
  
  defp apply_reputation_weighting(bid, state) do
    reputation_weight = Map.get(state.reputation_weights, bid.agent_id, 1.0)
    
    # Apply reputation bonus/penalty to effective bid value
    effective_amount = bid.amount * reputation_weight
    
    %{bid |
      effective_amount: effective_amount,
      reputation_weight: reputation_weight,
      original_amount: bid.amount
    }
  end
  
  defp check_anti_gaming(bid, state) do
    agent_id = bid.agent_id
    
    # Check bid frequency limits
    recent_bids = get_recent_bids(agent_id, state, 60_000)  # Last minute
    
    cond do
      length(recent_bids) > 10 ->
        {:error, :excessive_bid_frequency}
        
      detect_shill_bidding?(bid, state) ->
        {:error, :shill_bidding_detected}
        
      detect_bid_manipulation?(bid, state) ->
        {:error, :bid_manipulation_detected}
        
      true ->
        :ok
    end
  end
  
  defp record_bid(bid, state) do
    bid_record = %{
      bid: bid,
      round: state.current_round,
      timestamp: DateTime.utc_now()
    }
    
    %{state | bid_history: [bid_record | state.bid_history]}
  end
  
  defp process_round_bids(state) do
    current_round_bids = Enum.filter(state.bid_history, fn record ->
      record.round == state.current_round
    end)
    
    case state.auction_type do
      :english ->
        process_english_auction_round(current_round_bids, state)
        
      :dutch ->
        process_dutch_auction_round(current_round_bids, state)
        
      :sealed_bid ->
        process_sealed_bid_round(current_round_bids, state)
        
      :vickrey ->
        process_vickrey_auction_round(current_round_bids, state)
        
      _ ->
        process_generic_auction_round(current_round_bids, state)
    end
  end
  
  defp process_english_auction_round(bids, state) do
    case bids do
      [] ->
        %{result: :no_bids, highest_bid: nil}
        
      bid_records ->
        # Find highest effective bid
        highest_bid_record = Enum.max_by(bid_records, fn record ->
          record.bid.effective_amount
        end)
        
        %{
          result: :bid_received,
          highest_bid: highest_bid_record.bid,
          total_bids: length(bid_records),
          round: state.current_round
        }
    end
  end
  
  defp process_vickrey_auction_round(bids, state) do
    case length(bids) do
      0 ->
        %{result: :no_bids, winning_bid: nil}
        
      1 ->
        single_bid = List.first(bids).bid
        %{
          result: :single_bid,
          winning_bid: single_bid,
          winning_price: state.resource_spec.reserve_price || single_bid.effective_amount
        }
        
      _ ->
        # Sort bids by effective amount
        sorted_bids = Enum.sort_by(bids, fn record ->
          record.bid.effective_amount
        end, :desc)
        
        highest_bid = List.first(sorted_bids).bid
        second_highest_bid = Enum.at(sorted_bids, 1).bid
        
        %{
          result: :vickrey_winner,
          winning_bid: highest_bid,
          winning_price: second_highest_bid.effective_amount,
          all_bids: sorted_bids
        }
    end
  end
  
  defp should_continue_auction?(round_results, state) do
    cond do
      state.current_round >= state.max_rounds ->
        false
        
      round_results.result == :no_bids ->
        false
        
      state.auction_type == :vickrey and round_results.result == :vickrey_winner ->
        false
        
      state.auction_type == :english and round_results.result == :bid_received ->
        # Continue if there's competitive bidding
        true
        
      true ->
        false
    end
  end
  
  defp prepare_next_round(state, round_results) do
    # Update market prices based on bidding activity
    new_market_prices = update_market_prices(state.market_prices, round_results)
    
    # Increment round
    %{state |
      current_round: state.current_round + 1,
      market_prices: new_market_prices,
      status: :preparing_next_round
    }
  end
  
  defp finalize_auction_results(state, final_round_results) do
    %{
      coordination_id: state.coordination_id,
      auction_type: state.auction_type,
      winner: get_auction_winner(final_round_results),
      final_price: get_final_price(final_round_results),
      total_rounds: state.current_round,
      participation_stats: calculate_participation_stats(state),
      market_impact: calculate_market_impact(state),
      duration: DateTime.diff(DateTime.utc_now(), state.started_at, :microsecond)
    }
  end
  
  defp initialize_market_prices(resource_spec) do
    base_price = resource_spec.base_price || 1.0
    
    %{
      current_price: base_price,
      historical_prices: [base_price],
      volatility: 0.0,
      trend: :stable
    }
  end
  
  defp load_reputation_weights(participants) do
    Enum.map(participants, fn agent_id ->
      case Foundation.MABEAM.Economics.get_agent_reputation(agent_id) do
        {:ok, reputation} ->
          # Convert reputation to bidding weight (0.5 to 1.5 range)
          weight = 0.5 + reputation.overall_score
          {agent_id, weight}
          
        {:error, _} ->
          {agent_id, 1.0}  # Default weight
      end
    end)
    |> Map.new()
  end
  
  defp initialize_anti_gaming_measures do
    %{
      bid_frequency_tracking: %{},
      suspicious_patterns: [],
      collaboration_detection: %{}
    }
  end
  
  defp calculate_round_timeout(auction_type, round) do
    base_timeout = case auction_type do
      :english -> 30_000      # 30 seconds per round
      :dutch -> 60_000        # 1 minute for descending price
      :sealed_bid -> 120_000  # 2 minutes for sealed bids
      :vickrey -> 120_000     # 2 minutes for sealed bids
      _ -> 60_000
    end
    
    # Shorter timeouts for later rounds
    round_multiplier = 1.0 - (round - 1) * 0.1
    max(round(base_timeout * round_multiplier), 10_000)  # Minimum 10 seconds
  end
  
  defp get_current_market_price(state) do
    state.market_prices.current_price
  end
  
  defp get_current_highest_bid(state) do
    case state.bid_history do
      [] ->
        state.resource_spec.starting_price || state.market_prices.current_price
        
      bid_records ->
        bid_records
        |> Enum.map(fn record -> record.bid.effective_amount end)
        |> Enum.max()
    end
  end
  
  defp notify_completion(result, state) do
    send(Foundation.MABEAM.Coordination, {:coordination_complete, state.coordination_id, result})
  end
end

defmodule Foundation.MABEAM.Protocols.Performance do
  @moduledoc """
  Performance monitoring and optimization for coordination protocols
  """
  
  # Protocol performance metrics
  def measure_protocol_performance(protocol, coordination_spec, opts) do
    start_time = System.monotonic_time(:microsecond)
    
    case protocol.start_coordination(generate_id(), coordination_spec, opts) do
      {:ok, result} ->
        end_time = System.monotonic_time(:microsecond)
        duration = end_time - start_time
        
        # Record performance metrics
        :telemetry.execute([:foundation, :mabeam, :protocol, :performance], %{
          duration_us: duration,
          participants: length(coordination_spec.participants)
        }, %{
          protocol: protocol_name(protocol),
          result: :success
        })
        
        {:ok, result, %{duration_us: duration}}
        
      {:error, reason} ->
        end_time = System.monotonic_time(:microsecond)
        duration = end_time - start_time
        
        :telemetry.execute([:foundation, :mabeam, :protocol, :performance], %{
          duration_us: duration,
          participants: length(coordination_spec.participants)
        }, %{
          protocol: protocol_name(protocol),
          result: :error,
          error: reason
        })
        
        {:error, reason, %{duration_us: duration}}
    end
  end
  
  # Adaptive protocol selection based on performance
  def select_optimal_protocol(coordination_spec, performance_history) do
    candidate_protocols = Foundation.MABEAM.Protocols.Selector.get_candidate_protocols(coordination_spec)
    
    # Analyze historical performance for each protocol
    protocol_scores = Enum.map(candidate_protocols, fn protocol ->
      score = calculate_protocol_score(protocol, coordination_spec, performance_history)
      {protocol, score}
    end)
    
    # Select highest-scoring protocol
    case Enum.max_by(protocol_scores, fn {_protocol, score} -> score end) do
      {best_protocol, _score} -> {:ok, best_protocol}
      nil -> {:error, :no_suitable_protocol}
    end
  end
  
  defp calculate_protocol_score(protocol, coordination_spec, performance_history) do
    # Base score from protocol capabilities
    base_score = calculate_base_protocol_score(protocol, coordination_spec)
    
    # Performance adjustment from history
    performance_adjustment = calculate_performance_adjustment(protocol, performance_history)
    
    # Resource cost consideration
    cost_adjustment = calculate_cost_adjustment(protocol, coordination_spec)
    
    base_score + performance_adjustment + cost_adjustment
  end
end

defmodule Foundation.MABEAM.Protocols.Telemetry do
  @moduledoc """
  Comprehensive telemetry for coordination protocols
  """
  
  def setup_protocol_telemetry do
    :telemetry.attach_many(
      "mabeam-protocols-telemetry",
      [
        [:foundation, :mabeam, :protocol, :started],
        [:foundation, :mabeam, :protocol, :completed],
        [:foundation, :mabeam, :protocol, :failed],
        [:foundation, :mabeam, :protocol, :performance],
        [:foundation, :mabeam, :consensus, :achieved],
        [:foundation, :mabeam, :auction, :completed]
      ],
      &handle_protocol_telemetry/4,
      nil
    )
  end
  
  def handle_protocol_telemetry(event, measurements, metadata, _config) do
    case event do
      [:foundation, :mabeam, :protocol, :completed] ->
        record_protocol_completion(measurements, metadata)
        
      [:foundation, :mabeam, :consensus, :achieved] ->
        record_consensus_achievement(measurements, metadata)
        
      [:foundation, :mabeam, :auction, :completed] ->
        record_auction_completion(measurements, metadata)
        
      _ ->
        record_generic_protocol_event(event, measurements, metadata)
    end
  end
  
  defp record_protocol_completion(measurements, metadata) do
    :prometheus_histogram.observe(
      :mabeam_protocol_duration,
      [protocol: metadata.protocol],
      measurements.duration_us / 1000
    )
    
    :prometheus_counter.inc(
      :mabeam_protocol_completions_total,
      [protocol: metadata.protocol, result: metadata.result]
    )
  end
end