bb

# SPDX-FileCopyrightText: 2026 James Harton
#
# SPDX-License-Identifier: Apache-2.0
if Code.ensure_loaded?(Igniter) do
  defmodule Mix.Tasks.Bb.FromUrdf do
    @shortdoc "Generate a BB robot module from a URDF file"
    @moduledoc """
    #{@shortdoc}
    Reads a URDF XML file and writes a `defmodule` that uses `BB` with an
    equivalent topology to your project.
    If the target module already exists, only its `topology do ... end` block
    is replaced — `settings`, sensors, controllers, commands and any other
    hand-written content are left in place. If the existing module has no
    `topology` block, one is appended.
    ## Example
    ```bash
    mix bb.from_urdf path/to/robot.urdf --module MyApp.Robot
    ```
    ## Options
      * `--module`, `-m` - The module name for the generated robot.
        Defaults to `{AppPrefix}.Robot`.
    ## URDF feature support
    `<mimic>` joints are emitted as a `BB.Sensor.Mimic` attached to the
    mimicking joint — BB's sensor implements the same
    `position * multiplier + offset` semantics as URDF.
    These URDF features have no direct BB equivalent and are skipped with a
    warning rather than failing the import:
      * `<safety_controller>` blocks
      * `<transmission>` blocks
      * `<gazebo>` extensions
    Mesh files are referenced as-is — `package://` URIs from ROS are not
    rewritten, so you may need to copy meshes into the project and adjust
    paths by hand.
    """
    use Igniter.Mix.Task
    alias BB.Urdf.{Importer, Parser}
    alias Igniter.Code.{Common, Function}
    @impl Igniter.Mix.Task
    def info(_argv, _parent) do
      %Igniter.Mix.Task.Info{
        positional: [:urdf_path],
        schema: [module: :string],
        aliases: [m: :module]
      }
    end
    @impl Igniter.Mix.Task
    def igniter(igniter) do
      %{urdf_path: urdf_path} = igniter.args.positional
      module_name = resolve_module(igniter)
      case Parser.parse_file(urdf_path) do
        {:ok, parsed} ->
          generate(igniter, parsed, module_name)
        {:error, reason} ->
          Igniter.add_issue(igniter, "Could not parse URDF #{urdf_path}: #{inspect(reason)}")
      end
    end
    defp resolve_module(igniter) do
      case Keyword.get(igniter.args.options, :module) do
        nil -> Igniter.Project.Module.module_name(igniter, "Robot")
        name -> Igniter.Project.Module.parse(name)
      end
    end
    defp generate(igniter, parsed, module_name) do
      with {:ok, source, warnings} <- Importer.to_source(parsed, module_name),
           {:ok, topology_ast, _} <- Importer.to_topology_quoted(parsed) do
        igniter
        |> find_and_update_or_create_module(module_name, source, topology_ast)
        |> add_warnings(warnings)
      else
        {:error, reason} ->
          Igniter.add_issue(igniter, "Could not generate BB module: #{inspect(reason)}")
      end
    end
    defp find_and_update_or_create_module(igniter, module_name, source, topology_ast) do
      body = strip_defmodule(source, module_name)
      Igniter.Project.Module.find_and_update_or_create_module(
        igniter,
        module_name,
        body,
        fn zipper -> replace_or_insert_topology(zipper, topology_ast) end
      )
    end
    defp replace_or_insert_topology(zipper, topology_ast) do
      case Function.move_to_function_call_in_current_scope(zipper, :topology, 1) do
        {:ok, found} ->
          {:ok, Common.replace_code(found, topology_ast)}
        :error ->
          {:ok, Common.add_code(zipper, topology_ast)}
      end
    end
    defp strip_defmodule(source, module_name) do
      module_string = Macro.inspect_atom(:literal, module_name)
      source
      |> String.replace(~r/\Adefmodule\s+#{Regex.escape(module_string)}\s+do\n?/, "")
      |> String.replace(~r/\nend\s*\z/, "")
      |> String.trim_trailing()
    end
    defp add_warnings(igniter, warnings) do
      Enum.reduce(warnings, igniter, fn warning, acc ->
        Igniter.add_warning(acc, warning)
      end)
    end
  end
else
  defmodule Mix.Tasks.Bb.FromUrdf do
    @shortdoc "Generate a BB robot module from a URDF file"
    @moduledoc false
    use Mix.Task
    def run(_argv) do
      Mix.shell().error("""
      The bb.from_urdf task requires igniter.
          mix deps.get
          mix bb.from_urdf path/to/robot.urdf --module MyApp.Robot
      """)
      exit({:shutdown, 1})
    end
  end
end