# Code generated by protox. Don't edit.
# credo:disable-for-this-file
defmodule PgQuery.RenameStmt 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__{
          missing_ok: boolean(),
          behavior: atom(),
          newname: String.t(),
          subname: String.t(),
          object: PgQuery.Node.t() | nil,
          relation: PgQuery.RangeVar.t() | nil,
          relation_type: atom(),
          rename_type: atom(),
          __uf__: [{non_neg_integer(), Protox.Types.tag(), binary()}]
        }
  defstruct missing_ok: false,
            behavior: :DROP_BEHAVIOR_UNDEFINED,
            newname: "",
            subname: "",
            object: nil,
            relation: nil,
            relation_type: :OBJECT_TYPE_UNDEFINED,
            rename_type: :OBJECT_TYPE_UNDEFINED,
            __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_missing_ok(msg)
        |> encode_behavior(msg)
        |> encode_newname(msg)
        |> encode_subname(msg)
        |> encode_object(msg)
        |> encode_relation(msg)
        |> encode_relation_type(msg)
        |> encode_rename_type(msg)
        |> encode_unknown_fields(msg)
      end
    )

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

    defp encode_behavior({acc, acc_size}, msg) do
      if msg.behavior == :DROP_BEHAVIOR_UNDEFINED do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} =
          msg.behavior |> PgQuery.DropBehavior.encode() |> Protox.Encode.encode_enum()

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

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

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

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

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

    defp encode_relation_type({acc, acc_size}, msg) do
      if msg.relation_type == :OBJECT_TYPE_UNDEFINED do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} =
          msg.relation_type |> PgQuery.ObjectType.encode() |> Protox.Encode.encode_enum()

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

    defp encode_rename_type({acc, acc_size}, msg) do
      if msg.rename_type == :OBJECT_TYPE_UNDEFINED do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} =
          msg.rename_type |> PgQuery.ObjectType.encode() |> Protox.Encode.encode_enum()

        {["\b", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:rename_type, "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.RenameStmt))
        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{}

            <<8::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_bool(bytes)
              {[missing_ok: value], rest}

            <<7::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_enum(bytes, PgQuery.DropBehavior)
              {[behavior: value], rest}

            <<6::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[newname: 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)
              {[subname: Protox.Decode.validate_string!(delimited)], rest}

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

              {[object: Protox.MergeMessage.merge(msg.object, PgQuery.Node.decode!(delimited))],
               rest}

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

              {[
                 relation:
                   Protox.MergeMessage.merge(msg.relation, PgQuery.RangeVar.decode!(delimited))
               ], rest}

            <<2::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_enum(bytes, PgQuery.ObjectType)
              {[relation_type: value], rest}

            <<1::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_enum(bytes, PgQuery.ObjectType)
              {[rename_type: value], 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
    )
  )

  (
    @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(:missing_ok) do
      {:ok, false}
    end

    def default(:behavior) do
      {:ok, :DROP_BEHAVIOR_UNDEFINED}
    end

    def default(:newname) do
      {:ok, ""}
    end

    def default(:subname) do
      {:ok, ""}
    end

    def default(:object) do
      {:ok, nil}
    end

    def default(:relation) do
      {:ok, nil}
    end

    def default(:relation_type) do
      {:ok, :OBJECT_TYPE_UNDEFINED}
    end

    def default(:rename_type) do
      {:ok, :OBJECT_TYPE_UNDEFINED}
    end

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

  @spec schema() :: Protox.MessageSchema.t()
  def schema() do
    %{
      __struct__: Protox.MessageSchema,
      fields: %{
        behavior: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: :DROP_BEHAVIOR_UNDEFINED},
          label: :optional,
          name: :behavior,
          tag: 7,
          type: {:enum, PgQuery.DropBehavior}
        },
        missing_ok: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :missing_ok,
          tag: 8,
          type: :bool
        },
        newname: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :newname,
          tag: 6,
          type: :string
        },
        object: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :object,
          tag: 4,
          type: {:message, PgQuery.Node}
        },
        relation: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :relation,
          tag: 3,
          type: {:message, PgQuery.RangeVar}
        },
        relation_type: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: :OBJECT_TYPE_UNDEFINED},
          label: :optional,
          name: :relation_type,
          tag: 2,
          type: {:enum, PgQuery.ObjectType}
        },
        rename_type: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: :OBJECT_TYPE_UNDEFINED},
          label: :optional,
          name: :rename_type,
          tag: 1,
          type: {:enum, PgQuery.ObjectType}
        },
        subname: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :subname,
          tag: 5,
          type: :string
        }
      },
      file_options: nil,
      name: PgQuery.RenameStmt,
      syntax: :proto3
    }
  end
end