# Mortal Mode (Zero Config)
config :foundation, cluster: true

# Apprentice Mode (Simple Config)
config :foundation, cluster: :kubernetes
config :foundation, cluster: :consul
config :foundation, cluster: :dns
config :foundation, cluster: [strategy: :gossip, secret: "my-secret"]

# Wizard Mode (Full libcluster passthrough)
config :libcluster, topologies: [...]  # Foundation detects and defers

# Foundation.Supervisor must provide these child processes when clustering enabled:
- {Cluster.Supervisor, resolved_topology}
- {Phoenix.PubSub, name: Foundation.PubSub, adapter: Phoenix.PubSub.PG2}
- {Horde.Registry, name: Foundation.ProcessRegistry, keys: :unique, members: :auto}
- {Horde.DynamicSupervisor, name: Foundation.DistributedSupervisor, members: :auto}

# Primary API Contract
@spec start_singleton(module(), args :: list(), opts :: keyword()) ::
  {:ok, pid()} | {:error, term()}

@spec start_replicated(module(), args :: list(), opts :: keyword()) ::
  list({:ok, pid()} | {:error, term()})

@spec lookup_singleton(term()) :: {:ok, pid()} | :not_found

# Required Options
opts :: [
  name: term(),           # Registry key (optional)
  restart: :permanent | :temporary | :transient,
  timeout: pos_integer() | :infinity
]

# Primary API Contract
@spec register_service(name :: term(), pid(), capabilities :: list(), metadata :: map()) ::
  :ok | {:error, term()}

@spec discover_services(criteria :: keyword()) :: list(service_info())

@type service_info() :: %{
  name: term(),
  pid: pid(),
  node: atom(),
  capabilities: list(),
  metadata: map(),
  registered_at: integer()
}

# Discovery Criteria
criteria :: [
  name: term(),
  capabilities: list(),
  node: atom(),
  health_check: (service_info() -> boolean())
]

# Primary API Contract  
@spec broadcast(channel :: atom(), message :: term(), opts :: keyword()) :: :ok
@spec subscribe(channel :: atom(), handler :: pid()) :: :ok
@spec route_message(message :: term(), opts :: keyword()) :: :ok

# Standard Channels
@type channel() :: :control | :events | :telemetry | :data

# Routing Options
opts :: [
  channel: channel(),
  priority: :low | :normal | :high,
  compression: boolean(),
  timeout: pos_integer()
]

# Mortal: Foundation controls everything
config :foundation, cluster: true

# Apprentice: Foundation translates high-level config  
config :foundation, cluster: :kubernetes

# Wizard: Foundation defers to existing libcluster config
config :libcluster, topologies: [...]

# Standard channels map to PubSub topics
:control -> "foundation:control"
:events -> "foundation:events"  
:telemetry -> "foundation:telemetry"
:data -> "foundation:data"

# Test each facade function in isolation
test "ProcessManager.start_singleton creates child and registers" do
  assert {:ok, pid} = Foundation.ProcessManager.start_singleton(TestWorker, [], name: :test)
  assert {:ok, ^pid} = Foundation.ProcessManager.lookup_singleton(:test)
  assert [{^pid, _}] = Horde.Registry.lookup(Foundation.ProcessRegistry, :test)
end

# Test configuration translation
test "ClusterConfig translates :kubernetes to libcluster topology" do
  topology = Foundation.ClusterConfig.translate_kubernetes_config(app_name: "test-app")
  assert topology[:strategy] == Cluster.Strategy.Kubernetes
  assert topology[:config][:kubernetes_selector] == "app=test-app"
end

# Multi-node cluster formation
test "cluster forms correctly with mdns_lite strategy" do
  nodes = start_cluster([:"[email protected]", :"[email protected]"])
  
  # Verify cluster formation
  Enum.each(nodes, fn node ->
    cluster_nodes = :rpc.call(node, Node, :list, [])
    assert length(cluster_nodes) == 1  # Other node connected
  end)
end

# Service discovery across nodes
test "services registered on one node are discoverable from another" do
  {node1, node2} = start_two_node_cluster()
  
  # Register service on node1
  :ok = :rpc.call(node1, Foundation.ServiceMesh, :register_service, 
    [:test_service, spawn_service(), [:capability_a]])
  
  # Discover from node2
  services = :rpc.call(node2, Foundation.ServiceMesh, :discover_services, 
    [name: :test_service])
  assert length(services) == 1
end

# Complete application scenarios
test "elixir_scope distributed debugging workflow" do
  cluster = start_three_node_cluster()
  
  # Start ElixirScope on cluster
  start_elixir_scope_on_cluster(cluster)
  
  # Execute distributed operation with tracing
  trace_id = ElixirScope.start_distributed_trace()
  result = execute_distributed_workflow(cluster, trace_id)
  
  # Verify trace data collected from all nodes
  trace_data = ElixirScope.get_trace_data(trace_id)
  assert trace_data.nodes == cluster
  assert trace_data.complete == true
end

@tag :benchmark
test "cluster formation completes within SLA" do
  start_time = System.monotonic_time(:millisecond)
  
  nodes = start_cluster_async(5)
  wait_for_full_cluster_formation(nodes)
  
  formation_time = System.monotonic_time(:millisecond) - start_time
  assert formation_time < 30_000  # 30 seconds SLA
