defmodule Nexus.Coordination.Strategy do
  @moduledoc """
  Five layers of coordination complexity, each building on the previous:
  
  1. Foundation: Proven primitives (vector clocks, gossip, consensus)
  2. Performance: Optimized implementations (ETS routing, connection pooling)
  3. Intelligence: ML-enhanced decisions (predictive routing, adaptive load balancing)
  4. Adaptive: Dynamic behavior adjustment (environmental adaptation)
  5. Emergency: Fallback mechanisms (circuit breakers, graceful degradation)
  
  Each layer is independently testable and can operate without higher layers.
  """
  
  @coordination_layers [:foundation, :performance, :intelligence, :adaptive, :emergency]
  
  def coordinate(agents, goal, max_layer \\ :adaptive) do
    available_layers = available_coordination_layers()
    effective_layer = min_layer(max_layer, available_layers)
    
    case effective_layer do
      :foundation -> foundation_coordinate(agents, goal)
      :performance -> performance_coordinate(agents, goal)
      :intelligence -> intelligence_coordinate(agents, goal)
      :adaptive -> adaptive_coordinate(agents, goal)
      :emergency -> emergency_coordinate(agents, goal)
    end
  rescue
    error ->
      Logger.warn("Coordination failed at #{effective_layer}, falling back")
      fallback_coordinate(agents, goal, effective_layer)
  end
  
  defp fallback_coordinate(agents, goal, failed_layer) do
    lower_layer = get_lower_layer(failed_layer)
    
    if lower_layer do
      coordinate(agents, goal, lower_layer)
    else
      # Ultimate fallback: simple round-robin
      simple_round_robin_coordinate(agents, goal)
    end
  end
end

defmodule Nexus.Coordination.VectorClock do
  @moduledoc """
  Proven vector clock implementation for causal consistency.
  
  Characteristics:
  - Well-understood semantics
  - Predictable performance: O(N) for N nodes
  - Battle-tested in production systems
  - Clear debugging and reasoning model
  """
  
  defstruct clocks: %{}, node_id: nil
  
  def new(node_id) do
    %__MODULE__{
      clocks: %{node_id => 0},
      node_id: node_id
    }
  end
  
  def tick(%__MODULE__{} = vc) do
    current_time = Map.get(vc.clocks, vc.node_id, 0)
    new_clocks = Map.put(vc.clocks, vc.node_id, current_time + 1)
    %{vc | clocks: new_clocks}
  end
  
  def merge(%__MODULE__{} = vc1, %__MODULE__{} = vc2) do
    all_nodes = MapSet.union(
      MapSet.new(Map.keys(vc1.clocks)),
      MapSet.new(Map.keys(vc2.clocks))
    )
    
    merged_clocks = Enum.reduce(all_nodes, %{}, fn node, acc ->
      time1 = Map.get(vc1.clocks, node, 0)
      time2 = Map.get(vc2.clocks, node, 0)
      Map.put(acc, node, max(time1, time2))
    end)
    
    %{vc1 | clocks: merged_clocks}
  end
  
  def compare(%__MODULE__{} = vc1, %__MODULE__{} = vc2) do
    all_nodes = MapSet.union(
      MapSet.new(Map.keys(vc1.clocks)),
      MapSet.new(Map.keys(vc2.clocks))
    )
    
    comparisons = Enum.map(all_nodes, fn node ->
      time1 = Map.get(vc1.clocks, node, 0)
      time2 = Map.get(vc2.clocks, node, 0)
      
      cond do
        time1 < time2 -> :less
        time1 > time2 -> :greater
        true -> :equal
      end
    end)
    
    cond do
      Enum.all?(comparisons, &(&1 == :less or &1 == :equal)) and 
      Enum.any?(comparisons, &(&1 == :less)) -> :before
      
      Enum.all?(comparisons, &(&1 == :greater or &1 == :equal)) and 
      Enum.any?(comparisons, &(&1 == :greater)) -> :after
      
      Enum.all?(comparisons, &(&1 == :equal)) -> :equal
      
      true -> :concurrent
    end
  end
end

defmodule Nexus.Coordination.CausalConsistency do
  @moduledoc """
  Causal consistency using vector clocks for agent coordination.
  """
  
  def coordinate_with_causality(agents, operations) do
    # Initialize vector clock for coordination session
    coordinator_clock = Nexus.Coordination.VectorClock.new(node())
    
    # Execute operations with causal ordering
    {results, _final_clock} = Enum.reduce(operations, {[], coordinator_clock}, 
      fn operation, {acc_results, clock} ->
        # Tick clock for this operation
        new_clock = Nexus.Coordination.VectorClock.tick(clock)
        
        # Execute operation with causal timestamp
        result = execute_causal_operation(operation, new_clock, agents)
        
        {[result | acc_results], new_clock}
      end)
    
    Enum.reverse(results)
  end
  
  defp execute_causal_operation(operation, vector_clock, agents) do
    # Add vector clock to operation metadata
    causal_operation = %{operation | 
      metadata: Map.put(operation.metadata || %{}, :vector_clock, vector_clock)
    }
    
    # Send to target agents with causal information
    case operation.type do
      :broadcast ->
        broadcast_causal_operation(agents, causal_operation)
      
      :targeted ->
        send_causal_operation(operation.target_agents, causal_operation)
      
      :coordinated ->
        coordinate_causal_operation(operation.coordinator, agents, causal_operation)
    end
  end
  
  defp broadcast_causal_operation(agents, operation) do
    # Broadcast to all agents with causal ordering guarantee
    Enum.map(agents, fn agent ->
      Nexus.Agent.send_causal_message(agent.id, operation)
    end)
  end
