grizzly

defmodule Grizzly.ZWave.QRCode do
  @moduledoc """
  Z-Wave QR code
  This module handles Z-Wave QR codes that follow Silicon Labs
  Software Design Specification SDS13937 and SDS13944.
  """

  alias Grizzly.ZWave
  alias Grizzly.ZWave.{DSK, Security}
  alias Grizzly.ZWave.SmartStart.MetaExtension.UUID16

  @typedoc "QR Code version (S2-only or Smart Start-enabled)"
  @type version() :: :s2 | :smart_start

  @typedoc """
  Device information
  * `:zwave_device_type` - either {generic_device_type, specific_device_type} or a number
  """
  @type t() :: %__MODULE__{
          version: version(),
          requested_keys: [ZWave.Security.key()],
          dsk: ZWave.DSK.t(),
          zwave_device_type: {atom(), atom()} | 0..65535,
          zwave_installer_icon: ZWave.IconType.name() | ZWave.IconType.value(),
          manufacturer_id: 0..65535,
          product_type: 0..65535,
          product_id: 0..65535,
          application_version: {byte(), byte()} | nil,
          uuid16: nil | UUID16.t(),
          supported_protocols: any()
        }

  defstruct version: :smart_start,
            requested_keys: [],
            dsk: ZWave.DSK.zeros(),
            zwave_device_type: 0,
            zwave_installer_icon: 0,
            manufacturer_id: 0,
            product_type: 0,
            product_id: 0,
            application_version: nil,
            uuid16: nil,
            supported_protocols: []

  @lead_in "90"

  @spec decode(<<_::16, _::_*8>>) :: {:ok, t()} | {:error, :invalid_dsk}
  def decode(@lead_in <> binary) do
    {version, binary} = String.split_at(binary, 2)
    {_checksum, binary} = String.split_at(binary, 5)
    {requested_keys, binary} = String.split_at(binary, 3)
    {dsk, binary} = String.split_at(binary, 40)

    requested_keys = requested_keys |> String.to_integer() |> Security.byte_to_keys()

    case DSK.parse(dsk) do
      {:ok, dsk} ->
        tlv = decode_tlv(binary)

        app_version =
          if is_list(tlv[:product_id]) do
            {tlv[:product_id][:app_version], tlv[:product_id][:app_sub_version]}
          else
            nil
          end

        {:ok,
         %__MODULE__{
           version: decode_version(version),
           requested_keys: requested_keys,
           dsk: dsk,
           zwave_device_type:
             {tlv[:product_type][:generic_device_class],
              tlv[:product_type][:specific_device_class]},
           zwave_installer_icon: tlv[:product_type][:installer_icon],
           manufacturer_id: tlv[:product_id][:manufacturer_id],
           product_type: tlv[:product_id][:product_type],
           product_id: tlv[:product_id][:product_id],
           application_version: app_version,
           uuid16: tlv[:uuid_16],
           supported_protocols: tlv[:supported_protocols] || []
         }}

      {:error, _} ->
        {:error, :invalid_dsk}
    end
  end

  defp decode_tlv(binary, acc \\ [])
  defp decode_tlv("", acc), do: acc

  defp decode_tlv(binary, acc) do
    {tag_critical, binary} = String.split_at(binary, 2)
    <<tag::7, _critical::1>> = <<String.to_integer(tag_critical)::8>>

    # critical = if(critical == 1, do: true, else: false)
    {length, binary} = String.split_at(binary, 2)
    length = String.to_integer(length)
    {value, binary} = String.split_at(binary, length)

    tag = decode_tag(tag)

    decode_tlv(binary, [{tag, decode_value(tag, value)} | acc])
  end

  defp decode_tag(0x00), do: :product_type
  defp decode_tag(0x01), do: :product_id
  defp decode_tag(0x02), do: :max_inclusion_request_interval
  defp decode_tag(0x03), do: :uuid_16
  defp decode_tag(0x04), do: :supported_protocols
  defp decode_tag(0x32), do: :name
  defp decode_tag(0x33), do: :location
  defp decode_tag(0x34), do: :smartstart_inclusion_setting
  defp decode_tag(0x35), do: :advanced_joinin
  defp decode_tag(0x36), do: :bootstrapping_mode
  defp decode_tag(0x37), do: :network_status

  defp decode_value(:product_type, value) do
    {classes, installer_icon} = String.split_at(value, 5)
    <<generic::8, specific::8>> = <<String.to_integer(classes)::16>>
    installer_icon = String.to_integer(installer_icon)

    {:ok, generic_device_class} = ZWave.DeviceClasses.generic_device_class_from_byte(generic)

    {:ok, specific_device_class} =
      ZWave.DeviceClasses.specific_device_class_from_byte(
        generic_device_class,
        specific
      )

    {:ok, installer_icon} = ZWave.IconType.to_name(installer_icon)

    %{
      generic_device_class: generic_device_class,
      specific_device_class: specific_device_class,
      installer_icon: installer_icon
    }
  end

  defp decode_value(:product_id, value) do
    [manufacturer_id, product_type, product_id, vsn] =
      value
      |> String.to_charlist()
      |> Enum.chunk_every(5)
      |> Enum.map(&String.to_integer(to_string(&1)))

    <<app_version::8, app_sub_version::8>> = <<vsn::16>>

    [
      manufacturer_id: manufacturer_id,
      product_type: product_type,
      product_id: product_id,
      app_version: app_version,
      app_sub_version: app_sub_version
    ]
  end

  defp decode_value(:uuid_16, value) do
    <<_presentation::2-bytes, decimalized_uuid::binary>> = value

    ints =
      decimalized_uuid
      |> String.to_charlist()
      |> Enum.chunk_every(5)
      |> Enum.map(&String.to_integer(to_string(&1)))

    uuid_string =
      for int <- ints, into: <<>> do
        <<int::16>>
      end

    {:ok, uuid} = Base.encode16(uuid_string) |> UUID16.new(:hex)

    uuid
  end

  defp decode_value(:supported_protocols, value) do
    {int_val, ""} = Integer.parse(value)

    <<_reserved::6, zwave_lr::1, zwave::1, _rest::binary>> = <<int_val>>
    protocols = if(zwave_lr == 1, do: [:zwave_lr], else: [])
    if(zwave == 1, do: [:zwave | protocols], else: protocols)
  end

  defp decode_value(_, value), do: value

  @doc """
  Encode device information into Z-Wave QR Code format
  The output of this is either a 90 byte or 136 byte string that should be put
  into a QR Code. Z-Wave specifies that the 90-byte code (no UUID16) is made
  into a 29x29 pixel QR Code. The 136-byte* code (w/ UUID16) should be put into
  a 33x33 pixel QR Code.
  QR Codes should be encoded as type "text" with error correction "L".
  NOTE: SDS13937 has a mistake with the code length. It says 134 bytes, but the
  UUID16 encode has 2 extra bytes for presentation, so it should be 136.
  """
  @spec encode!(t()) :: iolist()
  def encode!(info) do
    payload = [
      encode_requested_keys(info.requested_keys),
      encode_dsk(info),
      encode_qr_product_type(info),
      encode_qr_product_id(info),
      encode_uuid16(info.uuid16)
    ]

    [@lead_in, encode_version(info.version), checksum(payload), payload]
  end

  defp checksum(payload) do
    <<two_bytes::16, _rest::144>> = :crypto.hash(:sha, payload)
    int_to_string(two_bytes, 5)
  end

  defp encode_version(:s2), do: "00"
  defp encode_version(:smart_start), do: "01"

  defp decode_version("00"), do: :s2
  defp decode_version("01"), do: :smart_start

  defp encode_requested_keys(requested_keys) do
    ZWave.Security.keys_to_byte(requested_keys)
    |> int_to_string(3)
  end

  defp encode_dsk(info), do: ZWave.DSK.to_string(info.dsk, delimiter: "")

  defp encode_qr_product_type(info) do
    # QR Product type = TLV type 00, length 10
    [
      "0010",
      encode_device_type(info.zwave_device_type),
      encode_icon_type(info.zwave_installer_icon)
    ]
  end

  defp encode_device_type({generic, specific}) do
    device_type =
      ZWave.DeviceClasses.generic_device_class_to_byte(generic) * 256 +
        ZWave.DeviceClasses.specific_device_class_to_byte(generic, specific)

    encode_device_type(device_type)
  end

  defp encode_device_type(device_type) when is_integer(device_type) do
    int_to_string(device_type, 5)
  end

  defp encode_icon_type(type) when is_atom(type) do
    {:ok, value} = ZWave.IconType.to_value(type)
    encode_icon_type(value)
  end

  defp encode_icon_type(type), do: int_to_string(type, 5)

  defp encode_qr_product_id(info) do
    app_version =
      cond do
        is_tuple(info.application_version) && tuple_size(info.application_version) == 2 ->
          {app_version, app_sub_version} = info.application_version
          <<vsn::16>> = <<app_version, app_sub_version>>
          int_to_string(vsn, 5)

        is_integer(info.application_version) ->
          int_to_string(info.application_version, 5)

        true ->
          int_to_string(0, 5)
      end

    # QR Product ID = TLV type 02, length 20
    [
      "0220",
      int_to_string(info.manufacturer_id, 5),
      int_to_string(info.product_type, 5),
      int_to_string(info.product_id, 5),
      app_version
    ]
  end

  defp encode_uuid16(nil), do: []

  defp encode_uuid16(uuid16) do
    value = UUID16.encode(uuid16)
    <<0x06, 0x11, presentation, uuid::binary>> = value

    decimalized_uuid =
      uuid
      |> ZWave.DSK.new()
      |> ZWave.DSK.to_string(delimiter: "")

    # UUID16 = TLV type 06, length 42
    ["0642", int_to_string(presentation, 2), decimalized_uuid]
  end

  defp int_to_string(value, num_digits) when value >= 0 do
    value
    |> Integer.to_string(10)
    |> String.pad_leading(num_digits, "0")
  end
end