# frozen_string_literal: true

# Copyright (C) 2015-2020 MongoDB Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

module Mongo
  class Error
    # Class for parsing the various forms that errors can come in from MongoDB
    # command responses.
    #
    # The errors can be reported by the server in a number of ways:
    # - {ok:0} response indicates failure. In newer servers, code, codeName
    #   and errmsg fields should be set. In older servers some may not be set.
    # - {ok:1} response with a write concern error (writeConcernError top-level
    #   field). This indicates that the node responding successfully executed
    #   the request, but not enough other nodes successfully executed the
    #   request to satisfy the write concern.
    # - {ok:1} response with writeErrors top-level field. This can be obtained
    #   in a bulk write but also in a non-bulk write. In a non-bulk write
    #   there should be exactly one error in the writeErrors list.
    #   The case of multiple errors is handled by BulkWrite::Result.
    # - {ok:1} response with writeConcernErrors top-level field. This can
    #   only be obtained in a bulk write and is handled by BulkWrite::Result,
    #   not by this class.
    #
    # Note that writeErrors do not have codeName fields - they just provide
    # codes and messages. writeConcernErrors may similarly not provide code
    # names.
    #
    # @since 2.0.0
    # @api private
    class Parser
      include SdamErrorDetection

      # @return [ BSON::Document ] The returned document.
      attr_reader :document

      # @return [ String ] The full error message to be used in the
      #   raised exception.
      attr_reader :message

      # @return [ String ] The server-returned error message
      #   parsed from the response.
      attr_reader :server_message

      # @return [ Array<Protocol::Message> ] The message replies.
      attr_reader :replies

      # @return [ Integer ] The error code parsed from the document.
      # @since 2.6.0
      attr_reader :code

      # @return [ String ] The error code name parsed from the document.
      # @since 2.6.0
      attr_reader :code_name

      # @return [ Array<String> ] The set of labels associated with the error.
      # @since 2.7.0
      attr_reader :labels

      # @api private
      attr_reader :wtimeout

      # Create the new parser with the returned document.
      #
      # @example Create the new parser.
      #   Parser.new({ 'errmsg' => 'failed' })
      #
      # @param [ BSON::Document ] document The returned document.
      # @param [ Array<Protocol::Message> ] replies The message replies.
      # @param [ Hash ] options The options.
      #
      # @since 2.0.0
      def initialize(document, replies = nil, options = nil)
        @document = document || {}
        @replies = replies
        @options = if options
                     options.dup
                   else
                     {}
                   end.freeze
        parse!
      end

      # @return [ true | false ] Whether the document includes a write
      #   concern error. A failure may have a top level error and a write
      #   concern error or either one of the two.
      #
      # @since 2.10.0
      # @api experimental
      def write_concern_error?
        !!write_concern_error_document
      end

      # Returns the write concern error document as it was reported by the
      # server, if any.
      #
      # @return [ Hash | nil ] Write concern error as reported to the server.
      # @api experimental
      def write_concern_error_document
        document['writeConcernError']
      end

      # @return [ Integer | nil ] The error code for the write concern error,
      #   if a write concern error is present and has a code.
      #
      # @since 2.10.0
      # @api experimental
      def write_concern_error_code
        write_concern_error_document && write_concern_error_document['code']
      end

      # @return [ String | nil ] The code name for the write concern error,
      #   if a write concern error is present and has a code name.
      #
      # @since 2.10.0
      # @api experimental
      def write_concern_error_code_name
        write_concern_error_document && write_concern_error_document['codeName']
      end

      # @return [ Array<String> | nil ] The error labels associated with this
      # write concern error, if there is a write concern error present.
      def write_concern_error_labels
        write_concern_error_document && write_concern_error_document['errorLabels']
      end

      class << self
        def build_message(code: nil, code_name: nil, message: nil)
          if code_name && code
            "[#{code}:#{code_name}]: #{message}"
          elsif code_name
            # This surely should never happen, if there's a code name
            # there ought to also be the code provided.
            # Handle this case for completeness.
            "[#{code_name}]: #{message}"
          elsif code
            "[#{code}]: #{message}"
          else
            message
          end
        end
      end

      private

      def parse!
        if document['ok'] != 1 && document['writeErrors']
          raise ArgumentError, 'writeErrors should only be given in successful responses'
        end

        @message = +''
        parse_single(@message, '$err')
        parse_single(@message, 'err')
        parse_single(@message, 'errmsg')
        parse_multiple(@message, 'writeErrors')
        parse_single(@message, 'errmsg', write_concern_error_document) if write_concern_error_document
        parse_flag(@message)
        parse_code
        parse_labels
        parse_wtimeout

        @server_message = @message
        @message = self.class.build_message(
          code: code,
          code_name: code_name,
          message: @message
        )
      end

      def parse_single(message, key, doc = document)
        return unless (error = doc[key])

        append(message, error)
      end

      def parse_multiple(message, key)
        return unless (errors = document[key])

        errors.each do |error|
          parse_single(message, 'errmsg', error)
        end
      end

      def parse_flag(message)
        if replies && replies.first &&
           replies.first.respond_to?(:cursor_not_found?) && replies.first.cursor_not_found?
          append(message, CURSOR_NOT_FOUND)
        end
      end

      def append(message, error)
        if message.length > 1
          message.concat(", #{error}")
        else
          message.concat(error)
        end
      end

      def parse_code
        if document['ok'] == 1
          @code = @code_name = nil
        else
          @code = document['code']
          @code_name = document['codeName']
        end

        # Since there is only room for one code, do not replace
        # codes of the top level response with write concern error codes.
        # In practice this should never be an issue as a write concern
        # can only fail after the operation succeeds on the primary.
        if @code.nil? && @code_name.nil? && (subdoc = write_concern_error_document)
          @code = subdoc['code']
          @code_name = subdoc['codeName']
        end

        return unless @code.nil? && @code_name.nil?
        # If we have writeErrors, and all of their codes are the same,
        # use that code. Otherwise don't set the code
        return unless (write_errors = document['writeErrors'])

        codes = write_errors.map { |e| e['code'] }.compact
        return unless codes.uniq.length == 1

        @code = codes.first
        # code name may not be returned by the server
        @code_name = write_errors.map { |e| e['codeName'] }.compact.first
      end

      def parse_labels
        @labels = document['errorLabels'] || []
      end

      def parse_wtimeout
        @wtimeout = write_concern_error_document &&
                    write_concern_error_document['errInfo'] &&
                    write_concern_error_document['errInfo']['wtimeout']
      end
    end
  end
end
