# credo:disable-for-this-file
defmodule CucumberMessages.SourceReference do
  @moduledoc false
  defstruct reference: nil, location: nil, __uf__: []

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

      @spec encode!(struct) :: iodata | no_return
      def encode!(msg) do
        [] |> encode_reference(msg) |> encode_location(msg) |> encode_unknown_fields(msg)
      end
    )

    [
      defp encode_reference(acc, msg) do
        case msg.reference do
          nil -> acc
          {:uri, _field_value} -> encode_uri(acc, msg)
          {:java_method, _field_value} -> encode_java_method(acc, msg)
          {:java_stack_trace_element, _field_value} -> encode_java_stack_trace_element(acc, msg)
        end
      end
    ]

    [
      defp encode_uri(acc, msg) do
        try do
          {_, child_field_value} = msg.reference
          [acc, "\n", Protox.Encode.encode_string(child_field_value)]
        rescue
          ArgumentError ->
            reraise Protox.EncodingError.new(:uri, "invalid field value"), __STACKTRACE__
        end
      end,
      defp encode_location(acc, msg) do
        try do
          if msg.location == nil do
            acc
          else
            [acc, "\x12", Protox.Encode.encode_message(msg.location)]
          end
        rescue
          ArgumentError ->
            reraise Protox.EncodingError.new(:location, "invalid field value"), __STACKTRACE__
        end
      end,
      defp encode_java_method(acc, msg) do
        try do
          {_, child_field_value} = msg.reference
          [acc, "\x1A", Protox.Encode.encode_message(child_field_value)]
        rescue
          ArgumentError ->
            reraise Protox.EncodingError.new(:java_method, "invalid field value"), __STACKTRACE__
        end
      end,
      defp encode_java_stack_trace_element(acc, msg) do
        try do
          {_, child_field_value} = msg.reference
          [acc, "\"", Protox.Encode.encode_message(child_field_value)]
        rescue
          ArgumentError ->
            reraise Protox.EncodingError.new(:java_stack_trace_element, "invalid field value"),
                    __STACKTRACE__
        end
      end
    ]

    defp encode_unknown_fields(acc, msg) do
      Enum.reduce(msg.__struct__.unknown_fields(msg), acc, fn {tag, wire_type, bytes}, acc ->
        case wire_type do
          0 ->
            [acc, Protox.Encode.make_key_bytes(tag, :int32), bytes]

          1 ->
            [acc, Protox.Encode.make_key_bytes(tag, :double), bytes]

          2 ->
            len_bytes = bytes |> byte_size() |> Protox.Varint.encode()
            [acc, Protox.Encode.make_key_bytes(tag, :packed), len_bytes, bytes]

          5 ->
            [acc, Protox.Encode.make_key_bytes(tag, :float), bytes]
        end
      end)
    end
  )

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

      (
        @spec decode!(binary) :: struct | no_return
        def decode!(bytes) do
          parse_key_value(bytes, struct(CucumberMessages.SourceReference))
        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 Protox.Decode.parse_key(bytes) do
            {0, _, _} ->
              raise %Protox.IllegalTagError{}

            {1, _, bytes} ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[reference: {:uri, Protox.Decode.validate_string!(delimited)}], rest}

            {2, _, bytes} ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 location:
                   Protox.MergeMessage.merge(
                     msg.location,
                     CucumberMessages.Location.decode!(delimited)
                   )
               ], rest}

            {3, _, bytes} ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 case msg.reference do
                   {:java_method, previous_value} ->
                     {:reference,
                      {:java_method,
                       Protox.MergeMessage.merge(
                         previous_value,
                         CucumberMessages.SourceReference.JavaMethod.decode!(delimited)
                       )}}

                   _ ->
                     {:reference,
                      {:java_method,
                       CucumberMessages.SourceReference.JavaMethod.decode!(delimited)}}
                 end
               ], rest}

            {4, _, bytes} ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 case msg.reference do
                   {:java_stack_trace_element, previous_value} ->
                     {:reference,
                      {:java_stack_trace_element,
                       Protox.MergeMessage.merge(
                         previous_value,
                         CucumberMessages.SourceReference.JavaStackTraceElement.decode!(delimited)
                       )}}

                   _ ->
                     {:reference,
                      {:java_stack_trace_element,
                       CucumberMessages.SourceReference.JavaStackTraceElement.decode!(delimited)}}
                 end
               ], rest}

            {tag, wire_type, rest} ->
              {value, rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)

              {[
                 {msg.__struct__.unknown_fields_name(),
                  [value | msg.__struct__.unknown_fields(msg)]}
               ], rest}
          end

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

    []
  )

  (
    @spec json_decode(iodata(), keyword()) :: {:ok, struct()} | {:error, any()}
    def json_decode(input, opts \\ []) do
      try do
        {:ok, json_decode!(input, opts)}
      rescue
        e in Protox.JsonDecodingError -> {:error, e}
      end
    end

    @spec json_decode!(iodata(), keyword()) :: struct() | no_return()
    def json_decode!(input, opts \\ []) do
      {json_library_wrapper, json_library} = Protox.JsonLibrary.get_library(opts, :decode)

      Protox.JsonDecode.decode!(
        input,
        CucumberMessages.SourceReference,
        &json_library_wrapper.decode!(json_library, &1)
      )
    end

    @spec json_encode(struct(), keyword()) :: {:ok, iodata()} | {:error, any()}
    def json_encode(msg, opts \\ []) do
      try do
        {:ok, json_encode!(msg, opts)}
      rescue
        e in Protox.JsonEncodingError -> {:error, e}
      end
    end

    @spec json_encode!(struct(), keyword()) :: iodata() | no_return()
    def json_encode!(msg, opts \\ []) do
      {json_library_wrapper, json_library} = Protox.JsonLibrary.get_library(opts, :encode)
      Protox.JsonEncode.encode!(msg, &json_library_wrapper.encode!(json_library, &1))
    end
  )

  (
    @deprecated "Use fields_defs()/0 instead"
    @spec defs() :: %{
            required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
          }
    def defs() do
      %{
        1 => {:uri, {:oneof, :reference}, :string},
        2 => {:location, {:scalar, nil}, {:message, CucumberMessages.Location}},
        3 =>
          {:java_method, {:oneof, :reference},
           {:message, CucumberMessages.SourceReference.JavaMethod}},
        4 =>
          {:java_stack_trace_element, {:oneof, :reference},
           {:message, CucumberMessages.SourceReference.JavaStackTraceElement}}
      }
    end

    @deprecated "Use fields_defs()/0 instead"
    @spec defs_by_name() :: %{
            required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
          }
    def defs_by_name() do
      %{
        java_method:
          {3, {:oneof, :reference}, {:message, CucumberMessages.SourceReference.JavaMethod}},
        java_stack_trace_element:
          {4, {:oneof, :reference},
           {:message, CucumberMessages.SourceReference.JavaStackTraceElement}},
        location: {2, {:scalar, nil}, {:message, CucumberMessages.Location}},
        uri: {1, {:oneof, :reference}, :string}
      }
    end
  )

  (
    @spec fields_defs() :: list(Protox.Field.t())
    def fields_defs() do
      [
        %{
          __struct__: Protox.Field,
          json_name: "uri",
          kind: {:oneof, :reference},
          label: :optional,
          name: :uri,
          tag: 1,
          type: :string
        },
        %{
          __struct__: Protox.Field,
          json_name: "location",
          kind: {:scalar, nil},
          label: :optional,
          name: :location,
          tag: 2,
          type: {:message, CucumberMessages.Location}
        },
        %{
          __struct__: Protox.Field,
          json_name: "javaMethod",
          kind: {:oneof, :reference},
          label: :optional,
          name: :java_method,
          tag: 3,
          type: {:message, CucumberMessages.SourceReference.JavaMethod}
        },
        %{
          __struct__: Protox.Field,
          json_name: "javaStackTraceElement",
          kind: {:oneof, :reference},
          label: :optional,
          name: :java_stack_trace_element,
          tag: 4,
          type: {:message, CucumberMessages.SourceReference.JavaStackTraceElement}
        }
      ]
    end

    [
      @spec(field_def(atom) :: {:ok, Protox.Field.t()} | {:error, :no_such_field}),
      (
        def field_def(:uri) do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "uri",
             kind: {:oneof, :reference},
             label: :optional,
             name: :uri,
             tag: 1,
             type: :string
           }}
        end

        def field_def("uri") do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "uri",
             kind: {:oneof, :reference},
             label: :optional,
             name: :uri,
             tag: 1,
             type: :string
           }}
        end

        []
      ),
      (
        def field_def(:location) do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "location",
             kind: {:scalar, nil},
             label: :optional,
             name: :location,
             tag: 2,
             type: {:message, CucumberMessages.Location}
           }}
        end

        def field_def("location") do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "location",
             kind: {:scalar, nil},
             label: :optional,
             name: :location,
             tag: 2,
             type: {:message, CucumberMessages.Location}
           }}
        end

        []
      ),
      (
        def field_def(:java_method) do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "javaMethod",
             kind: {:oneof, :reference},
             label: :optional,
             name: :java_method,
             tag: 3,
             type: {:message, CucumberMessages.SourceReference.JavaMethod}
           }}
        end

        def field_def("javaMethod") do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "javaMethod",
             kind: {:oneof, :reference},
             label: :optional,
             name: :java_method,
             tag: 3,
             type: {:message, CucumberMessages.SourceReference.JavaMethod}
           }}
        end

        def field_def("java_method") do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "javaMethod",
             kind: {:oneof, :reference},
             label: :optional,
             name: :java_method,
             tag: 3,
             type: {:message, CucumberMessages.SourceReference.JavaMethod}
           }}
        end
      ),
      (
        def field_def(:java_stack_trace_element) do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "javaStackTraceElement",
             kind: {:oneof, :reference},
             label: :optional,
             name: :java_stack_trace_element,
             tag: 4,
             type: {:message, CucumberMessages.SourceReference.JavaStackTraceElement}
           }}
        end

        def field_def("javaStackTraceElement") do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "javaStackTraceElement",
             kind: {:oneof, :reference},
             label: :optional,
             name: :java_stack_trace_element,
             tag: 4,
             type: {:message, CucumberMessages.SourceReference.JavaStackTraceElement}
           }}
        end

        def field_def("java_stack_trace_element") do
          {:ok,
           %{
             __struct__: Protox.Field,
             json_name: "javaStackTraceElement",
             kind: {:oneof, :reference},
             label: :optional,
             name: :java_stack_trace_element,
             tag: 4,
             type: {:message, CucumberMessages.SourceReference.JavaStackTraceElement}
           }}
        end
      ),
      def field_def(_) do
        {:error, :no_such_field}
      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, [{unknown_fields_name(), []}])
    end
  )

  (
    @spec required_fields() :: []
    def required_fields() do
      []
    end
  )

  (
    @spec syntax() :: atom()
    def syntax() do
      :proto3
    end
  )

  [
    @spec(default(atom) :: {:ok, boolean | integer | String.t() | float} | {:error, atom}),
    def default(:uri) do
      {:error, :no_default_value}
    end,
    def default(:location) do
      {:ok, nil}
    end,
    def default(:java_method) do
      {:error, :no_default_value}
    end,
    def default(:java_stack_trace_element) do
      {:error, :no_default_value}
    end,
    def default(_) do
      {:error, :no_such_field}
    end
  ]

  (
    @spec file_options() :: struct()
    def file_options() do
      file_options = %{
        __struct__: Protox.Google.Protobuf.FileOptions,
        __uf__: [],
        cc_enable_arenas: nil,
        cc_generic_services: nil,
        csharp_namespace: nil,
        deprecated: nil,
        go_package: "messages",
        java_generate_equals_and_hash: nil,
        java_generic_services: nil,
        java_multiple_files: nil,
        java_outer_classname: nil,
        java_package: nil,
        java_string_check_utf8: nil,
        objc_class_prefix: nil,
        optimize_for: nil,
        php_class_prefix: nil,
        php_generic_services: nil,
        php_metadata_namespace: nil,
        php_namespace: nil,
        py_generic_services: nil,
        ruby_package: nil,
        swift_prefix: nil,
        uninterpreted_option: []
      }

      case function_exported?(Google.Protobuf.FileOptions, :decode!, 1) do
        true ->
          bytes =
            file_options |> Protox.Google.Protobuf.FileOptions.encode!() |> :binary.list_to_bin()

          apply(Google.Protobuf.FileOptions, :decode!, [bytes])

        false ->
          file_options
      end
    end
  )
end