# mix.exs
defp deps do
  [
    # ... existing deps ...
    
    # Jido framework
    {:jido, github: "agentjido/jido", branch: "main"},
    {:jido_workflows, github: "agentjido/jido_workflows", branch: "main", optional: true},
    
    # Additional AI/ML integrations for Jido
    {:openai_ex, "~> 0.5", optional: true},
    {:anthropic_ex, "~> 0.1", optional: true},
    {:cohere, "~> 0.1", optional: true}
  ]
end

defmodule JidoFoundation.Bridge do
  @moduledoc """
  Core integration bridge between Jido and Foundation.
  """
  
  # Already implemented in lib/jido_foundation/bridge.ex
  # ✅ Agent registration
  # ✅ Metadata updates
  # ✅ Telemetry forwarding
  # ✅ Circuit breaker protection
  # ✅ Resource management
  # ✅ Agent discovery
  # ✅ Batch operations
  # ✅ Health monitoring
end

# test/jido_foundation/bridge_test.exs
# ✅ Already implemented with full coverage

defmodule JidoFoundation.AgentIntegrationTest do
  use ExUnit.Case
  
  describe "Jido.Agent with Foundation" do
    test "automatically registers with Foundation on startup"
    test "updates Foundation metadata on state changes"
    test "uses Foundation error handling for actions"
    test "participates in Foundation coordination"
    test "reports health through Foundation monitoring"
  end
end

defmodule JidoFoundation.ActionIntegrationTest do
  use ExUnit.Case
  
  describe "Jido.Action with Foundation" do
    test "actions protected by circuit breakers"
    test "resource limits enforced on actions"
    test "action telemetry flows through Foundation"
    test "failed actions trigger Foundation recovery"
    test "compensation actions on failure"
  end
end

defmodule JidoFoundation.SignalIntegrationTest do
  use ExUnit.Case
  
  describe "Jido.Signal with Foundation" do
    test "signals routed through coordination layer"
    test "broadcast signals to agent groups"
    test "signal filtering by capability"
    test "signal transformation pipeline"
    test "signal persistence and replay"
  end
end

defmodule JidoFoundation.Patterns.Workflow do
  @moduledoc """
  Jido workflow patterns using Foundation coordination.
  """
  
  def create_distributed_workflow(workflow_spec) do
    # Use Foundation.AtomicTransaction for workflow steps
    # Leverage MABEAM.CoordinationPatterns for orchestration
  end
  
  def parallel_workflow_execution(workflow, agents) do
    # Distribute workflow across multiple Jido agents
    # Use Foundation batch operations for efficiency
  end
end

defmodule JidoFoundation.Patterns.Team do
  @moduledoc """
  Multi-agent team patterns for Jido agents.
  """
  
  def create_specialist_team(team_spec) do
    # Different Jido agents with specific capabilities
    # Coordinated through Foundation patterns
  end
  
  def hierarchical_team(leader_spec, worker_specs) do
    # Leader-follower pattern using Foundation
    # Work distribution and result aggregation
  end
end

defmodule JidoFoundation.Patterns.Learning do
  @moduledoc """
  Distributed learning patterns for Jido agents.
  """
  
  def federated_learning(agents, model_spec) do
    # Use MLFoundation.DistributedOptimization
    # Coordinate model updates across agents
  end
  
  def ensemble_learning(base_learners, aggregator) do
    # Multiple Jido agents as base learners
    # Foundation coordination for voting/averaging
  end
end

defmodule JidoFoundation.Observability do
  @moduledoc """
  Enhanced observability for Jido agents.
  """
  
  def setup_agent_metrics(agent_pid) do
    # Register custom metrics for Jido-specific behavior
    # Integrate with Foundation telemetry pipeline
  end
  
  def create_agent_dashboard(agents) do
    # Real-time dashboard for agent monitoring
    # Leverage Foundation.PerformanceMonitor
  end
end

defmodule JidoFoundation.Deployment do
  @moduledoc """
  Production deployment patterns for Jido agents.
  """
  
  def rolling_update(agent_specs) do
    # Gradual agent updates without downtime
    # Use Foundation.Infrastructure for orchestration
  end
  
  def blue_green_deployment(current_agents, new_agents) do
    # Safe deployment with instant rollback
    # Coordinate through Foundation
  end
end

defmodule JidoFoundation.Security do
  @moduledoc """
  Security features for Jido agents.
  """
  
  def setup_agent_isolation(agent_pid) do
    # Process isolation and sandboxing
    # Resource limits through Foundation
  end
  
  def enable_action_auditing(agent_pid) do
    # Audit trail for all agent actions
    # Stored through Foundation infrastructure
  end
end

# Before (pure Jido)
defmodule MyAgent do
  use Jido.Agent
  
  def init(config) do
    {:ok, config}
  end
end

# After (with Foundation)
defmodule MyAgent do
  use Jido.Agent
  use JidoFoundation.Integration
  
  def init(config) do
    # Automatic Foundation registration
    {:ok, config}
  end
end

# Add Jido agents to existing Foundation app
{:ok, agent} = JidoFoundation.Bridge.start_and_register_agent(
  MyJidoAgent,
  %{config: value},
  capabilities: [:planning, :execution]
)

# Use Foundation patterns with Jido agents
Foundation.Coordination.coordinate_agents(
  [jido_agent1, jido_agent2],
  :consensus,
  decision_spec
)

config :foundation,
  registry_impl: MABEAM.AgentRegistry,
  coordination_impl: MABEAM.AgentCoordination

config :jido,
  use_foundation: true,
  foundation_opts: [
    auto_register: true,
    health_checks: true,
    telemetry: true
  ]

config :foundation,
  registry_impl: MABEAM.AgentRegistry,
  coordination_impl: MABEAM.AgentCoordination,
  error_handler: [
    circuit_breaker_threshold: 5,
    circuit_breaker_timeout: 30_000
  ]

config :jido,
  use_foundation: true,
  foundation_opts: [
    auto_register: true,
    health_checks: true,
    health_check_interval: 60_000,
    telemetry: true,
    resource_limits: [
      max_memory_mb: 512,
      max_cpu_percent: 80
    ]
  ]