import json
import datetime

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

from dockerhub.marketing import MailingListManager, LeadManager
from dockerhub.marketo import constants
from dockerhub.marketo.exceptions import UnableToCompleteRequestException
from dockerhub.test.marketo import test_mixins


class TestMarketoFixture(TestCase):
    mailing_list_id = "1015"
    email = "fake@email.com"
    lead_id = 1
    cookie = 'test_cookie_id'
    field_name = 'test'
    field_value = 'value'
    extra_values = dict(
        is_awesome=True,
        firstName='John',
        lastName='Costa'
    )
    campaign_id = '1051'

    def setUp(self):
        self.mailing_list_manager = MailingListManager()
        self.lead_manager = LeadManager()


class TestMailingListIsSubscribed(test_mixins.MarketoRequiresOauthTokenMixin,
                                  test_mixins.MarketoGetLeadMixin,
                                  test_mixins.MarketoAddLeadToListMixin,
                                  test_mixins.MarketoIsSubscribedMixin,
                                  test_mixins.MarketoMemberOfListMixin,
                                  test_mixins.MarketoRemoveFromListMixin,
                                  TestMarketoFixture):
    @httpretty.activate
    def test_lead_is_subscribed(self):

        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.GET_LEAD_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.POST,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.POST_LEAD_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.POST,
            self.POST_TO_LIST_URL.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.POST_TO_LIST_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEADS_ON_LIST.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.GET_LEADS_ON_LIST_IN_LIST_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.GET,
            self.MEMBER_OF_LIST_URL.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.GET_MEMBER_OF_LIST_RESPONSE)
        )

        self.assertTrue(
            self.mailing_list_manager.is_subscribed(
                self.mailing_list_id, self.email
            )
        )


class TestMailingListSubscribe(test_mixins.MarketoRequiresOauthTokenMixin,
                               test_mixins.MarketoGetLeadMixin,
                               test_mixins.MarketoAddLeadToListMixin,
                               test_mixins.MarketoIsSubscribedMixin,
                               test_mixins.MarketoMemberOfListMixin,
                               test_mixins.MarketoRemoveFromListMixin,
                               TestMarketoFixture):
    @httpretty.activate
    def test_subscribe(self):

        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.GET_LEAD_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.POST,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.POST_LEAD_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.POST,
            self.POST_TO_LIST_URL.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.POST_TO_LIST_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEADS_ON_LIST.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.GET_LEADS_ON_LIST_IN_LIST_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.GET,
            self.MEMBER_OF_LIST_URL.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.GET_MEMBER_OF_LIST_RESPONSE)
        )

        self.assertTrue(
            self.mailing_list_manager.subscribe(
                self.mailing_list_id, self.email
            )
        )


class TestMailingListUnsubscribe(test_mixins.MarketoRequiresOauthTokenMixin,
                                 test_mixins.MarketoGetLeadMixin,
                                 test_mixins.MarketoRemoveFromListMixin,
                                 test_mixins.MarketoIsSubscribedMixin,
                                 test_mixins.MarketoMemberOfListMixin,
                                 TestMarketoFixture):
    mailing_list_id = 1015

    @httpretty.activate
    def test_unsubscribe(self):

        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))
        httpretty.register_uri(
            httpretty.POST,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.POST_LEAD_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.DELETE,
            self.DELETE_FROM_LIST_URL.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.DELETE_FROM_LIST_RESPONSE_NOT_IN_LIST)
        )
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEADS_ON_LIST.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.GET_LEADS_ON_LIST_NOT_IN_LIST_RESPONSE)
        )
        httpretty.register_uri(
            httpretty.GET,
            self.MEMBER_OF_LIST_URL.format(self.mailing_list_id),
            content_type="application/json",
            body=json.dumps(self.GET_MEMBER_OF_LIST_RESPONSE)
        )

        self.assertTrue(
            self.mailing_list_manager.unsubscribe(
                self.mailing_list_id, self.email
            )
        )