end

defmodule Nexus.Coordination.Gossip do
  @moduledoc """
  Proven gossip protocol for eventual consistency.
  
  Characteristics:
  - O(log N) convergence time
  - Fault-tolerant by design
  - Well-understood failure modes
  - Configurable convergence vs. bandwidth tradeoffs
  """
  
  use GenServer
  
  defstruct [
    :node_id,
    :cluster_nodes,
    :state,
    :version,
    :gossip_interval,
    :convergence_detector
  ]
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(opts) do
    node_id = Keyword.get(opts, :node_id, node())
    gossip_interval = Keyword.get(opts, :gossip_interval, 1000)
    
    state = %__MODULE__{
      node_id: node_id,
      cluster_nodes: [node_id],
      state: %{},
      version: 0,
      gossip_interval: gossip_interval,
      convergence_detector: Nexus.Convergence.Detector.new()
    }
    
    # Schedule first gossip round
    schedule_gossip_round(gossip_interval)
    
    {:ok, state}
  end
  
  def gossip_state(state_update) do
    GenServer.cast(__MODULE__, {:gossip_state, state_update})
  end
  
  def get_converged_state() do
    GenServer.call(__MODULE__, :get_converged_state)
  end
  
  def handle_cast({:gossip_state, state_update}, state) do
    # Update local state
    new_local_state = merge_state_update(state.state, state_update)
    new_version = state.version + 1
    
    # Prepare gossip message
    gossip_message = %{
      source_node: state.node_id,
      state: new_local_state,
      version: new_version,
      timestamp: :erlang.system_time(:microsecond)
    }
    
    # Trigger immediate gossip for important updates
    if important_update?(state_update) do
      initiate_gossip_round(gossip_message, state.cluster_nodes)
    end
    
    new_state = %{state | 
      state: new_local_state,
      version: new_version
    }
    
    {:noreply, new_state}
  end
  
  def handle_cast({:gossip_message, message}, state) do
    # Receive gossip message from another node
    case should_accept_gossip?(message, state) do
      true ->
        # Merge received state
        merged_state = merge_gossip_state(state.state, message.state)
        
        # Update convergence detector
        new_detector = Nexus.Convergence.Detector.update(
          state.convergence_detector,
          message.source_node,
          message.version
        )
        
        new_state = %{state |
          state: merged_state,
          convergence_detector: new_detector
        }
        
        {:noreply, new_state}
      
      false ->
        # Ignore outdated or invalid gossip
        {:noreply, state}
    end
  end
  
  def handle_call(:get_converged_state, _from, state) do
    case Nexus.Convergence.Detector.is_converged?(state.convergence_detector) do
      true -> {:reply, {:ok, state.state}, state}
      false -> {:reply, {:not_converged, state.state}, state}
    end
  end
  
  def handle_info(:gossip_round, state) do
    # Execute gossip round
    execute_gossip_round(state)
    
    # Schedule next round
    schedule_gossip_round(state.gossip_interval)
    
    {:noreply, state}
  end
  
  defp execute_gossip_round(state) do
    # Select random subset of nodes for gossip
    gossip_fanout = calculate_optimal_fanout(length(state.cluster_nodes))
    gossip_targets = select_gossip_targets(state.cluster_nodes, gossip_fanout)
    
    # Prepare gossip message
    gossip_message = %{
      source_node: state.node_id,
      state: state.state,
      version: state.version,
      timestamp: :erlang.system_time(:microsecond)
    }
    
    # Send gossip to selected nodes
    Enum.each(gossip_targets, fn target_node ->
      send_gossip_message(target_node, gossip_message)
    end)
  end
  
  defp calculate_optimal_fanout(cluster_size) do
    # Optimal fanout for O(log N) convergence
    max(1, :math.ceil(:math.log2(cluster_size)))
  end
  
  defp select_gossip_targets(nodes, fanout) do
    # Randomly select targets (excluding self)
    other_nodes = nodes -- [node()]
    
    if length(other_nodes) <= fanout do
      other_nodes
    else
      Enum.take_random(other_nodes, fanout)
    end
  end
  
  defp send_gossip_message(target_node, message) do
    # Send gossip message with fault tolerance
    case :rpc.call(target_node, GenServer, :cast, [__MODULE__, {:gossip_message, message}], 1000) do
      {:badrpc, _reason} ->
        # Node unreachable, will try again next round
        :ok
      _ ->
        :ok
    end
  end
end