end

@tag :benchmark  
test "channel messaging meets throughput requirements" do
  cluster = start_cluster(3)
  
  # Measure messages per second across channels
  throughput = measure_channel_throughput(cluster, duration: 10_000)
  
  assert throughput[:control] > 1_000    # 1k/sec control messages
  assert throughput[:events] > 5_000     # 5k/sec event messages  
  assert throughput[:data] > 10_000      # 10k/sec data messages
end

test "cluster heals after network partition" do
  cluster = start_cluster(5)
  
  # Create partition: [node1, node2] vs [node3, node4, node5]
  create_network_partition(cluster, split: 2)
  
  # Verify each partition continues operating
  verify_partition_operations(cluster)
  
  # Heal partition
  heal_network_partition(cluster)
  
  # Verify cluster convergence
  assert_eventually(fn -> cluster_fully_converged?(cluster) end, 30_000)
end

test "services migrate when nodes fail" do
  cluster = start_cluster(3)
  
  # Start singleton service
  {:ok, service_pid} = Foundation.ProcessManager.start_singleton(TestService, [])
  original_node = node(service_pid)
  
  # Kill the node hosting the service
  kill_node(original_node)
  
  # Verify service restarts on another node
  assert_eventually(fn ->
    case Foundation.ProcessManager.lookup_singleton(TestService) do
      {:ok, new_pid} -> node(new_pid) != original_node
      _ -> false
    end
  end, 10_000)
end

# Foundation must support secure cluster formation
config :foundation,
  cluster: :kubernetes,
  security: [
    erlang_cookie: {:system, "ERLANG_COOKIE"},
    tls_enabled: true,
    certificate_file: "/etc/ssl/certs/cluster.pem"
  ]

# Services can declare required capabilities
Foundation.ServiceMesh.register_service(
  :payment_service,
  self(),
  [:payment_processing],
  %{security_level: :high, audit_required: true}
)

# Discovery can filter by security requirements
Foundation.ServiceMesh.discover_services(
  capabilities: [:payment_processing],
  security_level: :high
)

# Foundation must expose health endpoints
Foundation.HealthMonitor.cluster_health()
# => %{
#   status: :healthy | :degraded | :critical,
#   nodes: [{node, status, metrics}],
#   services: [{service, status, instances}],
#   last_check: timestamp
# }

# Standard telemetry events Foundation must emit
[:foundation, :cluster, :node_joined] => %{node: atom()}
[:foundation, :cluster, :node_left] => %{node: atom(), reason: term()}
[:foundation, :service, :registered] => %{name: term(), node: atom()}
[:foundation, :service, :deregistered] => %{name: term(), node: atom()}
[:foundation, :message, :sent] => %{channel: atom(), size: integer()}
[:foundation, :message, :received] => %{channel: atom(), latency: integer()}

# Foundation must provide structured logging
Logger.info("Foundation cluster formed", 
  cluster_id: cluster_id,
  node_count: 3,
  formation_time_ms: 15_432,
  strategy: :kubernetes
)

Logger.warning("Service health check failed",
  service: :user_service,
  node: :"[email protected]",
  consecutive_failures: 3,
  action: :marking_unhealthy
)

# Foundation must work in containerized environments
FROM elixir:1.15-alpine

# Required for clustering
RUN apk add --no-cache netcat-openbsd

# Foundation clustering just works
COPY . /app
WORKDIR /app
RUN mix deps.get && mix compile

# Single environment variable enables clustering
ENV FOUNDATION_CLUSTER=kubernetes

CMD ["mix", "run", "--no-halt"]

# Foundation must integrate with Kubernetes service discovery
apiVersion: apps/v1
kind: Deployment
metadata:
  name: foundation-app
spec:
  selector:
    matchLabels:
      app: foundation-app
  template:
    metadata:
      labels:
        app: foundation-app
    spec:
      containers:
      - name: app
        image: foundation-app:latest
        env:
        - name: FOUNDATION_CLUSTER
          value: "kubernetes"
        - name: FOUNDATION_APP_NAME
          value: "foundation-app"

# Existing libcluster config continues to work
config :libcluster,
  topologies: [
    k8s: [
      strategy: Cluster.Strategy.Kubernetes,
      config: [...]
    ]
  ]

# Just add Foundation dependency - no config changes needed
{:foundation, "~> 2.0"}

# Phase 1: Add Foundation, keep libcluster config
{:foundation, "~> 2.0"}

# Phase 2: Start using Foundation services
Foundation.ServiceMesh.register_service(:my_service, self())

# Phase 3: Switch to Foundation clustering
config :foundation, cluster: :kubernetes
# Remove old libcluster config

# Before: Manual process registry
GenServer.start_link(MyService, [], name: {:global, :my_service})

# After: Foundation service mesh
Foundation.ProcessManager.start_singleton(MyService, [], name: :my_service)

# Before: Manual message broadcasting
Enum.each(Node.list(), fn node ->
  send({:my_service, node}, message)
end)

# After: Foundation channels
Foundation.Channels.broadcast(:events, message)