# Jido agents are compile-time validated and type-safe
defmodule WeatherAgent do
  use Jido.Agent,
    name: "weather_service",
    schema: [
      location: [type: :string, required: true],
      api_key: [type: :string, required: true],
      cache_ttl: [type: :integer, default: 300],
      status: [type: :atom, values: [:idle, :fetching, :cached, :error]]
    ],
    actions: [FetchWeather, CacheWeather, ValidateLocation]

  # Sophisticated lifecycle hooks
  def on_before_run(agent) do
    # Pre-execution validation and setup
    {:ok, agent}
  end

  def on_after_run(agent, result, directives) do
    # Post-execution cleanup and state updates
    {:ok, agent}
  end

  def on_error(agent, error) do
    # Intelligent error recovery
    {:ok, %{agent | state: %{status: :error}}}
  end
end

# Actions automatically convert to LLM tool schemas
defmodule FetchWeatherAction do
  use Jido.Action,
    name: "fetch_weather",
    description: "Fetches current weather for a location",
    schema: [
      location: [type: :string, required: true, 
                 description: "City or location name"],
      units: [type: :string, default: "metric", 
              values: ["metric", "imperial"]]
    ]

  def run(params, _context) do
    # Implementation
    {:ok, weather_data}
  end
end

# Automatic tool conversion for LLM integration
FetchWeatherAction.to_tool()
# Returns:
%{
  "name" => "fetch_weather",
  "description" => "Fetches current weather for a location",
  "parameters" => %{
    "type" => "object",
    "properties" => %{
      "location" => %{
        "type" => "string",
        "description" => "City or location name"
      },
      "units" => %{
        "type" => "string",
        "enum" => ["metric", "imperial"],
        "default" => "metric"
      }
    },
    "required" => ["location"]
  }
}

# Sophisticated event routing with patterns
Jido.Signal.Bus.subscribe(self(), "weather.*")
Jido.Signal.Bus.subscribe(self(), "error.**")

# Signal with rich metadata
signal = %Jido.Signal{
  source: weather_agent_pid,
  type: "weather.updated",
  data: %{location: "NYC", temperature: 22},
  metadata: %{timestamp: DateTime.utc_now()}
}

# Built-in persistence and journaling
Jido.Signal.Journal.append(signal)
Jido.Signal.Snapshot.create_snapshot(agent_pid)

# Hot-swappable skills
defmodule TranslationSkill do
  use Jido.Skill,
    name: "translation",
    description: "Provides text translation capabilities"

  def on_signal(%Jido.Signal{type: "translate.request"} = signal, state) do
    # Handle translation request
    translated = translate(signal.data.text, signal.data.target_lang)
    
    response = %Jido.Signal{
      source: self(),
      type: "translate.response",
      data: %{translated_text: translated}
    }
    
    {:ok, [response], state}
  end
end

# Runtime skill management
Jido.Agent.add_skill(agent_pid, TranslationSkill, %{api_key: "..."})
Jido.Agent.remove_skill(agent_pid, TranslationSkill)

# Jido has some distribution via Phoenix.PubSub
defmodule Jido.Signal.Dispatch.PubSub do
  # Can broadcast signals across nodes
  def dispatch(signal, topic) do
    Phoenix.PubSub.broadcast(MyApp.PubSub, topic, signal)
  end
end

# Process topology tracking
Jido.Signal.Topology.get_process_tree(root_pid)
# Returns hierarchical view of all related processes

# Foundation adds enterprise clustering around Jido
defmodule Foundation.ClusteredAgentSystem do
  # Automatic cluster formation
  def start_cluster(node_configs) do
    Foundation.Clustering.Manager.form_cluster(node_configs)
  end

  # Distributed agent placement
  def deploy_agent(agent_spec, placement_strategy \\ :load_balanced) do
    target_node = Foundation.Placement.select_node(placement_strategy)
    Foundation.RemoteExecution.spawn_agent(target_node, agent_spec)
  end

  # Cross-node coordination
  def coordinate_agents(agent_group, coordination_pattern) do
    Foundation.Coordination.DistributedBarrier.synchronize(
      agent_group, coordination_pattern
    )
  end

  # Enterprise monitoring
  def monitor_cluster_health do
    Foundation.Monitoring.ClusterHealth.collect_metrics()
  end
end

defmodule SimpleAgentApp do
  use Application

  def start(_type, _args) do
    children = [
      {Registry, keys: :unique, name: SimpleAgentApp.Registry},
      {DynamicSupervisor, name: SimpleAgentApp.AgentSupervisor},
      
      # Jido agents with all built-in capabilities
      {WeatherAgent, [id: "weather_service"]},
      {ProcessorAgent, [id: "data_processor"]},
      {CoordinatorAgent, [id: "workflow_coordinator"]}
    ]
    
    Supervisor.start_link(children, strategy: :one_for_one)
  end
end

# Jido provides:
# - Sophisticated agent lifecycle
# - Action-to-tool conversion
# - Signal routing and processing
# - Skills and sensor management
# - Local coordination and state management

defmodule EnterpriseAgentCluster do
  # Foundation handles clustering infrastructure
  use Foundation.ClusterApplication
  
  def start_cluster(opts) do
    # Foundation: Cluster formation and node management
    {:ok, cluster} = Foundation.Clustering.start_link(opts)
    
    # Foundation: Distributed registries and coordination
    {:ok, _registry} = Foundation.DistributedRegistry.start_link()
    {:ok, _coordinator} = Foundation.Coordination.Manager.start_link()
    
    # Foundation: Enterprise services
    {:ok, _monitor} = Foundation.Monitoring.ClusterMonitor.start_link()
    {:ok, _security} = Foundation.Security.Manager.start_link()
    
    # Jido: Agent implementation excellence
    agent_specs = [
      {WeatherAgent, [cluster_node: :auto_select]},
      {ProcessorAgent, [cluster_node: :auto_select]},
      {CoordinatorAgent, [cluster_node: :leader]}
    ]
    
    # Foundation places agents optimally across cluster
    Foundation.AgentDeployer.deploy_agents(agent_specs)
  end
end