#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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 Qpid

  module Proton

    # A Message represents an addressable quantity of data.
    #
    # ==== Examples
    #
    class Message

      # Decodes a message from supplied AMQP data and returns the number
      # of bytes consumed.
      #
      # ==== Options
      #
      # * encoded - the encoded data
      #
      def decode(encoded)
        check(Cproton.pn_message_decode(@impl, encoded, encoded.length))

        post_decode
      end

      def post_decode # :nodoc:
        # decode elements from the message
        @properties = {}
        props = Qpid::Proton::Data.new(Cproton::pn_message_properties(@impl))
        if props.next
          @properties = props.type.get(props)
        end
        @instructions = nil
        insts = Qpid::Proton::Data.new(Cproton::pn_message_instructions(@impl))
        if insts.next
          @instructions = insts.type.get(insts)
        end
        @annotations = nil
        annts = Qpid::Proton::Data.new(Cproton::pn_message_annotations(@impl))
        if annts.next
          @annotations = annts.type.get(annts)
        end
        @body = nil
        body = Qpid::Proton::Data.new(Cproton::pn_message_body(@impl))
        if body.next
          @body = body.type.get(body)
        end
      end

      # Encodes the message.
      def encode
        pre_encode
        size = 16
        loop do
          error, data = Cproton::pn_message_encode(@impl, size)
          if error == Qpid::Proton::Error::OVERFLOW
            size *= 2
          else
            check(error)
            return data
          end
        end
      end

      def pre_encode # :nodoc:
        # encode elements from the message
        props = Qpid::Proton::Data.new(Cproton::pn_message_properties(@impl))
        props.clear
        Qpid::Proton::Mapping.for_class(@properties.class).put(props, @properties) unless @properties.empty?
        insts = Qpid::Proton::Data.new(Cproton::pn_message_instructions(@impl))
        insts.clear
        if !@instructions.nil?
          mapping = Qpid::Proton::Mapping.for_class(@instructions.class)
          mapping.put(insts, @instructions)
        end
        annts = Qpid::Proton::Data.new(Cproton::pn_message_annotations(@impl))
        annts.clear
        if !@annotations.nil?
          mapping = Qpid::Proton::Mapping.for_class(@annotations.class)
          mapping.put(annts, @annotations)
        end
        body = Qpid::Proton::Data.new(Cproton::pn_message_body(@impl))
        body.clear
        if !@body.nil?
          mapping = Qpid::Proton::Mapping.for_class(@body.class)
          mapping.put(body, @body)
        end
      end

      # Creates a new +Message+ instance.
      def initialize
        @impl = Cproton.pn_message
        ObjectSpace.define_finalizer(self, self.class.finalize!(@impl))
        @properties = {}
        @instructions = {}
        @annotations = {}
        @body = nil
      end

      def to_s
        tmp = Cproton.pn_string("")
        Cproton.pn_inspect(@impl, tmp)
        result = Cproton.pn_string_get(tmp)
        Cproton.pn_free(tmp)
        return result
      end

      # Invoked by garbage collection to clean up resources used
      # by the underlying message implementation.
      def self.finalize!(impl) # :nodoc:
        proc {
          Cproton.pn_message_free(impl)
        }
      end

      # Returns the underlying message implementation.
      def impl # :nodoc:
        @impl
      end

      # Clears the state of the +Message+. This allows a single instance of
      # +Message+ to be reused.
      #
      def clear
        Cproton.pn_message_clear(@impl)
        @properties.clear unless @properties.nil?
        @instructions.clear unless @instructions.nil?
        @annotations.clear unless @annotations.nil?
        @body = nil
      end

      # Returns the most recent error number.
      #
      def errno
        Cproton.pn_message_errno(@impl)
      end

      # Returns the most recent error message.
      #
      def error
        Cproton.pn_error_text(Cproton.pn_message_error(@impl))
      end

      # Returns whether there is currently an error reported.
      #
      def error?
        !Cproton.pn_message_errno(@impl).zero?
      end

      # Sets the durable flag.
      #
      # See ::durable for more details on message durability.
      #
      # ==== Options
      #
      # * state - the durable state
      #
      def durable=(state)
        raise TypeError.new("state cannot be nil") if state.nil?
        Cproton.pn_message_set_durable(@impl, state)
      end

      # Returns the durable property.
      #
      # The durable property indicates that the emessage should be held durably
      # by any intermediaries taking responsibility for the message.
      #
      # ==== Examples
      #
      #  msg = Qpid::Proton::Message.new
      #  msg.durable = true
      #
      def durable
        Cproton.pn_message_is_durable(@impl)
      end

      # Sets the priority.
      #
      # +NOTE:+ Priority values are limited to the range [0,255].
      #
      # ==== Options
      #
      # * priority - the priority value
      #
      def priority=(priority)
        raise TypeError.new("invalid priority: #{priority}") if priority.nil? || !([Float, Fixnum].include?(priority.class))
        raise RangeError.new("priority out of range: #{priority}") if ((priority > 255) || (priority < 0))
        Cproton.pn_message_set_priority(@impl, priority.floor)
      end

      # Returns the priority.
      #
      def priority
        Cproton.pn_message_get_priority(@impl)
      end

      # Sets the time-to-live for the message.
      #
      # ==== Options
      #
      # * time - the time in milliseconds
      #
      def ttl=(time)
        raise TypeError.new("invalid ttl: #{time}") if time.nil? || !([Float, Fixnum].include?(time.class))
        raise RangeError.new("time out of range: #{time}") if ((time < 0))
        Cproton.pn_message_set_ttl(@impl, time.floor)
      end

      # Returns the time-to-live, in milliseconds.
      #
      def ttl
        Cproton.pn_message_get_ttl(@impl)
      end

      # Sets whether this is the first time the message was acquired.
      #
      # See ::first_acquirer? for more details.
      #
      # ==== Options
      #
      # * state - true if claiming the message
      #
      def first_acquirer=(state)
        raise TypeError.new("invalid state: #{state}") if state.nil? || !([TrueClass, FalseClass].include?(state.class))
        Cproton.pn_message_set_first_acquirer(@impl, state)
      end

      # Sets the delivery count for the message.
      #
      # See ::delivery_count for more details.
      #
      # ==== Options
      #
      # * count - the delivery count
      #
      def delivery_count=(count)
        raise ArgumentError.new("invalid count: #{count}") if count.nil? || !([Float, Fixnum].include?(count.class))
        raise RangeError.new("count out of range: #{count}") if count < 0

        Cproton.pn_message_set_delivery_count(@impl, count.floor)
      end

      # Returns the delivery count for the message.
      #
      # This is the number of delivery attempts for the given message.
      #
      def delivery_count
        Cproton.pn_message_get_delivery_count(@impl)
      end

      # Returns whether this is the first acquirer.
      #
      #
      def first_acquirer?
        Cproton.pn_message_is_first_acquirer(@impl)
      end

      # Sets the message id.
      #
      # ==== Options
      #
      # * id = the id
      #
      def id=(id)
        Cproton.pn_message_set_id(@impl, id)
      end

      # Returns the message id.
      #
      def id
        Cproton.pn_message_get_id(@impl)
      end

      # Sets the user id.
      #
      # ==== Options
      #
      # * id - the user id
      #
      def user_id=(id)
        Cproton.pn_message_set_user_id(@impl, id)
      end

      # Returns the user id.
      #
      def user_id
        Cproton.pn_message_get_user_id(@impl)
      end

      # Sets the destination address.
      #
      # ==== Options
      #
      # * address - the address
      #
      def address=(address)
        Cproton.pn_message_set_address(@impl, address)
      end

      # Returns the destination address.
      #
      def address
        Cproton.pn_message_get_address(@impl)
      end

      # Sets the subject.
      #
      # ==== Options
      #
      # * subject - the subject
      #
      def subject=(subject)
        Cproton.pn_message_set_subject(@impl, subject)
      end

      # Returns the subject
      #
      def subject
        Cproton.pn_message_get_subject(@impl)
      end

      # Sets the reply-to address.
      #
      # ==== Options
      #
      # * address - the reply-to address
      #
      def reply_to=(address)
        Cproton.pn_message_set_reply_to(@impl, address)
      end

      # Returns the reply-to address
      #
      def reply_to
        Cproton.pn_message_get_reply_to(@impl)
      end

      # Sets the correlation id.
      #
      # ==== Options
      #
      # * id - the correlation id
      #
      def correlation_id=(id)
        Cproton.pn_message_set_correlation_id(@impl, id)
      end

      # Returns the correlation id.
      #
      def correlation_id
        Cproton.pn_message_get_correlation_id(@impl)
      end

      # Sets the message format.
      #
      # See MessageFormat for more details on formats.
      #
      # ==== Options
      #
      # * format - the format
      #
      def format=(format)
        raise TypeError.new("invalid message format: #{format}") if (format.nil? || !format.kind_of?(Qpid::Proton::MessageFormat))
        Cproton.pn_message_set_format(@impl, format.value)
      end

      # Returns the message format
      #
      def format
        Qpid::Proton::MessageFormat.by_value(Cproton.pn_message_get_format(@impl))
      end

      # Sets the content type.
      #
      # ==== Options
      #
      # * content_type - the content type
      #
      def content_type=(content_type)
        Cproton.pn_message_set_content_type(@impl, content_type)
      end

      # Returns the content type
      #
      def content_type
        Cproton.pn_message_get_content_type(@impl)
      end

      # Sets the message content.
      #
      # ==== Options
      #
      # * content - the content
      #
      def content=(content)
        Cproton.pn_message_load(@impl, content)
      end

      # Returns the message content.
      #
      def content
        Cproton.pn_message_save(@impl, 1024)[1]
      end

      # Sets the content encoding type.
      #
      # ==== Options
      #
      # * encoding - the content encoding
      #
      def content_encoding=(encoding)
        Cproton.pn_message_set_content_encoding(@impl, encoding)
      end

      # Returns the content encoding type.
      #
      def content_encoding
        Cproton.pn_message_get_content_encoding(@impl)
      end

      # Sets the expiration time.
      #
      # ==== Options
      #
      # * time - the expiry time
      #
      def expires=(time)
        raise TypeError.new("invalid expiry time: #{time}") if time.nil?
        raise ArgumentError.new("expiry time cannot be negative: #{time}") if time < 0
        Cproton.pn_message_set_expiry_time(@impl, time)
      end

      # Returns the expiration time.
      #
      def expires
        Cproton.pn_message_get_expiry_time(@impl)
      end

      # Sets the creation time.
      #
      # ==== Options
      #
      # * time - the creation time
      #
      def creation_time=(time)
        raise TypeError.new("invalid time: #{time}") if time.nil?
        raise ArgumentError.new("time cannot be negative") if time < 0
        Cproton.pn_message_set_creation_time(@impl, time)
      end

      # Returns the creation time.
      #
      def creation_time
        Cproton.pn_message_get_creation_time(@impl)
      end

      # Sets the group id.
      #
      # ==== Options
      #
      # * id - the group id
      #
      def group_id=(id)
        Cproton.pn_message_set_group_id(@impl, id)
      end

      # Returns the group id.
      #
      def group_id
        Cproton.pn_message_get_group_id(@impl)
      end

      # Sets the group sequence number.
      #
      # ==== Options
      #
      # * seq - the sequence number
      #
      def group_sequence=(seq)
        raise TypeError.new("invalid seq: #{seq}") if seq.nil?
        Cproton.pn_message_set_group_sequence(@impl, seq)
      end

      # Returns the group sequence number.
      #
      def group_sequence
        Cproton.pn_message_get_group_sequence(@impl)
      end

      # Sets the reply-to group id.
      #
      # ==== Options
      #
      # * id - the id
      #
      def reply_to_group_id=(id)
        Cproton.pn_message_set_reply_to_group_id(@impl, id)
      end

      # Returns the reply-to group id.
      #
      def reply_to_group_id
        Cproton.pn_message_get_reply_to_group_id(@impl)
      end

      # Returns the list of property names for associated with this message.
      #
      # ==== Examples
      #
      #   msg.properties.each do |name|
      #   end
      #
      def properties
        @properties
      end

      # Replaces the entire set of properties with the specified hash.
      #
      def properties=(properties)
        @properties = properties
      end

      # Assigns the value given to the named property.
      #
      # ==== Arguments
      #
      # * name - the property name
      # * value - the property value
      #
      def []=(name, value)
        @properties[name] = value
      end

      # Retrieves the value for the specified property name. If not found, then
      # it returns nil.
      #
      def [](name)
        @properties[name]
      end

      # Deletes the named property.
      #
      def delete_property(name)
        @properties.delete(name)
      end

      # Returns the instructions for this message.
      #
      def instructions
        @instructions
      end

      # Assigns instructions to this message.
      #
      def instructions=(instr)
        @instructions = instr
      end

      # Returns the annotations for this message.
      #
      def annotations
        @annotations
      end

      # Assigns annotations to this message.
      #
      def annotations=(annotations)
        @annotations = annotations
      end

      # Returns the body property of the message.
      #
      def body
        @body
      end

      # Assigns a new value to the body of the message.
      #
      def body=(body)
        @body = body
      end

      private

      def check(err) # :nodoc:
        if err < 0
          raise DataError, "[#{err}]: #{Cproton.pn_message_error(@data)}"
        else
          return err
        end
      end
    end

  end

end