defmodule Foundation.MABEAM.Core do
  @moduledoc """
  Universal Variable Orchestrator for multi-agent coordination on the BEAM.
  
  Provides the core infrastructure for variables to coordinate agents across
  the entire BEAM cluster, managing agent lifecycle, resource allocation,
  and adaptive behavior based on collective performance.
  """
  
  use GenServer
  use Foundation.Services.ServiceBehaviour
  
  alias Foundation.{ProcessRegistry, Events, Telemetry}
  alias Foundation.MABEAM.{AgentRegistry, Coordination, Telemetry, Types}
  
  @type orchestrator_state :: %{
    agent_registry: pid(),
    coordination_engine: pid(),
    variable_registry: %{atom() => Types.orchestration_variable()},
    performance_tracker: pid(),
    resource_monitor: pid(),
    adaptation_scheduler: pid()
  }
  
  ## Public API
  
  @doc """
  Start the MABEAM orchestrator with the Foundation service framework.
  """
  @spec start_link(keyword()) :: GenServer.on_start()
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @doc """
  Register an orchestration variable that coordinates multiple agents.
  """
  @spec register_orchestration_variable(Types.orchestration_variable()) :: 
    :ok | {:error, term()}
  def register_orchestration_variable(variable) do
    GenServer.call(__MODULE__, {:register_variable, variable})
  end
  
  @doc """
  Coordinate all agents based on current variable values and system state.
  """
  @spec coordinate_system() :: {:ok, [Types.coordination_result()]} | {:error, term()}
  def coordinate_system() do
    GenServer.call(__MODULE__, :coordinate_system)
  end
  
  @doc """
  Adapt the system based on collective performance metrics.
  """
  @spec adapt_system(Types.performance_metrics()) :: {:ok, [Types.adaptation_result()]} | {:error, term()}
  def adapt_system(metrics) do
    GenServer.call(__MODULE__, {:adapt_system, metrics})
  end
  
  @doc """
  Get comprehensive system status including all agents and variables.
  """
  @spec system_status() :: {:ok, Types.system_status()} | {:error, term()}
  def system_status() do
    GenServer.call(__MODULE__, :system_status)
  end
  
  ## GenServer Implementation
  
  @impl true
  def init(opts) do
    # Initialize with Foundation's service framework
    case Foundation.Services.ServiceRegistry.register_service(__MODULE__, opts) do
      :ok ->
        state = initialize_orchestrator_state(opts)
        setup_telemetry()
        {:ok, state}
      
      {:error, reason} ->
        {:stop, reason}
    end
  end
  
  @impl true
  def handle_call({:register_variable, variable}, _from, state) do
    case validate_orchestration_variable(variable) do
      {:ok, validated_variable} ->
        new_state = %{state | 
          variable_registry: Map.put(state.variable_registry, variable.id, validated_variable)
        }
        
        # Emit event for variable registration
        Events.emit(:mabeam_variable_registered, %{
          variable_id: variable.id,
          variable_type: variable.type,
          affected_agents: variable.agents
        })
        
        {:reply, :ok, new_state}
      
      {:error, reason} ->
        {:reply, {:error, reason}, state}
    end
  end
  
  @impl true
  def handle_call(:coordinate_system, _from, state) do
    coordination_results = coordinate_all_variables(state)
    {:reply, {:ok, coordination_results}, state}
  end
  
  @impl true
  def handle_call({:adapt_system, metrics}, _from, state) do
    adaptation_results = adapt_all_variables(state, metrics)
    new_state = apply_adaptations(state, adaptation_results)
    {:reply, {:ok, adaptation_results}, new_state}
  end
  
  @impl true
  def handle_call(:system_status, _from, state) do
    status = compile_system_status(state)
    {:reply, {:ok, status}, state}
  end
  
  ## Private Implementation
  
  defp initialize_orchestrator_state(opts) do
    {:ok, agent_registry} = AgentRegistry.start_link(opts)
    {:ok, coordination_engine} = Coordination.start_link(opts)
    {:ok, performance_tracker} = Foundation.MABEAM.PerformanceTracker.start_link(opts)
    {:ok, resource_monitor} = Foundation.MABEAM.ResourceMonitor.start_link(opts)
    {:ok, adaptation_scheduler} = Foundation.MABEAM.AdaptationScheduler.start_link(opts)
    
    %{
      agent_registry: agent_registry,
      coordination_engine: coordination_engine,
      variable_registry: %{},
      performance_tracker: performance_tracker,
      resource_monitor: resource_monitor,
      adaptation_scheduler: adaptation_scheduler
    }
  end
  
  defp setup_telemetry() do
    Telemetry.attach_many(
      "mabeam-core-telemetry",
      [
        [:mabeam, :coordination, :start],
        [:mabeam, :coordination, :stop],
        [:mabeam, :adaptation, :start],
        [:mabeam, :adaptation, :stop],
        [:mabeam, :agent, :lifecycle]
      ],
      &handle_telemetry_event/4,
      %{}
    )
  end
  
  defp coordinate_all_variables(state) do
    state.variable_registry
    |> Map.values()
    |> Enum.map(&coordinate_variable(&1, state))
  end
  
  defp coordinate_variable(variable, state) do
    Coordination.coordinate_agents(
      state.coordination_engine,
      variable,
      get_current_context(state)
    )
  end