defmodule Nexus.Coordination.Consensus do
  @moduledoc """
  Raft consensus implementation for critical coordination decisions.
  
  Use cases:
  - Leader election for coordination
  - Critical configuration changes
  - Resource allocation decisions
  - Conflict resolution
  """
  
  use GenServer
  
  defstruct [
    :node_id,
    :state,           # :follower | :candidate | :leader
    :current_term,
    :voted_for,
    :log,
    :commit_index,
    :last_applied,
    :cluster_members,
    :election_timeout,
    :heartbeat_interval
  ]
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(opts) do
    node_id = Keyword.get(opts, :node_id, node())
    cluster_members = Keyword.get(opts, :cluster_members, [node_id])
    
    state = %__MODULE__{
      node_id: node_id,
      state: :follower,
      current_term: 0,
      voted_for: nil,
      log: [],
      commit_index: 0,
      last_applied: 0,
      cluster_members: cluster_members,
      election_timeout: random_election_timeout(),
      heartbeat_interval: 50  # 50ms heartbeat
    }
    
    # Start election timeout
    schedule_election_timeout(state.election_timeout)
    
    {:ok, state}
  end
  
  @doc """
  Propose a consensus decision to the cluster.
  """
  def propose_decision(decision) do
    GenServer.call(__MODULE__, {:propose_decision, decision}, 10_000)
  end
  
  @doc """
  Get current consensus state.
  """
  def get_consensus_state() do
    GenServer.call(__MODULE__, :get_consensus_state)
  end
  
  def handle_call({:propose_decision, decision}, from, %{state: :leader} = state) do
    # Leader handles proposal
    log_entry = %{
      term: state.current_term,
      decision: decision,
      client: from,
      index: length(state.log) + 1
    }
    
    new_log = state.log ++ [log_entry]
    new_state = %{state | log: new_log}
    
    # Replicate to followers
    replicate_to_followers(log_entry, new_state)
    
    # Don't reply immediately - will reply when committed
    {:noreply, new_state}
  end
  
  def handle_call({:propose_decision, _decision}, _from, state) do
    # Not leader - redirect to leader
    case find_current_leader(state.cluster_members) do
      {:ok, leader} -> {:reply, {:redirect, leader}, state}
      :no_leader -> {:reply, {:error, :no_leader}, state}
    end
  end
  
  def handle_call(:get_consensus_state, _from, state) do
    consensus_state = %{
      node_state: state.state,
      current_term: state.current_term,
      commit_index: state.commit_index,
      cluster_members: state.cluster_members,
      leader: (if state.state == :leader, do: state.node_id, else: find_current_leader(state.cluster_members))
    }
    
    {:reply, consensus_state, state}
  end
  
  # Follower receives append entries (heartbeat or log replication)
  def handle_cast({:append_entries, leader_term, leader_id, prev_log_index, prev_log_term, entries, leader_commit}, state) do
    cond do
      leader_term < state.current_term ->
        # Reject - leader is outdated
        send_append_entries_response(leader_id, false, state.current_term)
        {:noreply, state}
      
      leader_term > state.current_term ->
        # Update term and become follower
        new_state = %{state | 
          current_term: leader_term,
          voted_for: nil,
          state: :follower
        }
        
        process_append_entries(leader_id, prev_log_index, prev_log_term, entries, leader_commit, new_state)
      
      true ->
        # Same term - process normally
        process_append_entries(leader_id, prev_log_index, prev_log_term, entries, leader_commit, state)
    end
  end
  
  def handle_info(:election_timeout, %{state: :follower} = state) do
    # Start election
    Logger.info("Starting leader election for term #{state.current_term + 1}")
    start_election(state)
  end
  
  def handle_info(:election_timeout, %{state: :candidate} = state) do
    # Election timeout as candidate - start new election
    Logger.info("Election timeout, starting new election")
    start_election(state)
  end
  
  def handle_info(:election_timeout, %{state: :leader} = state) do
    # Leaders don't timeout
    {:noreply, state}
  end
  
  def handle_info(:heartbeat, %{state: :leader} = state) do
    # Send heartbeat to all followers
    send_heartbeat_to_followers(state)
    
    # Schedule next heartbeat
    Process.send_after(self(), :heartbeat, state.heartbeat_interval)
    
    {:noreply, state}
  end
  
  defp start_election(state) do
    # Become candidate
    new_term = state.current_term + 1
    candidate_state = %{state |
      state: :candidate,
      current_term: new_term,
      voted_for: state.node_id
    }
    
    # Vote for self
    votes = 1
    
    # Request votes from other nodes
    vote_responses = request_votes_from_cluster(candidate_state)
    
    # Count votes
    total_votes = votes + count_positive_votes(vote_responses)
    majority = div(length(state.cluster_members), 2) + 1
    
    if total_votes >= majority do
      # Won election - become leader
      become_leader(candidate_state)
    else
      # Lost election - become follower
      become_follower(candidate_state)
    end
  end
  
  defp become_leader(state) do
    Logger.info("Became leader for term #{state.current_term}")
    
    leader_state = %{state | state: :leader}
    
    # Send initial heartbeat
    send_heartbeat_to_followers(leader_state)
    Process.send_after(self(), :heartbeat, state.heartbeat_interval)
    
    {:noreply, leader_state}
  end
  
  defp become_follower(state) do
    follower_state = %{state | state: :follower}
    schedule_election_timeout(random_election_timeout())
    {:noreply, follower_state}
  end
  
  defp random_election_timeout() do
    # Random timeout between 150-300ms
    150 + :rand.uniform(150)
  end