class TestLeadManagerInterface(test_mixins.MarketoRequiresOauthTokenMixin,
                               test_mixins.MarketoAddLeadMixin,
                               test_mixins.MarketoAssociateLeadMixin,
                               test_mixins.MarketoCreateActivityMixin,
                               test_mixins.MarketoRequestCampaignMixin,
                               TestMarketoFixture):
    expected_lead_ids = [1097532]
    campaign_triggered = True
    activity_created = True
    activity_date = datetime.datetime.now()
    activity_type = constants.DTR_BINARY_DOWNLOAD
    attributes = dict(Other1="https://some.url.com")
    attributes_2 = dict(SubType="Trial")
    extra_values_trial = dict(plan_type="Trial")
    extra_values_docker = dict(point_of_entry="docker")
    extra_values_tutum = dict(point_of_entry="tutum")
    extra_values_null_plan_type = dict(point_of_entry="tutum",
                                       plan_type=None)

    @httpretty.activate
    def test_create_lead(self):
        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))
        httpretty.register_uri(
            httpretty.POST,
            self.POST_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.POST_LEAD_RESPONSE))
        httpretty.register_uri(
            httpretty.POST,
            self.ASSOCIATE_LEAD_URL.format(1097532),  # see fixture
            content_type="application/json",
            body=json.dumps(self.ASSOCIATE_LEAD_RESPONSE))

        self.result = self.lead_manager.create_lead(self.email)
        self.assertEqual(
            self.result,
            (self.expected_lead_ids, False)
        )

    @httpretty.activate
    def test_create_lead(self):
        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))
        httpretty.register_uri(
            httpretty.POST,
            self.POST_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.POST_LEAD_RESPONSE))
        httpretty.register_uri(
            httpretty.POST,
            self.ASSOCIATE_LEAD_URL.format(1097532),  # see fixture
            content_type="application/json",
            body=json.dumps(self.ASSOCIATE_LEAD_RESPONSE))

        # find lead
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.GET_LEAD_RESPONSE)
        )

        # trigger hub smart campaign
        httpretty.register_uri(
            httpretty.POST,
            self.REQUEST_CAMPAIGN_URL.format(
                settings.MARKETO_HUB_SIGNUP_CAMPAIGN_ID),
            content_type="application/json",
            body=json.dumps(self.POST_VALID_CAMPAIGN_REQUEST_RESPONSE)
        )

        # trigger tutum smart campaign
        httpretty.register_uri(
            httpretty.POST,
            self.REQUEST_CAMPAIGN_URL.format(
                settings.MARKETO_TUTUM_SIGNUP_CAMPAIGN_ID),
            content_type="application/json",
            body=json.dumps(self.POST_VALID_CAMPAIGN_REQUEST_RESPONSE)
        )

        # trigger trial smart campaign
        httpretty.register_uri(
            httpretty.POST,
            self.REQUEST_CAMPAIGN_URL.format(
                settings.MARKETO_SIGNUP_TRIAL_CAMPAIGN_ID),
            content_type="application/json",
            body=json.dumps(self.POST_VALID_CAMPAIGN_REQUEST_RESPONSE)
        )

        self.result = self.lead_manager.create_lead(
            self.email,
            extra_values=self.extra_values_docker
        )
        self.assertEqual(
            self.result,
            (self.expected_lead_ids, self.campaign_triggered)
        )

        self.result = self.lead_manager.create_lead(
            self.email,
            extra_values=self.extra_values_tutum
        )
        self.assertEqual(
            self.result,
            (self.expected_lead_ids, self.campaign_triggered)
        )

        self.result = self.lead_manager.create_lead(
            self.email,
            extra_values=self.extra_values_trial
        )
        self.assertEqual(
            self.result,
            (self.expected_lead_ids, self.campaign_triggered)
        )

        self.result = self.lead_manager.create_lead(
            self.email,
            extra_values=self.extra_values_null_plan_type
        )
        self.assertEqual(
            self.result,
            (self.expected_lead_ids, self.campaign_triggered)
        )

    @httpretty.activate
    def test_create_activity(self):
        # authenticate
        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))

        # find lead
        httpretty.register_uri(
            httpretty.POST,
            self.POST_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.POST_LEAD_RESPONSE))

        # create activity
        httpretty.register_uri(
            httpretty.POST,
            self.POST_CREATE_ACTIVITY_URL,
            content_type="application/json",
            body=json.dumps(self.POST_CREATE_ACTIVITY_RESPONSE))

        self.result = self.lead_manager.create_activity(
            self.email,
            self.activity_date,
            self.activity_type,
            attributes=self.attributes
        )
        self.assertEqual(
            self.result,
            (self.activity_created, not self.campaign_triggered)
        )

    @httpretty.activate
    def test_create_trial_license_download_activity(self):
        # authenticate
        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))

        # find lead
        httpretty.register_uri(
            httpretty.POST,
            self.POST_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.POST_LEAD_RESPONSE))
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.GET_LEAD_RESPONSE)
        )

        # create activity
        httpretty.register_uri(
            httpretty.POST,
            self.POST_CREATE_ACTIVITY_URL,
            content_type="application/json",
            body=json.dumps(self.POST_CREATE_ACTIVITY_RESPONSE))

        # trigger request campaign
        httpretty.register_uri(
            httpretty.POST,
            self.REQUEST_CAMPAIGN_URL.format(
                settings.MARKETO_DOWNLOAD_TRIAL_LICENSE_CAMPAIGN_ID),
            content_type="application/json",
            body=json.dumps(self.POST_VALID_CAMPAIGN_REQUEST_RESPONSE)
        )

        self.result = self.lead_manager.create_activity(
            self.email,
            self.activity_date,
            self.activity_type,
            attributes=self.attributes_2
        )
        self.assertEqual(
            self.result,
            (self.activity_created, self.campaign_triggered)
        )

    @httpretty.activate
    def test_valid_campaign_request(self):
        # authenticate
        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.GET_LEAD_RESPONSE)
        )
        # trigger request campaign
        httpretty.register_uri(
            httpretty.POST,
            self.REQUEST_CAMPAIGN_URL.format(self.campaign_id),
            content_type="application/json",
            body=json.dumps(self.POST_VALID_CAMPAIGN_REQUEST_RESPONSE))

        result = self.lead_manager._trigger_smart_campaign(self.email, self.campaign_id)

        self.assertTrue(result)

    @httpretty.activate
    def test_invalid_campaign_request(self):
        # authenticate
        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))

        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.GET_LEAD_RESPONSE)
        )
        # trigger request campaign
        httpretty.register_uri(
            httpretty.POST,
            self.REQUEST_CAMPAIGN_URL.format(self.campaign_id),
            content_type="application/json",
            body=json.dumps(self.POST_INVALID_CAMPAIGN_REQUEST_RESPONSE))

        result = self.lead_manager._trigger_smart_campaign(self.email, self.campaign_id)

        self.assertFalse(result)

    @httpretty.activate
    def test_campaign_request_without_campaign_id(self):
        # authenticate
        httpretty.register_uri(
            httpretty.GET,
            self.OAUTH_TOKEN_URL,
            content_type="application/json",
            body=json.dumps(self.OAUTH_TOKEN_RESPONSE))
        httpretty.register_uri(
            httpretty.GET,
            self.GET_LEAD_URL,
            content_type="application/json",
            body=json.dumps(self.GET_LEAD_RESPONSE)
        )

        result = self.lead_manager._trigger_smart_campaign(self.email, None)

        self.assertFalse(result)