end

defmodule Foundation.MABEAM.AgentRegistry do
  @moduledoc """
  Registry for managing agent lifecycle, supervision, and metadata.
  
  Provides fault-tolerant agent management with automatic recovery,
  resource tracking, and performance monitoring.
  """
  
  use GenServer
  use Foundation.ProcessRegistry.ProcessBehaviour
  
  alias Foundation.MABEAM.Types
  
  @type registry_state :: %{
    agents: %{atom() => Types.agent_info()},
    supervisors: %{atom() => pid()},
    resource_allocations: %{atom() => Types.resource_allocation()},
    performance_history: %{atom() => [Types.performance_sample()]}
  }
  
  ## Public API
  
  @spec start_link(keyword()) :: GenServer.on_start()
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @doc """
  Register a new agent with the registry.
  """
  @spec register_agent(atom(), Types.agent_config()) :: :ok | {:error, term()}
  def register_agent(agent_id, config) do
    GenServer.call(__MODULE__, {:register_agent, agent_id, config})
  end
  
  @doc """
  Start an agent with fault tolerance and supervision.
  """
  @spec start_agent(atom()) :: {:ok, pid()} | {:error, term()}
  def start_agent(agent_id) do
    GenServer.call(__MODULE__, {:start_agent, agent_id})
  end
  
  @doc """
  Stop an agent gracefully.
  """
  @spec stop_agent(atom()) :: :ok | {:error, term()}
  def stop_agent(agent_id) do
    GenServer.call(__MODULE__, {:stop_agent, agent_id})
  end
  
  @doc """
  Get all active agents and their status.
  """
  @spec list_agents() :: {:ok, [Types.agent_info()]} | {:error, term()}
  def list_agents() do
    GenServer.call(__MODULE__, :list_agents)
  end
  
  @doc """
  Handle agent failure and initiate recovery.
  """
  @spec handle_agent_failure(atom(), term()) :: :ok
  def handle_agent_failure(agent_id, reason) do
    GenServer.cast(__MODULE__, {:agent_failure, agent_id, reason})
  end
  
  ## GenServer Implementation
  
  @impl true
  def init(opts) do
    # Register with Foundation's process registry
    Foundation.ProcessRegistry.register_process(__MODULE__, self(), %{
      type: :mabeam_agent_registry,
      capabilities: [:agent_management, :fault_tolerance, :resource_tracking]
    })
    
    state = %{
      agents: %{},
      supervisors: %{},
      resource_allocations: %{},
      performance_history: %{}
    }
    
    {:ok, state}
  end
  
  @impl true
  def handle_call({:register_agent, agent_id, config}, _from, state) do
    case validate_agent_config(config) do
      {:ok, validated_config} ->
        agent_info = create_agent_info(agent_id, validated_config)
        new_state = %{state | agents: Map.put(state.agents, agent_id, agent_info)}
        
        # Emit registration event
        Foundation.Events.emit(:mabeam_agent_registered, %{
          agent_id: agent_id,
          config: validated_config
        })
        
        {:reply, :ok, new_state}
      
      {:error, reason} ->
        {:reply, {:error, reason}, state}
    end
  end
  
  @impl true
  def handle_call({:start_agent, agent_id}, _from, state) do
    case Map.get(state.agents, agent_id) do
      nil ->
        {:reply, {:error, :agent_not_registered}, state}
      
      agent_info ->
        case start_agent_with_supervision(agent_info) do
          {:ok, pid, supervisor_pid} ->
            updated_info = %{agent_info | status: :running, pid: pid}
            new_state = %{state | 
              agents: Map.put(state.agents, agent_id, updated_info),
              supervisors: Map.put(state.supervisors, agent_id, supervisor_pid)
            }
            
            {:reply, {:ok, pid}, new_state}
          
          {:error, reason} ->
            {:reply, {:error, reason}, state}
        end
    end
  end
  
  @impl true
  def handle_cast({:agent_failure, agent_id, reason}, state) do
    case Map.get(state.agents, agent_id) do
      nil ->
        {:noreply, state}
      
      agent_info ->
        # Record failure
        Foundation.Events.emit(:mabeam_agent_failed, %{
          agent_id: agent_id,
          reason: reason,
          restart_strategy: agent_info.restart_strategy
        })
        
        # Attempt recovery based on restart strategy
        new_state = attempt_agent_recovery(state, agent_id, agent_info, reason)
        {:noreply, new_state}
    end
  end
  
  ## Private Implementation
  
  defp create_agent_info(agent_id, config) do
    %Types.agent_info{
      id: agent_id,
      module: config.module,
      config: config,
      status: :registered,
      pid: nil,
      start_time: nil,
      restart_count: 0,
      performance_metrics: %{},
      resource_usage: %{}
    }
  end
  
  defp start_agent_with_supervision(agent_info) do
    # Create a dedicated supervisor for this agent
    supervisor_spec = %{
      id: :"#{agent_info.id}_supervisor",
      start: {DynamicSupervisor, :start_link, [[strategy: :one_for_one]]},
      type: :supervisor
    }
    
    case DynamicSupervisor.start_child(Foundation.MABEAM.AgentSupervisor, supervisor_spec) do
      {:ok, supervisor_pid} ->
        # Start the actual agent under the supervisor
        agent_spec = %{
          id: agent_info.id,
          start: {agent_info.module, :start_link, [agent_info.config]},
          restart: :permanent,
          type: :worker
        }
        
        case DynamicSupervisor.start_child(supervisor_pid, agent_spec) do
          {:ok, agent_pid} ->
            {:ok, agent_pid, supervisor_pid}
          
          {:error, reason} ->
            DynamicSupervisor.terminate_child(Foundation.MABEAM.AgentSupervisor, supervisor_pid)
            {:error, reason}
        end
      
      {:error, reason} ->
        {:error, reason}
    end
  end
