# SPDX-FileCopyrightText: 2023 Frank Hunleth
#
# SPDX-License-Identifier: Apache-2.0
#
defmodule VintageNet.DHCP.Options do
  @moduledoc """
  DHCP Options
  """

  alias VintageNet.IP
  require Logger

  @typedoc """
  A map of options and other information reported by udhcpc

  Here's an example:

  ```elixir
  %{
    broadcast: {192, 168, 7, 255},
    dns: {192, 168, 7, 1},
    domain: "hunleth.lan",
    hostname: "nerves-9780",
    ip: {192, 168, 7, 190},
    lease: 86400,
    mask: 24,
    router: {192, 168, 7, 1},
    serverid: {192, 168, 7, 1},
    siaddr: {192, 168, 7, 1},
    subnet: {255, 255, 255, 0}
  }
  ```
  """
  @type t() :: %{
          optional(:ip) => :inet.ip_address(),
          optional(:mask) => non_neg_integer(),
          optional(:siaddr) => :inet.ip_address(),
          optional(:subnet) => :inet.ip_address(),
          optional(:timezone) => String.t(),
          optional(:router) => [:inet.ip_address()],
          optional(:dns) => [:inet.ip_address()],
          optional(:lprsrv) => [:inet.ip_address()],
          optional(:hostname) => String.t(),
          optional(:bootsize) => String.t(),
          optional(:domain) => String.t(),
          optional(:swapsrv) => :inet.ip_address(),
          optional(:rootpath) => String.t(),
          optional(:ipttl) => non_neg_integer(),
          optional(:mtu) => non_neg_integer(),
          optional(:broadcast) => :inet.ip_address(),
          optional(:routes) => [:inet.ip_address()],
          optional(:nisdomain) => String.t(),
          optional(:nissrv) => [:inet.ip_address()],
          optional(:ntpsrv) => [:inet.ip_address()],
          optional(:wins) => String.t(),
          optional(:lease) => non_neg_integer(),
          optional(:serverid) => :inet.ip_address(),
          optional(:message) => String.t(),
          optional(:renewal_time) => non_neg_integer(),
          optional(:rebind_time) => non_neg_integer(),
          optional(:vendor) => String.t(),
          optional(:tftp) => String.t(),
          optional(:bootfile) => String.t(),
          optional(:userclass) => String.t(),
          optional(:tzstr) => String.t(),
          optional(:tzdbstr) => String.t(),
          optional(:search) => String.t(),
          optional(:sipsrv) => String.t(),
          optional(:staticroutes) => [:inet.ip_address()],
          optional(:vlanid) => String.t(),
          optional(:vlanpriority) => non_neg_integer(),
          optional(:pxeconffile) => String.t(),
          optional(:pxepathprefix) => String.t(),
          optional(:reboottime) => String.t(),
          optional(:ip6rd) => String.t(),
          optional(:msstaticroutes) => String.t(),
          optional(:wpad) => String.t()
        }

  # Extract and translate udhcpc environment variables to DHCP options
  @doc false
  @spec udhcpc_to_options(%{String.t() => String.t()}) :: t()
  def udhcpc_to_options(info) do
    info
    |> Map.new(&transform_udhcpc_option/1)
    |> Map.delete(:discard)
  end

  # udhcpc passes DHCP options via environment variables and there's a lot of noise.
  # Transform known keys to atoms and mark unknown or unsupported ones as `:discard`
  defp transform_udhcpc_option({k, v}) do
    # See https://elixir.bootlin.com/busybox/1.35.0/source/networking/udhcp/common.c#L97
    # See https://www.rfc-editor.org/rfc/rfc2132 for descriptions
    udhcpc_option_map = %{
      # DHCP fields
      "ip" => {:ip, &IP.ip_to_tuple/1},
      "mask" => {:mask, &parse_int/1},
      "siaddr" => {:siaddr, &IP.ip_to_tuple/1},
      # DHCP options
      "subnet" => {:subnet, &IP.ip_to_tuple/1},
      "timezone" => {:timezone, &identity/1},
      "router" => {:router, &parse_ip_list/1},
      # "opt4" => :timesrv,
      # "opt5" => :namesrv,
      "dns" => {:dns, &parse_ip_list/1},
      # "opt7" => :logsrv,
      # "opt8" => :cookiesrv,
      "lprsrv" => {:lprsrv, &parse_ip_list/1},
      "hostname" => {:hostname, &identity/1},
      "bootsize" => {:bootsize, &identity/1},
      "domain" => {:domain, &identity/1},
      "swapsrv" => {:swapsrv, &IP.ip_to_tuple/1},
      "rootpath" => {:rootpath, &identity/1},
      "ipttl" => {:ipttl, &parse_int/1},
      "mtu" => {:mtu, &parse_int/1},
      "broadcast" => {:broadcast, &IP.ip_to_tuple/1},
      "routes" => {:routes, &parse_ip_list/1},
      "nisdomain" => {:nisdomain, &identity/1},
      "nissrv" => {:nissrv, &parse_ip_list/1},
      "ntpsrv" => {:ntpsrv, &parse_ip_list/1},
      "wins" => {:wins, &identity/1},
      "lease" => {:lease, &parse_int/1},
      "serverid" => {:serverid, &IP.ip_to_tuple/1},
      "message" => {:message, &identity/1},
      "opt58" => {:renewal_time, &parse_hex/1},
      "opt59" => {:rebind_time, &parse_hex/1},
      "vendor" => {:vendor, &identity/1},
      "tftp" => {:tftp, &identity/1},
      "bootfile" => {:bootfile, &identity/1},
      "opt77" => {:userclass, &identity/1},
      "tzstr" => {:tzstr, &identity/1},
      "tzdbstr" => {:tzdbstr, &identity/1},
      "search" => {:search, &identity/1},
      "sipsrv" => {:sipsrv, &identity/1},
      "staticroutes" => {:staticroutes, &parse_ip_list/1},
      "vlanid" => {:vlanid, &identity/1},
      "vlanpriority" => {:vlanpriority, &parse_int/1},
      "pxeconffile" => {:pxeconffile, &identity/1},
      "pxepathprefix" => {:pxepathprefix, &identity/1},
      "reboottime" => {:reboottime, &identity/1},
      "ip6rd" => {:ip6rd, &identity/1},
      "msstaticroutes" => {:msstaticroutes, &identity/1},
      "wpad" => {:wpad, &identity/1}
      # opt50 is used to request a client IP and used internally by udhcpc, so skip.
      # opt53 is the message type, so it's not an option
      # opt57 is the max message length, so it's not an option
      # See https://elixir.bootlin.com/busybox/1.35.0/source/networking/udhcp/common.c#L83
    }

    with {:ok, {key, parser}} <- Map.fetch(udhcpc_option_map, k),
         {:ok, result} <- parser.(v) do
      {key, result}
    else
      _error -> {:discard, nil}
    end
  end

  defp summarize_ok_tuples(ok_tuples, results \\ [])
  defp summarize_ok_tuples([], results), do: {:ok, Enum.reverse(results)}
  defp summarize_ok_tuples([{:ok, v} | rest], acc), do: summarize_ok_tuples(rest, [v | acc])
  defp summarize_ok_tuples([{:error, _} = error | _rest], _), do: error

  defp parse_ip_list(str) do
    str
    |> String.split(" ", trim: true)
    |> Enum.map(&IP.ip_to_tuple/1)
    |> summarize_ok_tuples()
  end

  defp parse_int(str) do
    case Integer.parse(str) do
      {v, ""} -> {:ok, v}
      _ -> {:error, "Expecting integer, got #{str}."}
    end
  end

  defp parse_hex(str) do
    case Integer.parse(str, 16) do
      {v, ""} -> {:ok, v}
      _ -> {:error, "Expecting hex, got #{str}."}
    end
  end

  defp identity(str), do: {:ok, str}
end
