smppex

defmodule SMPPEX.Protocol do
  @moduledoc false

  alias SMPPEX.Protocol.CommandNames
  alias SMPPEX.Protocol.MandatoryFieldsSpecs
  alias SMPPEX.Protocol.MandatoryFieldsParser
  alias SMPPEX.Protocol.OptionalFieldsParser
  alias SMPPEX.Protocol.MandatoryFieldsBuilder
  alias SMPPEX.Protocol.OptionalFieldsBuilder
  alias SMPPEX.RawPdu
  alias SMPPEX.Pdu

  @type error :: any
  @type pdu_parse_result :: {:pdu, Pdu.t()} | {:unparsed_pdu, RawPdu.t(), error}
  @type parse_result :: {:ok, nil, binary} | {:ok, pdu_parse_result, binary} | {:error, error}

  @spec parse(binary) :: parse_result

  def parse(bin) when byte_size(bin) < 4 do
    {:ok, nil, bin}
  end

  def parse(bin) do
    <<command_length::big-unsigned-integer-size(32), rest::binary>> = bin

    cond do
      command_length < 16 ->
        {:error, "Invalid PDU command_length #{inspect(command_length)}"}

      command_length <= byte_size(bin) ->
        body_length = command_length - 16
        <<header::binary-size(12), body::binary-size(body_length), next_pdus::binary>> = rest
        {:ok, parse_pdu(header, body), next_pdus}

      true ->
        {:ok, nil, bin}
    end
  end

  defp parse_pdu(header, body) do
    header = parse_header(header)
    raw_pdu = RawPdu.new(header, body)

    case CommandNames.name_by_id(RawPdu.command_id(raw_pdu)) do
      {:ok, name} -> parse_body_if_needed(name, raw_pdu)
      :unknown -> {:unparsed_pdu, raw_pdu, "Unknown command_id"}
    end
  end

  defp parse_header(<<
         command_id::big-unsigned-integer-size(32),
         command_status::big-unsigned-integer-size(32),
         sequence_number::big-unsigned-integer-size(32)
       >>) do
    {command_id, command_status, sequence_number}
  end

  defp parse_body_if_needed(name, raw_pdu) do
    case parse_body(name, raw_pdu) do
      {:pdu, _} = pdu ->
        pdu

      {:unparsed_pdu, _, _} = unparsed_pdu ->
        if parse_body?(raw_pdu) do
          unparsed_pdu
        else
          {:pdu, Pdu.new(RawPdu.header(raw_pdu), %{}, %{})}
        end
    end
  end

  defp parse_body(command_name, raw_pdu) do
    case parse_mandatory_fields(command_name, raw_pdu) do
      {:ok, fields, rest} ->
        case OptionalFieldsParser.parse(rest) do
          {:ok, tlvs} ->
            {:pdu, Pdu.new(RawPdu.header(raw_pdu), fields, tlvs)}

          {:error, error} ->
            {:unparsed_pdu, raw_pdu, error}
        end

      {:error, error} ->
        {:unparsed_pdu, raw_pdu, error}
    end
  end

  defp parse_body?(raw_pdu) do
    !RawPdu.resp?(raw_pdu) || RawPdu.success_resp?(raw_pdu)
  end

  defp parse_mandatory_fields(command_name, raw_pdu) do
    spec = MandatoryFieldsSpecs.spec_for(command_name)
    raw_pdu |> RawPdu.body() |> MandatoryFieldsParser.parse(spec)
  end

  @type build_result :: {:ok, binary} | {:error, error}

  @spec build(Pdu.t()) :: build_result

  def build(pdu) do
    case build_header(pdu) do
      {:ok, mandatory_specs, header_bin} -> build_body(pdu, header_bin, mandatory_specs)
      {:error, error} -> {:error, {"Error building header part", error}}
    end
  end

  defp build_body(pdu, header_bin, mandatory_specs) do
    if build_body?(pdu) do
      case build_mandatory_fields(pdu, mandatory_specs) do
        {:ok, mandatory_bin} ->
          case build_optional_fields(pdu) do
            {:ok, optional_bin} ->
              {:ok, concat_pdu_binary_parts(header_bin, mandatory_bin, optional_bin)}

            {:error, error} ->
              {:error, {"Error building optional field part", error}}
          end

        {:error, error} ->
          {:error, {"Error building mandatory field part", error}}
      end
    else
      {:ok, concat_pdu_binary_parts(header_bin, "", "")}
    end
  end

  defp build_header(pdu) do
    {command_id, command_status, sequence_number} = {
      Pdu.command_id(pdu),
      Pdu.command_status(pdu),
      Pdu.sequence_number(pdu)
    }

    case CommandNames.name_by_id(command_id) do
      {:ok, name} ->
        {:ok, MandatoryFieldsSpecs.spec_for(name),
         <<
           command_id::big-unsigned-integer-size(32),
           command_status::big-unsigned-integer-size(32),
           sequence_number::big-unsigned-integer-size(32)
         >>}

      :unknown ->
        {:error, "Unknown command_id #{inspect(command_id)}"}
    end
  end

  defp build_body?(pdu) do
    !Pdu.resp?(pdu) || Pdu.success_resp?(pdu)
  end

  defp build_mandatory_fields(pdu, specs) do
    pdu |> Pdu.mandatory_fields() |> MandatoryFieldsBuilder.build(specs)
  end

  defp build_optional_fields(pdu) do
    pdu |> Pdu.optional_fields() |> OptionalFieldsBuilder.build()
  end

  defp concat_pdu_binary_parts(header, mandatory, optional) do
    pdu_data = [header, mandatory, optional] |> List.flatten() |> Enum.join()
    size = byte_size(pdu_data) + 4
    <<size::big-unsigned-integer-size(32), pdu_data::binary>>
  end
end