end

defmodule Nexus.Coordination.HighPerformance do
  @moduledoc """
  Performance-optimized coordination patterns.
  
  Optimizations:
  - ETS-based routing tables for O(1) lookups
  - Connection pooling for remote operations
  - Binary protocols for serialization
  - NUMA-aware process placement
  """
  
  def setup_high_performance_coordination() do
    # Create high-performance routing infrastructure
    setup_routing_tables()
    setup_connection_pools()
    setup_binary_protocols()
    setup_numa_placement()
  end
  
  defp setup_routing_tables() do
    # Main routing table
    :ets.new(:nexus_routes, [
      :named_table,
      :public,
      :set,
      {:read_concurrency, true},
      {:write_concurrency, true}
    ])
    
    # Agent coordination groups
    :ets.new(:nexus_coordination_groups, [
      :named_table,
      :public,
      :bag,
      {:read_concurrency, true},
      {:write_concurrency, true}
    ])
    
    # Performance metrics
    :ets.new(:nexus_coordination_metrics, [
      :named_table,
      :public,
      :set,
      {:read_concurrency, true},
      {:write_concurrency, true}
    ])
  end
  
  def coordinate_high_performance(agents, coordination_type, goal) do
    start_time = :erlang.monotonic_time(:microsecond)
    
    result = case coordination_type do
      :broadcast -> high_performance_broadcast(agents, goal)
      :gathering -> high_performance_gathering(agents, goal)
      :consensus -> high_performance_consensus(agents, goal)
      :load_balance -> high_performance_load_balance(agents, goal)
    end
    
    end_time = :erlang.monotonic_time(:microsecond)
    record_coordination_metrics(coordination_type, end_time - start_time, length(agents))
    
    result
  end
  
  defp high_performance_broadcast(agents, goal) do
    # Use ETS for fast agent lookup
    agent_pids = Enum.map(agents, fn agent ->
      case :ets.lookup(:nexus_routes, agent.id) do
        [{_, :local, pid}] -> {:local, pid}
        [{_, :remote, node, pid}] -> {:remote, node, pid}
        [] -> {:error, :not_found}
      end
    end)
    
    # Group by node for efficient remote calls
    {local_pids, remote_groups} = group_agents_by_location(agent_pids)
    
    # Broadcast to local agents immediately
    local_results = Enum.map(local_pids, fn pid ->
      GenServer.cast(pid, {:coordination_message, goal})
    end)
    
    # Batch remote calls by node
    remote_results = Enum.map(remote_groups, fn {node, pids} ->
      batch_remote_cast(node, pids, {:coordination_message, goal})
    end)
    
    local_results ++ remote_results
  end
  
  defp high_performance_gathering(agents, goal) do
    # Parallel gathering with timeout
    timeout = goal.timeout || 5000
    
    # Start gathering tasks
    gathering_tasks = Enum.map(agents, fn agent ->
      Task.async(fn ->
        case fast_agent_call(agent.id, {:gather_data, goal}) do
          {:ok, data} -> {agent.id, data}
          error -> {agent.id, error}
        end
      end)
    end)
    
    # Collect results with timeout
    results = Task.yield_many(gathering_tasks, timeout)
    
    # Process gathered data
    successful_results = Enum.flat_map(results, fn
      {_task, {:ok, result}} -> [result]
      {_task, nil} -> []  # Timeout
      {_task, {:exit, _reason}} -> []  # Error
    end)
    
    aggregate_gathered_data(successful_results, goal)
  end
  
  defp fast_agent_call(agent_id, message) do
    case :ets.lookup(:nexus_routes, agent_id) do
      [{_, :local, pid}] ->
        GenServer.call(pid, message, 1000)
      
      [{_, :remote, node, pid}] ->
        # Use connection pool for remote call
        pooled_remote_call(node, pid, message, 1000)
      
      [] ->
        {:error, :agent_not_found}
    end
  end
  
  defp pooled_remote_call(node, pid, message, timeout) do
    pool_name = :"nexus_pool_#{node}"
    
    :poolboy.transaction(pool_name, fn _worker ->
      :rpc.call(node, GenServer, :call, [pid, message, timeout])
    end, timeout)
  end
  
  defp record_coordination_metrics(type, duration_us, agent_count) do
    metrics = %{
      coordination_type: type,
      duration_microseconds: duration_us,
      agent_count: agent_count,
      throughput: agent_count / (duration_us / 1_000_000),  # agents/second
      timestamp: :erlang.system_time(:microsecond)
    }
    
    :ets.insert(:nexus_coordination_metrics, {type, metrics})
    
    # Emit telemetry
    :telemetry.execute(
      [:nexus, :coordination, :performance],
      %{duration: duration_us, throughput: metrics.throughput},
      %{type: type, agent_count: agent_count}
    )
  end
