from decimal import Decimal

from cryptofeed.defines import BID, ASK
from cryptofeed.backends._util import book_convert

import asyncio
import aio_pika
import json

class RabbitCallback:
    def __init__(self,
                 host='127.0.0.1',
                 port=5672,
                 username='guest',
                 password='guest',
                 routing_key='test_queue',
                 **kwargs):
        self.url = f'amqp://{username}:{password}@{host}:{port}/'
        self.routing_key = routing_key

    async def connect(self):
        loop = asyncio.get_event_loop()
        return await aio_pika.connect_robust(self.url, loop=loop)

    async def publish(self, message):
        connection = await self.connect()
        channel = await connection.channel()
        print(message)
        await channel.default_exchange.publish(
            aio_pika.Message(
                body=message.encode()
            ),
            routing_key=self.routing_key
        )
        await connection.close()


class TradeRabbitCallback(RabbitCallback):
    async def __call__(self, *, feed: str, pair: str, side: str, amount: Decimal, price: Decimal, order_id=None, timestamp=None):
        trade = {'feed': feed, 'pair': pair, 'id': order_id, 'timestamp': timestamp, 'side': side, 'amount': float(amount), 'price': float(price)}
        data = {'type': 'trade', 'data': trade}
        await self.publish(json.dumps(data))


class FundingRabbitCallback(RabbitCallback):
    async def __call__(self, **kwargs):
        for key in kwargs:
            if isinstance(kwargs[key], Decimal):
                kwargs[key] = float(kwargs[key])

        data = {'type': 'funding', 'data': kwargs}
        await self.publish(json.dumps(data))


class BookRabbit(RabbitCallback):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.depth = kwargs.get('depth', None)
        self.previous = {BID: {}, ASK: {}}

    async def __call__(self, *, feed, pair, book, timestamp):
        data = {'timestamp': timestamp, BID: {}, ASK: {}}
        book_convert(book, data, self.depth)
        upd = {'type': 'book', 'feed': feed, 'pair': pair, 'data': data}

        if self.depth:
            if upd['data'][BID] == self.previous[BID] and upd['data'][ASK] == self.previous[ASK]:
                return
            self.previous[ASK] = upd['data'][ASK]
            self.previous[BID] = upd['data'][BID]

        await self.publish(json.dumps(upd))