require 'base64'

class Java::org.torquebox.messaging.client::Client

  alias_method :core_send, :send

  def receive(destination, opts = {})
    timeout = opts[:timeout] || 30000 # 30 sec
    type    = opts[:type]    || :raw
    filter  = opts[:filter]

    destination = lookup_destination( destination )

    recvd_msg = session.create_receiver( destination, filter ).receive( timeout )
    session.commit

    message_for_type( recvd_msg, type )
  end

  def send(destination, opts = {})
    message = prepare_message( opts )
    return if message.nil?

    destination = lookup_destination( destination )

    producer = session.create_producer( destination )
    producer.send( message )
    session.commit
  end

  def send_and_receive(destination, opts = {})
    message = prepare_message( opts )
    return if message.nil?

    type    = opts[:type] || :raw
    timeout = opts[:timeout] || 30000 # 30 sec

    destination = lookup_destination( destination )

    request_producer = session.create_producer( destination )

    reply_queue = session.create_temporary_queue
    reply_receiver = session.create_receiver( reply_queue )

    message.jmsreply_to = reply_queue
    message.jmsdelivery_mode = Java::javax.jms.DeliveryMode.NON_PERSISTENT

    request_producer.send( message )
    session.commit
    recvd_msg = reply_receiver.receive( timeout )
    session.commit

    message_for_type( recvd_msg, type )
  end

  def lookup_destination( destination )
     destination.is_a?( Java::javax.jms.Destination ) ? destination : self.lookup( destination.to_s )
  end

  def message_for_type( message, type )
    return if message.nil?

    case type
      when :text
        return message.text
      when :object
        return message.object
      else
        return message
    end
  end

  def prepare_message(opts = {})
    message = nil
    if ( ( ! opts[:task].nil? ) && ( ! opts[:payload].nil? ) )
      message = session.create_text_message
      message.set_string_property( 'torqueboxMessageType', 'task' )
      message.set_string_property( 'torqueboxTask', opts[:task] )
      marshalled = Marshal.dump( opts[:payload] )
      encoded = Base64.encode64( marshalled )
      message.text = encoded
    elsif ( ! opts[:object].nil? )
      message = session.create_text_message
      message.set_string_property( 'torqueboxMessageType', 'object' )
      marshalled = Marshal.dump( opts[:object] )
      encoded = Base64.encode64( marshalled )
      message.text = encoded
    elsif ( ! opts[:text].nil? )
      message = session.create_text_message
      message.set_string_property( 'torqueboxMessageType', 'text' )
      message.text = opts[:text].to_s
    end

    unless message.nil?
      opts[:properties].each do |key, value|
        key = key.to_s
        case value
          when String
            message.set_string_property( key, value )
          when Fixnum
            message.set_int_property( key, value )
          when Bignum
            message.set_long_property( key, value )
          when FalseClass, TrueClass
            message.set_boolean_property( key, value )
          when Float
            message.set_double_property( key, value )
          else
            message.set_object_property( key, value )
        end
      end unless opts[:properties].nil? or !opts[:properties].is_a?(Hash)
    end

    message
  end
end

module TorqueBox
  module Messaging

    class Client
      def self.connect(opts={},&block)
        factory = Java::org.torquebox.messaging.client::ClientFactory.new
        factory.naming_provider_url          = opts[:naming_provider_url]          unless ( opts[:naming_provider_url].nil? )
        factory.context_factory_class_name   = opts[:context_factory_class_name]   unless ( opts[:context_factory_class_name].nil? )
        factory.url_package_prefixes         = opts[:url_package_prefixes]         unless ( opts[:url_package_prefixes].nil? )
        factory.connection_factory_jndi_name = opts[:connection_factory_jndi_name] unless ( opts[:connection_factory_jndi_name].nil? )
        client = factory.create_client
        client.connect
        if ( block )
          begin
            block.call( client )
            client.commit
          rescue => e
            client.rollback
            raise e
          ensure
            client.close
          end
        else
          return client
        end
      end

    end

  end
end