require 'spec_helper'

require 'hermann/producer'
require 'hermann/consumer'
require 'hermann/discovery/zookeeper'
require 'concurrent'

require 'protobuf'
require_relative '../fixtures/testevent.pb'

describe 'producer' do
  include_context 'integration test context'

  let(:timeout) { 10 }
  let(:message) { 'msg' }
  let(:consumer) do
    Hermann::Consumer.new(topic, 'rspec-group', zookeepers)
  end
  let(:consumer_promise) do
    Concurrent::Promise.execute do
      value = nil
      puts "consuming off `#{topic}`"
      consumer.consume(topic) do |dequeued|
        puts "received the message: #{dequeued.inspect}"

        buffer = dequeued.message.to_a
        # value = String.from_java_bytes(dequeued.message)
        value = buffer.pack('C*').encode('UTF-8', {:invalid => :replace, :undef => :replace, :replace => ''})
        # puts ".......................encoding: #{buffer.pack('c*')} #{buffer.pack('c*').encoding}"

        # value = buffer.pack('c*').encode("ASCII-8BIT", {:invalid => :replace, :undef => :replace, :replace => ''})
        puts value
        consumer.shutdown
      end
      # Return this out of the block
      value
    end
  end
  let(:brokers_array) do
    broker_ids = Hermann::Discovery::Zookeeper.new(zookeepers).get_brokers
    puts "using ZK discovered brokers: #{broker_ids}"
    broker_ids
  end
  let(:producer) { Hermann::Producer.new(nil, brokers_array) }

  it 'produces and consumes messages', :type => :integration, :platform => :java do
    producer.push(message, :topic => topic).value!(timeout)
    expect(consumer_promise.value!(timeout)).to eql(message)
  end

  context 'with binary data', :type => :integration, :platform => :java do
    let(:event) do
      Hermann::TestEvent.new(:name => 'rspec',
                             :state => 3,
                             :bogomips => 9001)
    end

    let(:message) { event.encode }

    it 'should be a thing' do
      producer.push(message, :topic => topic).value!(timeout)
      dequeued = consumer_promise.value!(timeout)
      expect(dequeued).to eql(message.encode!('UTF-8', {:invalid => :replace, :undef => :replace, :replace => ''}))

      expect {
        Hermann::TestEvent.decode(dequeued)
      }.not_to raise_error
    end
  end

  after :each do
    # Make sure we shut down our connection in any case
    consumer.shutdown
  end
end