import datetime
import uuid

from django.conf import settings
from django.test import TestCase


from dockerhub.marketo import constants
from dockerhub.marketo.client import MarketoClient, MarketoConstantMixin
from dockerhub.marketo.constants import ADD_TO_LIST_ACTIVITY
from dockerhub.marketo.utils import flatten


class TestMarketoFixture(TestCase):
    list_id = '1002'
    email_template = "fake+{0}@email.com"
    cookie = 'id:287-GTJ-838&token:_mch-marketo.com-1396310362214-46169'

    def setUp(self):
        self.host = getattr(settings, 'MARKETO_HOST')
        self.client_id = getattr(settings, 'MARKETO_CLIENT_ID')
        self.client_secret = getattr(settings, 'MARKETO_SECRET')
        self.client = MarketoClient(
            host=self.host,
            client_id=self.client_id,
            client_secret=self.client_secret
        )


class TestLeadCreation(TestMarketoFixture):
    def setUp(self):
        super(TestLeadCreation, self).setUp()
        random_email = self.email_template.format(uuid.uuid4())
        self.lead_ids = self.client.create_lead(email=random_email)
        self.get_lead_result = self.client.get_leads(
            MarketoClient.FilterType.EMAIL,
            values=[random_email, ],
            fields=[MarketoClient.FieldType.ID, ]
        )

    def tearDown(self):
        self.client.delete_leads(
            self.lead_ids
        )

    def test(self):
        super(TestLeadCreation, self).tearDown()
        self.assertTrue(self.lead_ids)
        self.assertTrue(isinstance(self.lead_ids, list))
        self.assertEqual(len(self.lead_ids), 1)
        self.assertEqual(self.lead_ids[0], self.get_lead_result[0].get('id'))


class TestUpdateFieldValue(TestLeadCreation):
    def setUp(self):
        super(TestUpdateFieldValue, self).setUp()
        self.result = self.client.update_field_value(
            self.lead_ids[0],
            'list_{0}'.format(self.list_id),
            MarketoConstantMixin.SUBSCRIBED
        )

    def tearDown(self):
        super(TestUpdateFieldValue, self).setUp()

    def test(self):
        self.assertTrue(self.result)


class TestAddRemoveLeadsToList(TestLeadCreation):
    def setUp(self):
        super(TestAddRemoveLeadsToList, self).setUp()
        self.add_result = self.client.add_leads_to_list(
            self.list_id, self.lead_ids
        )
        self.on_list_result = self.client.is_member_of_list(
            self.list_id, self.lead_ids
        )
        self.remove_result = self.client.remove_leads_from_list(
            self.list_id, self.lead_ids
        )
        self.not_on_list_result = self.client.is_member_of_list(
            self.list_id, self.lead_ids
        )

    def tearDown(self):
        super(TestAddRemoveLeadsToList, self).setUp()

    def test(self):
        self.assertTrue(self.add_result)
        self.assertTrue(self.on_list_result)
        self.assertTrue(self.remove_result)
        self.assertFalse(self.not_on_list_result)


class TestBrokenSession(TestLeadCreation):
    def setUp(self):
        super(TestBrokenSession, self).setUp()
        self.add_result = self.client.add_leads_to_list(
            self.list_id, self.lead_ids
        )
        self.client._s.close()
        self.on_list_result = self.client.is_member_of_list(
            self.list_id, self.lead_ids
        )
        self.client._s.close()
        self.remove_result = self.client.remove_leads_from_list(
            self.list_id, self.lead_ids
        )
        self.client._s.close()
        self.not_on_list_result = self.client.is_member_of_list(
            self.list_id, self.lead_ids
        )

    def tearDown(self):
        super(TestBrokenSession, self).setUp()

    def test(self):
        self.assertTrue(self.add_result)
        self.assertTrue(self.on_list_result)
        self.assertTrue(self.remove_result)
        self.assertFalse(self.not_on_list_result)


class TestLeadAssocication(TestLeadCreation):
    def setUp(self):
        super(TestLeadAssocication, self).setUp()
        self.result = self.client.associate_lead(
            self.lead_ids[0], self.cookie
        )

    def tearDown(self):
        super(TestLeadAssocication, self).tearDown()

    def test(self):
        self.assertTrue(self.result.get('success'))


class TestGetLeadsByListId(TestLeadCreation):
    activity_ids = [ADD_TO_LIST_ACTIVITY.id]

    def setUp(self):
        super(TestGetLeadsByListId, self).setUp()
        self.client = MarketoClient(self.host, self.client_id, self.client_secret)

        self.add_result = self.client.add_leads_to_list(self.list_id, self.lead_ids)
        self.leads = self.client.get_leads_by_list_id(list_id=self.list_id)
        self.remove_result = self.client.remove_leads_from_list(self.list_id, self.lead_ids)

    def tearDown(self):
        super(TestGetLeadsByListId, self).tearDown()

    def test(self):
        self.assertTrue(self.add_result)
        # We're not guaranteed to have a single lead on the list
        # so we need to check for our value in the list returned
        # by converting out leads object list into a list of lead ids
        self.assertIn(self.lead_ids[0], [int(lead) for lead in flatten('id', self.leads)])
        self.assertTrue(self.remove_result)


class TestCreateActivity(TestLeadCreation):
    def setUp(self):
        super(TestCreateActivity, self).setUp()

        # Create custom activity
        self.result = self.client.create_custom_activity(
            self.lead_ids[0],
            constants.DTR_BINARY_DOWNLOAD_ACTIVITY.id,
            constants.DTR_BINARY_DOWNLOAD_ACTIVITY.value,
            datetime.datetime.now().isoformat(),
            attributes=[
                {
                    "name": "SubType",
                    "value": "Ubuntu",
                },
                {
                    "name": "UserName",
                    "value": "toli",
                },
                {
                    "name": "UUID",
                    "value": "123-abc-xyz-456",
                },
            ]
        )

        # now retrieve that activity
        self.get_lead_activities_result = self.client.get_lead_activities(
            activity_ids=constants.DTR_BINARY_DOWNLOAD_ACTIVITY.id
        )

    def tearDown(self):
        super(TestCreateActivity, self).tearDown()

    def test(self):
        self.assertTrue(self.result)
        lead_activitity_count = 0
        for result in self.get_lead_activities_result:
            if result.get('leadId') == self.lead_ids[0]:
                lead_activitity_count += 1
        # we may have other download linsence activities in staging, so
        # we make sure to count only the ones related to the test user
        self.assertEqual(lead_activitity_count, 1)
        self.assertEqual(
            constants.DTR_BINARY_DOWNLOAD_ACTIVITY.id,
            self.get_lead_activities_result[0].get('activityTypeId')
        )