# vim: set fileencoding=utf-8 sw=4 ts=4 et :

import sys

from twisted.internet.defer import inlineCallbacks, returnValue
from twisted.internet import reactor, task
from twisted.internet.protocol import ClientCreator

from txamqp.protocol import AMQClient
from txamqp.client import TwistedDelegate
from txamqp.content import Content
import txamqp.spec

RABBIT_MQ_HOST = "localhost"
RABBIT_MQ_PORT = 5672

VHOST = "/"
QUEUE_NAME = "connector-metro-localhost"
CONSUMER_TAG = "test_consumer_tag"
# Set it to 0 or None to make the concurrency problem disappear
PREFETCH_COUNT = 1

credentials = {"LOGIN": "guest", "PASSWORD": "guest"}


@inlineCallbacks
def getConnection(client):
    conn = yield client.connectTCP(
        RABBIT_MQ_HOST, RABBIT_MQ_PORT)
    yield conn.start(credentials)
    returnValue(conn)


@inlineCallbacks
def getChannel(conn):
    chan = yield conn.channel(1)
    yield chan.channel_open()
    returnValue(chan)


@inlineCallbacks
def getQueue(conn, chan):
    # get the message queue on the message server
    yield chan.queue_declare(queue=QUEUE_NAME, durable=True,
                             exclusive=False, auto_delete=False)
    if PREFETCH_COUNT is not None:
        reply = yield chan.basic_qos(prefetch_count=PREFETCH_COUNT)
    reply = yield chan.basic_consume(queue=QUEUE_NAME, consumer_tag=QUEUE_NAME)
    # get the queue that's associated with our consumer
    queue = yield conn.queue(QUEUE_NAME)
    returnValue(queue)


@inlineCallbacks
def processMessage(chan, queue):
    print "Queue size: %d" % len(queue.pending)
    msg = yield queue.get()
    print "Received: %s from channel #%s (n°%s)" % (
        msg.content.body, chan.id, msg.delivery_tag)
    yield chan.basic_ack(msg.delivery_tag)
    print "ACKed n°%s" % msg.delivery_tag

@inlineCallbacks
def sendMessage(chan):
    msg = Content("blabla")
    yield chan.basic_publish(exchange="perf", routing_key="perf", content=msg)
    print "Published on chan #%s" % chan.id


@inlineCallbacks
def main(spec):
    delegate = TwistedDelegate()
    # create the Twisted consumer client
    consumer = ClientCreator(
        reactor, AMQClient, delegate=delegate,
        vhost=VHOST, spec=spec)
    # connect to the RabbitMQ server
    conn = yield getConnection(consumer)
    # get the channel
    chan = yield getChannel(conn)
    # get the message queue
    queue = yield getQueue(conn, chan)
    # start the workers
    recv = task.LoopingCall(processMessage, chan, queue)
    send = task.LoopingCall(sendMessage, chan)
    recv.start(0.3)
    reactor.callLater(2, send.start, 0.5)
    def stop():
        print "Stopping"
        recv.stop()
        send.stop()
        reactor.stop()
    reactor.callLater(15, stop)


if __name__ == "__main__":
    if len(sys.argv) != 2:
        print "%s path_to_spec" % sys.argv[0]
        sys.exit(1)
    spec = txamqp.spec.load(sys.argv[1])
    main(spec)
    reactor.run()