# Code generated by protox. Don't edit.
# credo:disable-for-this-file
defmodule PgQuery.SummaryResult do
  @moduledoc false
  if function_exported?(Protox, :check_generator_version, 1) do
    Protox.check_generator_version(1)
  else
    raise "This code was generated with protox 2 but the runtime is using an older version of protox."
  end

  @type t :: %__MODULE__{
          truncated_query: String.t(),
          statement_types: [String.t()],
          filter_columns: [PgQuery.SummaryResult.FilterColumn.t()],
          functions: [PgQuery.SummaryResult.Function.t()],
          cte_names: [String.t()],
          aliases: %{String.t() => String.t()},
          tables: [PgQuery.SummaryResult.Table.t()],
          __uf__: [{non_neg_integer(), Protox.Types.tag(), binary()}]
        }
  defstruct truncated_query: "",
            statement_types: [],
            filter_columns: [],
            functions: [],
            cte_names: [],
            aliases: %{},
            tables: [],
            __uf__: []

  (
    (
      @spec encode(t()) :: {:ok, iodata(), non_neg_integer()} | {:error, any()}
      def encode(msg) do
        msg |> encode!() |> Tuple.insert_at(0, :ok)
      rescue
        e in [Protox.EncodingError, Protox.RequiredFieldsError] -> {:error, e}
      end

      @spec encode!(t()) :: {iodata(), non_neg_integer()} | no_return()
      def encode!(msg) do
        {_acc = [], _acc_size = 0}
        |> encode_truncated_query(msg)
        |> encode_statement_types(msg)
        |> encode_filter_columns(msg)
        |> encode_functions(msg)
        |> encode_cte_names(msg)
        |> encode_aliases(msg)
        |> encode_tables(msg)
        |> encode_unknown_fields(msg)
      end
    )

    defp encode_truncated_query({acc, acc_size}, msg) do
      if msg.truncated_query == "" do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_string(msg.truncated_query)
        {[":", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:truncated_query, "invalid field value"), __STACKTRACE__
    end

    defp encode_statement_types({acc, acc_size}, msg) do
      case msg.statement_types do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_string(value)
                  {[value_bytes, "2" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:statement_types, "invalid field value"), __STACKTRACE__
    end

    defp encode_filter_columns({acc, acc_size}, msg) do
      case msg.filter_columns do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "*" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:filter_columns, "invalid field value"), __STACKTRACE__
    end

    defp encode_functions({acc, acc_size}, msg) do
      case msg.functions do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "\"" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:functions, "invalid field value"), __STACKTRACE__
    end

    defp encode_cte_names({acc, acc_size}, msg) do
      case msg.cte_names do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_string(value)
                  {[value_bytes, "\x1A" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:cte_names, "invalid field value"), __STACKTRACE__
    end

    defp encode_aliases({acc, acc_size}, msg) do
      map = Map.fetch!(msg, :aliases)

      if map_size(map) == 0 do
        {acc, acc_size}
      else
        Enum.reduce(map, {acc, acc_size}, fn {k, v}, {acc, acc_size} ->
          {k_value_bytes, k_value_len} = Protox.Encode.encode_string(k)
          {v_value_bytes, v_value_len} = Protox.Encode.encode_string(v)
          len = 2 + k_value_len + v_value_len
          {len_varint, len_varint_size} = Protox.Varint.encode(len)
          acc = [<<"\x12", len_varint::binary, "\n">>, k_value_bytes, "\x12", v_value_bytes | acc]
          {acc, acc_size + 3 + k_value_len + v_value_len + len_varint_size}
        end)
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:aliases, "invalid field value"), __STACKTRACE__
    end

    defp encode_tables({acc, acc_size}, msg) do
      case msg.tables do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "\n" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:tables, "invalid field value"), __STACKTRACE__
    end

    defp encode_unknown_fields({acc, acc_size}, msg) do
      Enum.reduce(msg.__uf__, {acc, acc_size}, fn {tag, wire_type, bytes}, {acc, acc_size} ->
        case wire_type do
          0 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :int32)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}

          1 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :double)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}

          2 ->
            {len_bytes, len_size} = bytes |> byte_size() |> Protox.Varint.encode()
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :packed)

            {[acc, <<key_bytes::binary, len_bytes::binary, bytes::binary>>],
             acc_size + key_size + len_size + byte_size(bytes)}

          5 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :float)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}
        end
      end)
    end
  )

  (
    (
      @spec decode(binary()) :: {:ok, t()} | {:error, any()}
      def decode(bytes) do
        {:ok, decode!(bytes)}
      rescue
        e in [Protox.DecodingError, Protox.IllegalTagError, Protox.RequiredFieldsError] ->
          {:error, e}
      end

      (
        @spec decode!(binary()) :: t() | no_return()
        def decode!(bytes) do
          parse_key_value(bytes, struct(PgQuery.SummaryResult))
        end
      )
    )

    (
      @spec parse_key_value(binary(), struct()) :: struct()
      defp parse_key_value(<<>>, msg) do
        msg
      end

      defp parse_key_value(bytes, msg) do
        {field, rest} =
          case bytes do
            <<_::5, 3::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 3")

            <<_::5, 4::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 4")

            <<_::5, 6::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 6")

            <<_::5, 7::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 7")

            <<0::5, _::3, _rest::binary>> ->
              raise %Protox.IllegalTagError{}

            <<7::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[truncated_query: Protox.Decode.validate_string!(delimited)], rest}

            <<6::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 statement_types:
                   msg.statement_types ++ [Protox.Decode.validate_string!(delimited)]
               ], rest}

            <<5::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 filter_columns:
                   msg.filter_columns ++ [PgQuery.SummaryResult.FilterColumn.decode!(delimited)]
               ], rest}

            <<4::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[functions: msg.functions ++ [PgQuery.SummaryResult.Function.decode!(delimited)]],
               rest}

            <<3::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[cte_names: msg.cte_names ++ [Protox.Decode.validate_string!(delimited)]], rest}

            <<2::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 (
                   {entry_key, entry_value} =
                     (
                       {map_key, map_value} = parse_string_string({:unset, :unset}, delimited)

                       map_key =
                         case map_key do
                           :unset -> Protox.Default.default(:string)
                           _ -> map_key
                         end

                       map_value =
                         case map_value do
                           :unset -> Protox.Default.default(:string)
                           _ -> map_value
                         end

                       {map_key, map_value}
                     )

                   {:aliases, Map.put(msg.aliases, entry_key, entry_value)}
                 )
               ], rest}

            <<1::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[tables: msg.tables ++ [PgQuery.SummaryResult.Table.decode!(delimited)]], rest}

            <<bytes::binary>> ->
              {tag, wire_type, rest} = Protox.Decode.parse_key(bytes)
              {value, rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
              {[__uf__: msg.__uf__ ++ [value]], rest}
          end

        msg_updated = struct(msg, field)
        parse_key_value(rest, msg_updated)
      end
    )

    (
      defp parse_string_string(map_entry, <<>>) do
        map_entry
      end

      defp parse_string_string({entry_key, entry_value}, bytes) do
        {map_entry, rest} =
          case Protox.Decode.parse_key(bytes) do
            {1, _, rest} ->
              {res, rest} =
                (
                  {len, new_rest} = Protox.Varint.decode(rest)
                  {delimited, new_rest} = Protox.Decode.parse_delimited(new_rest, len)
                  {Protox.Decode.validate_string!(delimited), new_rest}
                )

              {{res, entry_value}, rest}

            {2, _, rest} ->
              {res, rest} =
                (
                  {len, new_rest} = Protox.Varint.decode(rest)
                  {delimited, new_rest} = Protox.Decode.parse_delimited(new_rest, len)
                  {Protox.Decode.validate_string!(delimited), new_rest}
                )

              {{entry_key, res}, rest}

            {tag, wire_type, rest} ->
              {_, rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
              {{entry_key, entry_value}, rest}
          end

        parse_string_string(map_entry, rest)
      end
    )
  )

  (
    @spec unknown_fields(struct()) :: [{non_neg_integer(), Protox.Types.tag(), binary()}]
    def unknown_fields(msg) do
      msg.__uf__
    end

    @spec unknown_fields_name() :: :__uf__
    def unknown_fields_name() do
      :__uf__
    end

    @spec clear_unknown_fields(struct) :: struct
    def clear_unknown_fields(msg) do
      struct!(msg, __uf__: [])
    end
  )

  (
    @spec default(atom()) ::
            {:ok, boolean() | integer() | String.t() | float()}
            | {:error, :no_such_field | :no_default_value}
    def default(:truncated_query) do
      {:ok, ""}
    end

    def default(:statement_types) do
      {:error, :no_default_value}
    end

    def default(:filter_columns) do
      {:error, :no_default_value}
    end

    def default(:functions) do
      {:error, :no_default_value}
    end

    def default(:cte_names) do
      {:error, :no_default_value}
    end

    def default(:aliases) do
      {:error, :no_default_value}
    end

    def default(:tables) do
      {:error, :no_default_value}
    end

    def default(_) do
      {:error, :no_such_field}
    end
  )

  @spec schema() :: Protox.MessageSchema.t()
  def schema() do
    %{
      __struct__: Protox.MessageSchema,
      fields: %{
        aliases: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :map,
          label: nil,
          name: :aliases,
          tag: 2,
          type: {:string, :string}
        },
        cte_names: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :cte_names,
          tag: 3,
          type: :string
        },
        filter_columns: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :filter_columns,
          tag: 5,
          type: {:message, PgQuery.SummaryResult.FilterColumn}
        },
        functions: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :functions,
          tag: 4,
          type: {:message, PgQuery.SummaryResult.Function}
        },
        statement_types: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :statement_types,
          tag: 6,
          type: :string
        },
        tables: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :tables,
          tag: 1,
          type: {:message, PgQuery.SummaryResult.Table}
        },
        truncated_query: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :truncated_query,
          tag: 7,
          type: :string
        }
      },
      file_options: nil,
      name: PgQuery.SummaryResult,
      syntax: :proto3
    }
  end
end