import json

import time

import unittest

from mock import patch

from cloudbrain.modules.sources.openbci import OpenBCISource

from cloudbrain.publishers.rabbitmq import PikaPublisher

from cloudbrain.connectors.openbci import OpenBCIConnector, OpenBCISample

class MockSerial(object):

    """

    Patch class serial.Serial

    """

    def __init__(self, port, baud):

        pass

    def write(self, text):

        pass

    def read(self):

        return 'mock'

    def close(self):

        pass

    def inWaiting(self):

        return False

class MockHTTPResponse(object):

    status_code = 200

    def json(self):

        return {'vhost': 'mock_vhost'}

def mock_requests_get(vhost_info_url, verify):

    return MockHTTPResponse()

def mock_start(self, callback_functions):

    """

    Patch method OpenBCIConnector.start

    :param callback_functions: (dict)

      E.g: {metric_0: callback_0, ...,  metric_N: callback_N}

      where 'metric_X' is a string and 'callback_X' is a function that takes an

      Array as argument.

    """

    packet_id = 0

    channel_data = [i for i in range(8)]

    aux_data = []

    timestamp = int(time.time() * 1000000) # in microseconds

    sample = OpenBCISample(packet_id, channel_data, aux_data, timestamp)

    for (metric, callback_function) in callback_functions.items():

        callback_function(sample)

class MockChannel(object):

    def __init__(self):

        self.published_count = 0

        self.message_published = None

    def exchange_declare(self, exchange, exchange_type):

        pass

    def basic_publish(self, exchange, routing_key, body, properties):

        self.published_count += 1

        self.message_published = body

        print("Message count: %s" % self.published_count)

        print("Message body: %s" % body)

class MockBlockingConnection(object):

    """

    Patch pika's BlockingConnection

    """

    def __init__(self, params):

        pass

    def close(self):

        pass

    def channel(self):

        return MockChannel()

class OpenBCITest(unittest.TestCase):

    def setUp(self):

        self.device = 'openbci'

        self.user = "mock"

        # OpenBCI config

        self.port = None

        self.baud = 0

        self.filter_data = False

        # metric info

        self.metric_name = 'eeg'

        self.num_channels = 8

        self.buffer_size = 2

        # rmq info

        self.rabbitmq_user = 'mock_user'

        self.rabbitmq_pwd = 'mock_pwd'

        self.base_routing_key = '%s:%s' % (self.user, self.device)

        self.message = {'timestamp': 100}

        for i in range(self.num_channels):

            self.message['channel_%s' % i] = i

    def validate_start_method(self, sample):

        self.assertEqual(sample.channel_data, [i for i in range(self.num_channels)])

        print("OpenBCI started: %s" % sample.channel_data)

    @patch('serial.Serial', MockSerial)

    @patch('cloudbrain.connectors.openbci.OpenBCIConnector.start',

           mock_start)

    def test_OpenBCIConnector(self):

        board = OpenBCIConnector()

        callbacks = {self.metric_name: self.validate_start_method}

        board.start(callbacks)

    @patch('requests.get', mock_requests_get)

    @patch('pika.BlockingConnection', MockBlockingConnection)

    def test_PikaPublisher(self):

        options = {"rabbitmq_user": self.rabbitmq_user,

                   "rabbitmq_pwd": self.rabbitmq_pwd}

        publisher = PikaPublisher(self.base_routing_key, **options)

        publisher.connect()

        publisher.register(self.metric_name, self.num_channels,

                           self.buffer_size)

        for metric_name in publisher.metrics_to_num_channels().keys():

            routing_key = "%s:%s" % (self.base_routing_key, metric_name)

            self.assertEqual(publisher.channels[routing_key].published_count, 0)

            self.assertEqual(publisher.channels[routing_key].message_published,

                             None)

            publisher.publish(metric_name, self.message)

            self.assertEqual(publisher.channels[routing_key].published_count, 0)

            publisher.publish(metric_name, self.message)

            self.assertEqual(publisher.channels[routing_key].published_count, 1)

            expected_message = [{

                "channel_5": 5, "channel_4": 4, "channel_7": 7,

                "channel_6": 6, "channel_1": 1, "channel_0": 0,

                "channel_3": 3, "channel_2": 2, "timestamp": 100

            }, {

                "channel_5": 5, "channel_4": 4, "channel_7": 7,

                "channel_6": 6, "channel_1": 1, "channel_0": 0,

                "channel_3": 3, "channel_2": 2, "timestamp": 100

            }]

            published_message = json.loads(

                publisher.channels[routing_key].message_published)

            self.assertEqual(published_message, expected_message)

    @patch('requests.get', mock_requests_get)

    @patch('serial.Serial', MockSerial)

    @patch('pika.BlockingConnection', MockBlockingConnection)

    @patch('cloudbrain.connectors.openbci.OpenBCIConnector.start',

           mock_start)

    def test_OpenBCISource(self):

        options = {"rabbitmq_user": self.rabbitmq_user,

                   "rabbitmq_pwd": self.rabbitmq_pwd}

        publisher = PikaPublisher(self.base_routing_key, **options)

        publisher.connect()

        publisher.register(self.metric_name, self.num_channels,

                           self.buffer_size)

        publishers = [publisher]

        subscribers = []

        source = OpenBCISource(subscribers=subscribers,

                               publishers=publishers,

                               port=self.port,

                               baud=self.baud,

                               filter_data=self.filter_data)

        source.start()

        pub = source.publishers[0]

        routing_key = "%s:%s" % (self.base_routing_key, self.metric_name)

        self.assertEqual(pub.channels[routing_key].published_count, 0)

        self.assertEqual(pub.channels[routing_key].message_published,

                         None, "No messages should have been sent yet.")