end

defmodule Nexus.Coordination.LoadBalancing do
  @moduledoc """
  High-performance load balancing with multiple strategies.
  
  Strategies:
  - Round-robin: O(1) with atomic counters
  - Least-connections: O(N) with cached connection counts
  - Weighted-response-time: O(N) with exponential moving averages
  - Resource-aware: O(N) with real-time resource monitoring
  """
  
  @strategies [:round_robin, :least_connections, :weighted_response_time, :resource_aware]
  
  def setup_load_balancing() do
    # Initialize strategy-specific data structures
    setup_round_robin()
    setup_connection_tracking()
    setup_response_time_tracking()
    setup_resource_monitoring()
  end
  
  defp setup_round_robin() do
    # Use atomic counters for round-robin
    :counters.new(1, [:atomics])
    |> :persistent_term.put(:nexus_round_robin_counter)
  end
  
  defp setup_connection_tracking() do
    # Track active connections per agent
    :ets.new(:nexus_agent_connections, [
      :named_table,
      :public,
      :set,
      {:read_concurrency, true},
      {:write_concurrency, true}
    ])
  end
  
  def balance_load(agents, requests, strategy \\ :round_robin) do
    case strategy do
      :round_robin -> 
        round_robin_balance(agents, requests)
      
      :least_connections -> 
        least_connections_balance(agents, requests)
      
      :weighted_response_time -> 
        weighted_response_time_balance(agents, requests)
      
      :resource_aware -> 
        resource_aware_balance(agents, requests)
      
      :adaptive ->
        adaptive_balance(agents, requests)
    end
  end
  
  defp round_robin_balance(agents, requests) do
    # Ultra-fast round-robin using atomic counter
    agent_count = length(agents)
    counter = :persistent_term.get(:nexus_round_robin_counter)
    
    Enum.map(requests, fn request ->
      # Atomic increment and wrap
      current = :counters.add(counter, 1, 1)
      agent_index = rem(current - 1, agent_count)
      agent = Enum.at(agents, agent_index)
      
      {agent, request}
    end)
  end
  
  defp least_connections_balance(agents, requests) do
    # Select agent with fewest active connections
    Enum.map(requests, fn request ->
      agent = Enum.min_by(agents, fn agent ->
        get_active_connections(agent.id)
      end)
      
      # Increment connection count
      increment_connection_count(agent.id)
      
      {agent, request}
    end)
  end
  
  defp weighted_response_time_balance(agents, requests) do
    # Select agents based on weighted response times
    agent_weights = Enum.map(agents, fn agent ->
      avg_response_time = get_average_response_time(agent.id)
      weight = if avg_response_time > 0, do: 1.0 / avg_response_time, else: 1.0
      {agent, weight}
    end)
    
    Enum.map(requests, fn request ->
      agent = weighted_random_selection(agent_weights)
      {agent, request}
    end)
  end
  
  defp resource_aware_balance(agents, requests) do
    # Consider CPU, memory, and queue depth
    Enum.map(requests, fn request ->
      agent = Enum.min_by(agents, fn agent ->
        calculate_resource_score(agent)
      end)
      
      {agent, request}
    end)
  end
  
  defp calculate_resource_score(agent) do
    # Lower score = better choice
    cpu_usage = get_agent_cpu_usage(agent.id)
    memory_usage = get_agent_memory_usage(agent.id)
    queue_depth = get_agent_queue_depth(agent.id)
    
    # Weighted combination
    cpu_usage * 0.4 + memory_usage * 0.3 + queue_depth * 0.3
  end
  
  defp adaptive_balance(agents, requests) do
    # Use ML model to predict optimal assignment
    case get_load_balancing_model() do
      {:ok, model} ->
        ml_enhanced_balance(agents, requests, model)
      
      {:error, :no_model} ->
        # Fall back to resource-aware balancing
        resource_aware_balance(agents, requests)
    end
  end
  
  def get_active_connections(agent_id) do
    case :ets.lookup(:nexus_agent_connections, agent_id) do
      [{_, count}] -> count
      [] -> 0
    end
  end
  
  def increment_connection_count(agent_id) do
    :ets.update_counter(:nexus_agent_connections, agent_id, 1, {agent_id, 0})
  end
  
  def decrement_connection_count(agent_id) do
    :ets.update_counter(:nexus_agent_connections, agent_id, -1, {agent_id, 0})
  end
end

