defmodule SuperintelligenceWeb.AgentController do
  use SuperintelligenceWeb, :controller
  alias Superintelligence.AIAgent.{Coordinator, Brain, ToolRegistry}

  def index(conn, _params) do
    agents = Coordinator.list_agents()
    json(conn, %{agents: format_agents(agents)})
  end

  def show(conn, %{"id" => agent_name}) do
    case Map.get(Coordinator.list_agents(), agent_name) do
      nil ->
        conn
        |> put_status(404)
        |> json(%{error: "Agent not found"})
      
      agent ->
        json(conn, %{agent: format_agent(agent_name, agent)})
    end
  end

  def create(conn, %{"name" => name} = params) do
    config = Map.get(params, "config", %{})
    
    case Coordinator.create_agent(name, config) do
      {:ok, agent} ->
        conn
        |> put_status(201)
        |> json(%{agent: format_agent(name, agent)})
      
      {:error, reason} ->
        conn
        |> put_status(400)
        |> json(%{error: reason})
    end
  end

  def execute_task(conn, %{"task" => task_description} = params) do
    opts = Map.get(params, "options", [])
    
    case Coordinator.submit_task(task_description, opts) do
      {:ok, task_id} ->
        json(conn, %{
          task_id: task_id,
          message: "Task submitted successfully"
        })
      
      {:error, reason} ->
        conn
        |> put_status(400)
        |> json(%{error: reason})
    end
  end

  def execute_action(conn, %{"id" => agent_name, "action" => action} = params) do
    args = Map.get(params, "args", %{})
    
    case Superintelligence.AIAgent.Agent.execute_task(agent_name, action) do
      {:ok, result} ->
        json(conn, %{result: result})
      
      {:error, reason} ->
        conn
        |> put_status(400)
        |> json(%{error: reason})
    end
  end

  def status(conn, %{"id" => agent_name}) do
    case Superintelligence.AIAgent.Agent.get_status(agent_name) do
      status when is_map(status) ->
        json(conn, %{status: status})
      
      _ ->
        conn
        |> put_status(404)
        |> json(%{error: "Agent not found"})
    end
  end

  def tasks(conn, _params) do
    tasks = Coordinator.list_tasks()
    json(conn, %{tasks: format_tasks(tasks)})
  end

  def task_status(conn, %{"task_id" => task_id}) do
    case Coordinator.get_task_status(task_id) do
      nil ->
        conn
        |> put_status(404)
        |> json(%{error: "Task not found"})
      
      task ->
        json(conn, %{task: format_task(task)})
    end
  end

  def tools(conn, _params) do
    tools = ToolRegistry.list_tools()
    json(conn, %{tools: tools})
  end

  def create_tool(conn, %{"name" => name, "code" => code, "description" => description, "parameters" => parameters}) do
    case ToolRegistry.create_or_update_tool(name, code, description, parameters) do
      {:ok, tool} ->
        conn
        |> put_status(201)
        |> json(%{tool: tool, message: "Tool created successfully"})
      
      {:error, reason} ->
        conn
        |> put_status(400)
        |> json(%{error: reason})
    end
  end

  def execute_tool(conn, %{"name" => name, "args" => args}) do
    case ToolRegistry.execute_tool(name, args) do
      {:ok, result} ->
        json(conn, %{result: result})
      
      {:error, reason} ->
        conn
        |> put_status(400)
        |> json(%{error: reason})
    end
  end

  def delete(conn, %{"id" => agent_name}) do
    case Coordinator.stop_agent(agent_name) do
      :ok ->
        json(conn, %{message: "Agent stopped successfully"})
      
      {:error, reason} ->
        conn
        |> put_status(400)
        |> json(%{error: reason})
    end
  end

  # Private helpers

  defp format_agents(agents) do
    Enum.map(agents, fn {name, agent} ->
      format_agent(name, agent)
    end)
  end

  defp format_agent(name, agent) do
    %{
      name: name,
      status: agent.status,
      current_task: agent.current_task,
      created_at: agent.created_at,
      config: agent.config
    }
  end

  defp format_tasks(tasks) do
    tasks
    |> Map.values()
    |> Enum.map(&format_task/1)
  end

  defp format_task(task) do
    %{
      id: task.id,
      description: task.description,
      status: task.status,
      created_at: task.created_at,
      assigned_agent: task.assigned_agent,
      result: task.result
    }
  end
end