end

defmodule Foundation.MABEAM.Coordination do
  @moduledoc """
  Basic coordination protocols for multi-agent variable optimization.
  
  Provides fundamental coordination mechanisms including negotiation,
  consensus, and conflict resolution between agents.
  """
  
  use GenServer
  
  alias Foundation.MABEAM.Types
  
  @type coordination_state :: %{
    active_negotiations: %{reference() => Types.negotiation_session()},
    consensus_protocols: %{atom() => module()},
    conflict_resolvers: %{atom() => module()},
    coordination_history: [Types.coordination_event()]
  }
  
  ## Public API
  
  @spec start_link(keyword()) :: GenServer.on_start()
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @doc """
  Coordinate agents for a specific orchestration variable.
  """
  @spec coordinate_agents(pid(), Types.orchestration_variable(), Types.coordination_context()) ::
    {:ok, [Types.agent_directive()]} | {:error, term()}
  def coordinate_agents(coordinator_pid, variable, context) do
    GenServer.call(coordinator_pid, {:coordinate_agents, variable, context})
  end
  
  @doc """
  Negotiate variable values between multiple agents.
  """
  @spec negotiate_variable_value(atom(), [Types.agent_preference()], keyword()) ::
    {:ok, term()} | {:error, term()}
  def negotiate_variable_value(variable_id, agent_preferences, opts \\ []) do
    GenServer.call(__MODULE__, {:negotiate_value, variable_id, agent_preferences, opts})
  end
  
  @doc """
  Establish consensus on system-wide configuration changes.
  """
  @spec establish_consensus([atom()], map(), keyword()) ::
    {:ok, map()} | {:error, term()}
  def establish_consensus(agent_ids, proposed_changes, opts \\ []) do
    GenServer.call(__MODULE__, {:establish_consensus, agent_ids, proposed_changes, opts})
  end
  
  ## GenServer Implementation
  
  @impl true
  def init(opts) do
    state = %{
      active_negotiations: %{},
      consensus_protocols: load_consensus_protocols(opts),
      conflict_resolvers: load_conflict_resolvers(opts),
      coordination_history: []
    }
    
    {:ok, state}
  end
  
  @impl true
  def handle_call({:coordinate_agents, variable, context}, _from, state) do
    case variable.coordination_fn do
      nil ->
        # Use default coordination strategy
        result = default_coordination_strategy(variable, context)
        {:reply, result, state}
      
      coordination_fn when is_function(coordination_fn, 3) ->
        # Use custom coordination function
        result = coordination_fn.(variable, variable.agents, context)
        {:reply, result, record_coordination_event(state, variable, result)}
    end
  end
  
  @impl true
  def handle_call({:negotiate_value, variable_id, agent_preferences, opts}, _from, state) do
    strategy = Keyword.get(opts, :strategy, :weighted_consensus)
    
    case negotiate_with_strategy(strategy, variable_id, agent_preferences, opts) do
      {:ok, negotiated_value} ->
        {:reply, {:ok, negotiated_value}, state}
      
      {:error, reason} ->
        {:reply, {:error, reason}, state}
    end
  end
  
  ## Coordination Strategies
  
  defp default_coordination_strategy(variable, context) do
    case variable.type do
      :agent_selection ->
        coordinate_agent_selection(variable, context)
      
      :resource_allocation ->
        coordinate_resource_allocation(variable, context)
      
      :communication_topology ->
        coordinate_communication_topology(variable, context)
      
      :adaptation_rate ->
        coordinate_adaptation_rate(variable, context)
      
      _ ->
        {:error, :unsupported_coordination_type}
    end
  end
  
  defp coordinate_agent_selection(variable, context) do
    # Select agents based on current task requirements and performance
    available_agents = variable.agents
    task_requirements = Map.get(context, :task_requirements, %{})
    
    selected_agents = available_agents
    |> Enum.filter(&agent_meets_requirements?(&1, task_requirements))
    |> Enum.take(Map.get(variable.constraints, :max_concurrent, length(available_agents)))
    
    directives = Enum.map(selected_agents, fn agent_id ->
      %Types.agent_directive{
        agent: agent_id,
        action: :activate,
        parameters: extract_agent_parameters(variable, agent_id),
        priority: calculate_agent_priority(agent_id, context),
        timeout: Map.get(variable.constraints, :timeout, 30_000)
      }
    end)
    
    {:ok, directives}
  end
  
  defp coordinate_resource_allocation(variable, context) do
    # Allocate resources based on agent requirements and availability
    total_resources = Map.get(context, :available_resources, %{})
    agent_requirements = Map.get(variable.constraints, :resource_requirements, %{})
    
    allocations = calculate_resource_allocations(variable.agents, agent_requirements, total_resources)
    
    directives = Enum.map(allocations, fn {agent_id, allocation} ->
      %Types.agent_directive{
        agent: agent_id,
        action: :allocate_resources,
        parameters: %{resources: allocation},
        priority: 1,
        timeout: 5_000
      }
    end)
    
    {:ok, directives}
  end
  
  ## Negotiation Strategies
  
  defp negotiate_with_strategy(:weighted_consensus, variable_id, agent_preferences, opts) do
    total_weight = agent_preferences
    |> Enum.map(fn {_agent, _value, opts} -> Keyword.get(opts, :weight, 1.0) end)
    |> Enum.sum()
    
    weighted_sum = agent_preferences
    |> Enum.map(fn {_agent, value, opts} -> 
      weight = Keyword.get(opts, :weight, 1.0)
      value * weight
    end)
    |> Enum.sum()
    
    negotiated_value = weighted_sum / total_weight
    
    # Apply constraints if specified
    constraints = Keyword.get(opts, :constraints, [])
    final_value = apply_constraints(negotiated_value, constraints)
    
    {:ok, final_value}
  end
  
  defp negotiate_with_strategy(:auction, variable_id, agent_preferences, opts) do
    # Implement auction-based negotiation
    # Each agent bids for their preferred value
    bids = Enum.map(agent_preferences, fn {agent, value, opts} ->
      bid_amount = Keyword.get(opts, :bid, 1.0)
      {agent, value, bid_amount}
    end)
    
    # Winner takes all - highest bidder gets their preferred value
    {_winner, winning_value, _bid} = Enum.max_by(bids, fn {_, _, bid} -> bid end)
    
    {:ok, winning_value}
  end
  
  ## Private Helpers
  
  defp load_consensus_protocols(opts) do
    default_protocols = %{
      simple_majority: Foundation.MABEAM.Consensus.SimpleMajority,
      weighted_voting: Foundation.MABEAM.Consensus.WeightedVoting,
      unanimous: Foundation.MABEAM.Consensus.Unanimous
    }
    
    custom_protocols = Keyword.get(opts, :consensus_protocols, %{})
    Map.merge(default_protocols, custom_protocols)
  end
  
  defp load_conflict_resolvers(opts) do
    default_resolvers = %{
      priority_based: Foundation.MABEAM.Conflict.PriorityBased,
      compromise: Foundation.MABEAM.Conflict.Compromise,
      leader_election: Foundation.MABEAM.Conflict.LeaderElection
    }
    
    custom_resolvers = Keyword.get(opts, :conflict_resolvers, %{})
    Map.merge(default_resolvers, custom_resolvers)
  end
  
  defp record_coordination_event(state, variable, result) do
    event = %Types.coordination_event{
      timestamp: DateTime.utc_now(),
      variable_id: variable.id,
      coordination_type: variable.type,
      result: result,
      affected_agents: variable.agents
    }
    
    %{state | coordination_history: [event | state.coordination_history]}
  end