defmodule Nexus.Coordination.Intelligence do
  @moduledoc """
  Machine learning enhanced coordination for predictive optimization.
  
  Features:
  - Predictive agent placement
  - Adaptive coordination strategies
  - Performance optimization through learning
  - Anomaly detection and response
  """
  
  use GenServer
  
  defstruct [
    :placement_model,
    :coordination_model,
    :performance_predictor,
    :anomaly_detector,
    :learning_history
  ]
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(_opts) do
    state = %__MODULE__{
      placement_model: initialize_placement_model(),
      coordination_model: initialize_coordination_model(),
      performance_predictor: initialize_performance_predictor(),
      anomaly_detector: initialize_anomaly_detector(),
      learning_history: :queue.new()
    }
    
    # Start learning loop
    schedule_learning_update()
    
    {:ok, state}
  end
  
  def predict_optimal_coordination(agents, goal) do
    GenServer.call(__MODULE__, {:predict_coordination, agents, goal})
  end
  
  def learn_from_coordination(coordination_result) do
    GenServer.cast(__MODULE__, {:learn_coordination, coordination_result})
  end
  
  def handle_call({:predict_coordination, agents, goal}, _from, state) do
    # Extract features for ML prediction
    features = extract_coordination_features(agents, goal)
    
    # Predict optimal coordination strategy
    strategy_prediction = Nexus.ML.predict(state.coordination_model, features)
    
    # Predict performance
    performance_prediction = Nexus.ML.predict(state.performance_predictor, features)
    
    result = %{
      recommended_strategy: strategy_prediction.class,
      confidence: strategy_prediction.confidence,
      predicted_performance: performance_prediction.value,
      reasoning: strategy_prediction.reasoning
    }
    
    {:reply, {:ok, result}, state}
  end
  
  def handle_cast({:learn_coordination, result}, state) do
    # Extract learning data
    features = result.features
    actual_strategy = result.strategy
    actual_performance = result.performance
    
    # Update coordination model
    new_coordination_model = Nexus.ML.update(
      state.coordination_model,
      features,
      actual_strategy
    )
    
    # Update performance predictor
    new_performance_predictor = Nexus.ML.update(
      state.performance_predictor,
      features,
      actual_performance
    )
    
    # Add to learning history
    learning_entry = %{
      timestamp: DateTime.utc_now(),
      features: features,
      strategy: actual_strategy,
      performance: actual_performance
    }
    
    new_history = :queue.in(learning_entry, state.learning_history)
    
    # Limit history size
    trimmed_history = if :queue.len(new_history) > 10000 do
      {_, trimmed} = :queue.out(new_history)
      trimmed
    else
      new_history
    end
    
    new_state = %{state |
      coordination_model: new_coordination_model,
      performance_predictor: new_performance_predictor,
      learning_history: trimmed_history
    }
    
    {:noreply, new_state}
  end
  
  def handle_info(:learning_update, state) do
    # Periodic model improvement
    improved_state = improve_models(state)
    
    # Schedule next update
    schedule_learning_update()
    
    {:noreply, improved_state}
  end
  
  defp extract_coordination_features(agents, goal) do
    # Extract numerical features for ML models
    [
      length(agents),                                    # Agent count
      calculate_agent_diversity(agents),                 # Agent type diversity
      goal.complexity || 1.0,                          # Goal complexity
      goal.deadline || 30.0,                           # Time constraint
      calculate_network_latency(agents),                # Network conditions
      get_current_system_load(),                        # System load
      count_active_coordinations(),                     # Coordination load
      get_historical_success_rate(goal.type)           # Historical success
    ]
  end
  
  defp improve_models(state) do
    # Use accumulated learning history to improve models
    recent_history = get_recent_learning_history(state.learning_history, 1000)
    
    if length(recent_history) >= 100 do  # Minimum data for improvement
      # Retrain coordination model
      improved_coordination_model = retrain_coordination_model(
        state.coordination_model,
        recent_history
      )
      
      # Retrain performance predictor
      improved_performance_predictor = retrain_performance_predictor(
        state.performance_predictor,
        recent_history
      )
      
      %{state |
        coordination_model: improved_coordination_model,
        performance_predictor: improved_performance_predictor
      }
    else
      state
    end
  end
end

