import boto3
import json
from moto import mock_sqs
import sys
import unittest
from unittest.mock import patch

from fpsweeper import config
from fpsweeper.logic import sweeper
from fpsweeper.model import fp_message


def get_track_filename_mock(db_session_direct_delivery, track_details):
    return '\\test\\testing\\test_filepath.wav'


def get_tuid_details_dict_mock(tuids, db_session_art_relations):
    return {4: {'upc': 400, 'cd': 1, 'track_id': 1},
            5: {'upc': 500, 'cd': 1, 'track_id': 1},
            6: {'upc': 600, 'cd': 1, 'track_id': 1}}


def get_tuid_population_mock(
        db_session_art_relations, daterange_start_days, daterange_end_seconds,
        is_backfill, vendor_id_csv):
    return [1, 2, 3, 4, 5, 6]


def get_missing_tuids_mock(db_session_fingerprint_capture, expected_tuids):
    return [4, 5, 6]


def insert_fp_sweeper_log_mock(db_session_fingerprint_capture, datetime_start,
                               datetime_end, daterange_start, daterange_end,
                               num_tracks_checked, num_tracks_queued, status,
                               created_by):
    pass


class TestSqsMessage(unittest.TestCase):
    def setUp(self):
        sys.argv.clear()

    def tearDown(self):
        sys.argv.clear()

    @mock_sqs
    @patch('fpsweeper.model.sweeper_persister.insert_fp_sweeper_log', side_effect=insert_fp_sweeper_log_mock)
    @patch('fpsweeper.logic.sweeper.get_tuid_population', side_effect=get_tuid_population_mock)
    @patch('fpsweeper.logic.sweeper.get_missing_tuids', side_effect=get_missing_tuids_mock)
    @patch('fpsweeper.logic.sweeper.get_tuid_details_dict', side_effect=get_tuid_details_dict_mock)
    @patch('fpsweeper.logic.sweeper.get_track_filename', side_effect=get_track_filename_mock)
    def test_sweeper_main_sqs_output(self, track_filename, tuid_details_dict, missing_tuids,
                                     tuid_population, insert_fp_sweeper_log):
        """Assert that running sweeper main() causes expected messages to be pushed to SQS
        Args:
            track_filename (mock function): get_track_filename_mock
            tuid_details_dict (mock function): get_tuid_details_dict_mock
            tuid_population (mock function): get_tuid_population_mock
            missing_tuids (mock function): get_missing_tuids_mock
            insert_fp_sweeper_log (mock function): insert_fp_sweeper_log_mock
        """
        for track_source in (fp_message.BACKFILL, fp_message.SWEEPER):
            sqs_conn = boto3.resource('sqs')
            sqs_conn.create_queue(QueueName=config.sqs_queue_name)

            # call main() with command-line args
            sys.argv.clear()
            sys.argv.append('test_sweeper_main_sqs_output')
            sys.argv.append('--daterange_start_days=5')
            sys.argv.append('--daterange_end_seconds=3600')
            if track_source == fp_message.BACKFILL:
                sys.argv.append('--backfill')
            sweeper.main()

            # get messages from mock sqs
            q = sqs_conn.get_queue_by_name(QueueName=config.sqs_queue_name)
            messages = q.receive_messages(MaxNumberOfMessages=10)

            # there should be 3 messages in queue (for tuids 4, 5, 6)
            self.assertEqual(len(messages), 3)

            # check each queue message
            expected_message_keys = frozenset([fp_message.CORRELATION_ID,
                                               fp_message.FILE_UPLOAD_TIME,
                                               fp_message.TRACK_SOURCE,
                                               fp_message.TUID, fp_message.UPC,
                                               fp_message.FILENAME])
            for message in messages:
                message_dict = json.loads(message.body)
                self.assertSetEqual(frozenset(message_dict.keys()), expected_message_keys)
                self.assertEqual(message_dict[fp_message.TRACK_SOURCE], track_source)
                self.assertIn(message_dict[fp_message.TUID], missing_tuids(None, None))
                expected_upcs = [x[fp_message.UPC] for x in tuid_details_dict(None, None).values()]
                self.assertIn(message_dict[fp_message.UPC], expected_upcs)