end

defmodule Foundation.MABEAM.Types do
  @moduledoc """
  Core type definitions for the MABEAM system.
  """
  
  @type agent_reference :: pid() | {atom(), node()} | atom()
  @type resource_allocation :: %{memory: pos_integer(), cpu_weight: float(), network_priority: atom()}
  @type coordination_pattern :: :broadcast | :ring | :star | :mesh | :custom
  @type adaptation_strategy :: :reactive | :predictive | :emergent | :consensus_based
  
  @type orchestration_variable :: %{
    id: atom(),
    type: orchestration_type(),
    agents: [agent_reference()],
    coordination_fn: coordination_function() | nil,
    adaptation_fn: adaptation_function() | nil,
    constraints: map(),
    resource_requirements: resource_allocation(),
    fault_tolerance: fault_tolerance_config(),
    telemetry_config: telemetry_config()
  }
  
  @type orchestration_type :: 
    :agent_selection | :resource_allocation | :communication_topology | 
    :adaptation_rate | :performance_threshold | :coordination_pattern | :custom
  
  @type coordination_function :: (orchestration_variable(), [agent_reference()], term() -> coordination_result())
  @type adaptation_function :: (orchestration_variable(), performance_metrics(), term() -> adaptation_result())
  
  @type coordination_result :: {:ok, [agent_directive()]} | {:error, coordination_error()}
  @type adaptation_result :: {:ok, orchestration_variable()} | {:error, adaptation_error()}
  
  @type agent_directive :: %{
    agent: agent_reference(),
    action: agent_action(),
    parameters: map(),
    priority: pos_integer(),
    timeout: pos_integer()
  }
  
  @type agent_action :: 
    :start | :stop | :reconfigure | :migrate | :scale_up | :scale_down | 
    :change_role | :update_communication | :adjust_parameters | :activate | :allocate_resources
  
  @type agent_config :: %{
    module: module(),
    supervision_strategy: atom(),
    resource_requirements: resource_allocation(),
    communication_interfaces: [atom()],
    role: agent_role(),
    restart_strategy: restart_strategy()
  }
  
  @type agent_role :: :coordinator | :executor | :evaluator | :optimizer | :monitor | :custom
  @type restart_strategy :: :permanent | :temporary | :transient
  
  @type agent_info :: %{
    id: atom(),
    module: module(),
    config: agent_config(),
    status: agent_status(),
    pid: pid() | nil,
    start_time: DateTime.t() | nil,
    restart_count: non_neg_integer(),
    performance_metrics: map(),
    resource_usage: map()
  }
  
  @type agent_status :: :registered | :starting | :running | :stopping | :stopped | :failed | :migrating
  
  @type performance_metrics :: %{
    aggregate_performance: float(),
    individual_performance: %{atom() => float()},
    resource_utilization: %{atom() => float()},
    communication_efficiency: float(),
    adaptation_success_rate: float(),
    fault_recovery_time: pos_integer()
  }
  
  @type coordination_context :: %{
    task_requirements: map(),
    available_resources: map(),
    system_load: float(),
    timestamp: DateTime.t()
  }
  
  @type coordination_event :: %{
    timestamp: DateTime.t(),
    variable_id: atom(),
    coordination_type: orchestration_type(),
    result: coordination_result(),
    affected_agents: [agent_reference()]
  }
  
  @type system_status :: %{
    active_agents: non_neg_integer(),
    active_variables: non_neg_integer(),
    system_performance: performance_metrics(),
    resource_utilization: map(),
    recent_events: [coordination_event()]
  }
  
  @type fault_tolerance_config :: %{
    max_failures: pos_integer(),
    failure_window: pos_integer(),
    recovery_strategy: atom(),
    escalation_policy: atom()
  }
  
  @type telemetry_config :: %{
    enabled: boolean(),
    metrics: [atom()],
    collection_interval: pos_integer(),
    storage_backend: atom()
  }
  
  # Error types
  @type coordination_error :: :timeout | :agent_unavailable | :resource_exhausted | :invalid_configuration
  @type adaptation_error :: :adaptation_failed | :invalid_metrics | :constraint_violation
  
  # Negotiation types
  @type agent_preference :: {agent_reference(), term(), keyword()}
  @type negotiation_session :: %{
    id: reference(),
    variable_id: atom(),
    participants: [agent_reference()],
    strategy: atom(),
    status: :active | :completed | :failed,
    result: term() | nil
  }
end

# Register MABEAM as a Foundation service
Foundation.Services.ServiceRegistry.register_service(
  Foundation.MABEAM.Core,
  %{
    type: :orchestration,
    capabilities: [:multi_agent, :variable_coordination, :fault_tolerance],
    dependencies: [:process_registry, :events, :telemetry]
  }
)

# MABEAM emits events through Foundation's event system
Foundation.Events.emit(:mabeam_coordination_completed, %{
  variable_id: :temperature,
  affected_agents: [:coder, :reviewer],
  coordination_result: :success
})

# MABEAM leverages Foundation's telemetry infrastructure
:telemetry.execute([:mabeam, :coordination, :duration], %{duration: 150}, %{
  variable_id: :temperature,
  agent_count: 3,
  coordination_type: :weighted_consensus
})