defmodule Nexus.ML.SimpleModels do
  @moduledoc """
  Simple, interpretable ML models for coordination prediction.
  
  Focus on simple models that are:
  - Fast to train and predict
  - Interpretable and debuggable
  - Reliable in production
  """
  
  def linear_regression_new() do
    %{
      type: :linear_regression,
      weights: [],
      bias: 0.0,
      learning_rate: 0.01,
      samples_seen: 0
    }
  end
  
  def linear_regression_predict(model, features) do
    if length(model.weights) == 0 do
      # No training data yet, return default
      %{value: 0.5, confidence: 0.0}
    else
      # Linear prediction: w·x + b
      prediction = Enum.zip(model.weights, features)
                  |> Enum.map(fn {w, x} -> w * x end)
                  |> Enum.sum()
                  |> Kernel.+(model.bias)
      
      # Simple confidence based on number of samples
      confidence = min(1.0, model.samples_seen / 100.0)
      
      %{value: prediction, confidence: confidence}
    end
  end
  
  def linear_regression_update(model, features, target) do
    if length(model.weights) == 0 do
      # Initialize weights
      weights = Enum.map(features, fn _ -> :rand.normal(0.0, 0.1) end)
      %{model | weights: weights}
    else
      # Gradient descent update
      prediction = linear_regression_predict(model, features).value
      error = target - prediction
      
      # Update weights: w = w + α * error * x
      new_weights = Enum.zip(model.weights, features)
                   |> Enum.map(fn {w, x} -> w + model.learning_rate * error * x end)
      
      # Update bias: b = b + α * error
      new_bias = model.bias + model.learning_rate * error
      
      %{model |
        weights: new_weights,
        bias: new_bias,
        samples_seen: model.samples_seen + 1
      }
    end
  end
  
  def decision_tree_new() do
    %{
      type: :decision_tree,
      tree: nil,
      max_depth: 5,
      min_samples_split: 10,
      samples_seen: 0
    }
  end
  
  def decision_tree_predict(model, features) do
    case model.tree do
      nil -> 
        %{class: :default, confidence: 0.0, reasoning: "No training data"}
      
      tree ->
        result = traverse_tree(tree, features)
        %{
          class: result.class,
          confidence: result.confidence,
          reasoning: result.path
        }
    end
  end
  
  defp traverse_tree(tree, features) do
    traverse_tree(tree, features, [])
  end
  
  defp traverse_tree(%{type: :leaf, class: class, confidence: conf}, _features, path) do
    %{class: class, confidence: conf, path: Enum.reverse(path)}
  end
  
  defp traverse_tree(%{type: :split, feature: feat_idx, threshold: thresh, left: left, right: right}, features, path) do
    feature_value = Enum.at(features, feat_idx)
    
    if feature_value <= thresh do
      traverse_tree(left, features, ["#{feat_idx} <= #{thresh}" | path])
    else
      traverse_tree(right, features, ["#{feat_idx} > #{thresh}" | path])
    end
  end
end

defmodule Nexus.Coordination.Adaptive do
  @moduledoc """
  Adaptive coordination that responds to changing environmental conditions.
  
  Adaptations:
  - Network latency changes
  - Resource availability fluctuations
  - Agent failure patterns
  - Load distribution changes
  """
  
  use GenServer
  
  defstruct [
    :environment_monitor,
    :adaptation_rules,
    :current_strategy,
    :adaptation_history,
    :performance_baseline
  ]
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(_opts) do
    state = %__MODULE__{
      environment_monitor: start_environment_monitoring(),
      adaptation_rules: load_adaptation_rules(),
      current_strategy: :foundation,
      adaptation_history: [],
      performance_baseline: establish_performance_baseline()
    }
    
    # Start adaptation monitoring
    schedule_adaptation_check()
    
    {:ok, state}
  end
  
  def coordinate_adaptively(agents, goal) do
    GenServer.call(__MODULE__, {:coordinate_adaptively, agents, goal})
  end
  
  def handle_call({:coordinate_adaptively, agents, goal}, _from, state) do
    # Assess current environment
    environment = assess_current_environment(state.environment_monitor)
    
    # Determine optimal strategy for current conditions
    optimal_strategy = determine_optimal_strategy(environment, agents, goal, state)
    
    # Execute coordination with selected strategy
    result = execute_adaptive_coordination(agents, goal, optimal_strategy)
    
    # Record adaptation decision and result
    adaptation_record = %{
      timestamp: DateTime.utc_now(),
      environment: environment,
      strategy: optimal_strategy,
      performance: result.performance,
      agents_count: length(agents),
      goal_type: goal.type
    }
    
    new_history = [adaptation_record | Enum.take(state.adaptation_history, 999)]
    new_state = %{state | adaptation_history: new_history}
    
    {:reply, result, new_state}
  end
  
  def handle_info(:adaptation_check, state) do
    # Periodic adaptation assessment
    environment = assess_current_environment(state.environment_monitor)
    
    # Check if current strategy is still optimal
    case should_adapt_strategy?(environment, state.current_strategy, state) do
      {:adapt, new_strategy, reason} ->
        Logger.info("Adapting coordination strategy to #{new_strategy}: #{reason}")
        new_state = %{state | current_strategy: new_strategy}
        {:noreply, new_state}
      
      :no_adaptation ->
        {:noreply, state}
    end
  end
  
  defp assess_current_environment(monitor) do
    %{
      network_latency: get_average_network_latency(),
      cpu_utilization: get_cluster_cpu_utilization(),
      memory_utilization: get_cluster_memory_utilization(),
      agent_failure_rate: get_recent_agent_failure_rate(),
      coordination_load: get_active_coordination_count(),
      time_of_day: get_time_of_day_factor(),
      cluster_size: length(Node.list()) + 1
    }
  end
  
  defp determine_optimal_strategy(environment, agents, goal, state) do
    # Apply adaptation rules to determine best strategy
    applicable_rules = Enum.filter(state.adaptation_rules, fn rule ->
      rule.condition_fn.(environment, agents, goal)
    end)
    
    case applicable_rules do
      [] ->
        # No specific rule applies, use foundation strategy
        :foundation
      
      rules ->
        # Select highest priority applicable rule
        best_rule = Enum.max_by(rules, & &1.priority)
        best_rule.strategy
    end
  end
  
  defp load_adaptation_rules() do
    [
      # High latency environment
      %{
        name: :high_latency_adaptation,
        priority: 8,
        condition_fn: fn env, _agents, _goal ->
          env.network_latency > 100  # >100ms average latency
        end,
        strategy: :async_coordination
      },
      
      # High resource utilization
      %{
        name: :resource_pressure_adaptation,
        priority: 7,
        condition_fn: fn env, _agents, _goal ->
          env.cpu_utilization > 0.8 or env.memory_utilization > 0.9
        end,
        strategy: :lightweight_coordination
      },
      
      # Large cluster
      %{
        name: :large_cluster_adaptation,
        priority: 6,
        condition_fn: fn env, agents, _goal ->
          env.cluster_size > 50 or length(agents) > 1000
        end,
        strategy: :hierarchical_coordination
      },
      
      # High failure rate
      %{
        name: :high_failure_adaptation,
        priority: 9,
        condition_fn: fn env, _agents, _goal ->
          env.agent_failure_rate > 0.05  # >5% failure rate
        end,
        strategy: :fault_tolerant_coordination
      },
      
      # Performance degradation
      %{
        name: :performance_degradation,
        priority: 5,
        condition_fn: fn env, _agents, goal ->
          current_perf = get_current_performance(goal.type)
          baseline_perf = get_baseline_performance(goal.type)
          current_perf < baseline_perf * 0.8  # 20% degradation
        end,
        strategy: :performance_optimized_coordination
      }
    ]
  end
  
  defp execute_adaptive_coordination(agents, goal, strategy) do
    start_time = :erlang.monotonic_time(:microsecond)
    
    result = case strategy do
      :foundation ->
        Nexus.Coordination.Proven.coordinate_with_causality(agents, [goal])
      
      :async_coordination ->
        execute_async_coordination(agents, goal)
      
      :lightweight_coordination ->
        execute_lightweight_coordination(agents, goal)
      
      :hierarchical_coordination ->
        execute_hierarchical_coordination(agents, goal)
      
      :fault_tolerant_coordination ->
        execute_fault_tolerant_coordination(agents, goal)
      
      :performance_optimized_coordination ->
        Nexus.Coordination.HighPerformance.coordinate_high_performance(
          agents, 
          goal.type, 
          goal
        )
    end
    
    end_time = :erlang.monotonic_time(:microsecond)
    duration = end_time - start_time
    
    %{
      result: result,
      strategy: strategy,
      performance: %{
        duration_microseconds: duration,
        throughput: length(agents) / (duration / 1_000_000)
      }
    }
  end
  
  defp execute_async_coordination(agents, goal) do
    # Asynchronous coordination for high-latency environments
    coordination_tasks = Enum.map(agents, fn agent ->
      Task.async(fn ->
        Nexus.Agent.send_async_coordination(agent.id, goal)
      end)
    end)
    
    # Don't wait for all responses - accept partial results
    timeout = goal.timeout || 5000
    results = Task.yield_many(coordination_tasks, timeout)
    
    successful_results = Enum.flat_map(results, fn
      {_task, {:ok, result}} -> [result]
      _ -> []
    end)
    
    %{type: :async_coordination, results: successful_results}
  end
  
  defp execute_lightweight_coordination(agents, goal) do
    # Minimal coordination for resource-constrained environments
    case goal.type do
      :broadcast ->
        # Simple fire-and-forget broadcast
        Enum.each(agents, fn agent ->
          spawn(fn -> Nexus.Agent.cast(agent.id, {:lightweight_message, goal}) end)
        end)
        %{type: :lightweight_broadcast, status: :sent}
      
      :gather ->
        # Sample subset of agents instead of all
        sample_size = min(10, length(agents))
        sampled_agents = Enum.take_random(agents, sample_size)
        
        results = Enum.map(sampled_agents, fn agent ->
          Nexus.Agent.call(agent.id, {:gather_data, goal})
        end)
        
        %{type: :lightweight_gather, results: results, sample_size: sample_size}
    end
  end
  
  defp execute_hierarchical_coordination(agents, goal) do
    # Hierarchical coordination for large clusters
    hierarchy_depth = calculate_optimal_hierarchy_depth(length(agents))
    
    # Group agents into hierarchy
    hierarchy = build_coordination_hierarchy(agents, hierarchy_depth)
    
    # Execute coordination through hierarchy
    execute_through_hierarchy(hierarchy, goal)
  end
  
  defp execute_fault_tolerant_coordination(agents, goal) do
    # Fault-tolerant coordination with redundancy
    redundancy_factor = 3
    
    # Create redundant coordination groups
    coordination_groups = create_redundant_groups(agents, redundancy_factor)
    
    # Execute coordination across groups with voting
    group_results = Enum.map(coordination_groups, fn group ->
      execute_group_coordination(group, goal)
    end)
    
    # Vote on results for fault tolerance
    consensus_result = vote_on_group_results(group_results)
    
    %{type: :fault_tolerant_coordination, result: consensus_result}
  end
end