import json
from db import db

from tests import BaseTestCase, FixtureLoader, mock_for_user
from unittest.mock import patch
from models import models, Project
from models.campaign import Campaign, ApprovalRequestCampaign
from tests.media_plan.fixtures.submit_media_plan_approval_fixture import fixture

reviewer = mock_for_user(1, "user-1@example.com", "sme-dna|5cf0091d6c91d310fe6fcdc6", name="First User")
non_reviewer = mock_for_user(2, "user-2@example.com", "sme-dna|user-2", name="User2")


class TestMediaPlanApproval(BaseTestCase):
    url = "/projects/500/media-plans/42/submit-approval"

    def setUp(self):
        super().setUp()
        FixtureLoader(models=models).import_as_sql(fixture)

    @patch("notifications.notifications_center.NotificationsCenter.notify")
    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_single_campaign_approval(self, notify_mock):
        data = {
            "campaigns": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97452",
                    "workflowStatus": "Approved"
                }
            ],
        }
        response = self.execute_post(self.url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 204)
        self.assertEqual(notify_mock.call_count, 1)
        campaign = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97452").one()
        self.assertEqual(campaign.workflow_status, "Approved")

    @patch("notifications.notifications_center.NotificationsCenter.notify")
    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_multiple_campaigns_with_different_statuses(self, notify_mock):
        data = {
            "campaigns": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97452",
                    "workflowStatus": "Approved"
                },
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97454",
                    "workflowStatus": "Disapproved"
                },
            ],
        }
        response = self.execute_post(self.url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 204)
        self.assertEqual(notify_mock.call_count, 1)
        campaign1 = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97452").one()
        self.assertEqual(campaign1.workflow_status, "Approved")
        campaign2 = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97454").one()
        self.assertEqual(campaign2.workflow_status, "Disapproved")

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_review_for_nonexistent_campaign(self):
        data = {
            "campaigns": [
                {
                    "campaignUuid": "11111111-2222-3333-4444-555555555555",
                    "workflowStatus": "Approved"
                }
            ],
        }
        response = self.execute_post(self.url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 422)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_review_with_invalid_campaign_status(self):
        data = {
            "campaigns": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97452",
                    "workflowStatus": "Booked"
                },
            ],
        }
        response = self.execute_post(self.url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 422)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_review_for_non_pending_campaign(self):
        data = {
            "campaigns": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97453",
                    "workflowStatus": "Approved"
                }
            ],
        }
        response = self.execute_post(self.url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 400)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", non_reviewer.jwt_decode)
    def test_submit_review_by_a_user_with_no_approver_permissions(self):
        data = {
            "campaigns": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97452",
                    "workflowStatus": "Approved"
                }
            ],
        }
        response = self.execute_post(self.url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 403)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_review_by_manual_transition_approved(self):
        url = "/projects/500/media-plans/42/campaigns/bulk-action"
        data = {
            "update": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97452",
                    "columns": {
                        "workflowStatus": "Approved",
                    }
                }
            ],
        }
        response = self.execute_post(url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 200)
        campaign1 = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97452").one()
        self.assertEqual(campaign1.workflow_status, "Approved")
        approval_request_campaign = (
            db.session.query(ApprovalRequestCampaign)
            .filter(ApprovalRequestCampaign.campaign_uuid == campaign1.uuid)
            .one()
        )
        self.assertEqual(approval_request_campaign.is_approved, True)
        self.assertEqual(approval_request_campaign.is_live, False)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_review_by_manual_transition_disapproved(self):
        url = "/projects/500/media-plans/42/campaigns/bulk-action"
        data = {
            "update": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97454",
                    "columns": {
                        "workflowStatus": "Disapproved",
                    }
                }
            ],
        }
        response = self.execute_post(url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 200)
        campaign1 = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97454").one()
        self.assertEqual(campaign1.workflow_status, "Disapproved")
        approval_request_campaign = (
            db.session.query(ApprovalRequestCampaign)
            .filter(ApprovalRequestCampaign.campaign_uuid == campaign1.uuid)
            .one()
        )
        self.assertEqual(approval_request_campaign.is_approved, False)
        self.assertEqual(approval_request_campaign.is_live, False)

    @patch("notifications.notifications_center.NotificationsCenter.notify")
    @patch("auth.atlas.atlas_token_decoder.jwt.decode", reviewer.jwt_decode)
    def test_submit_campaign_approval_should_update_project_last_edit_at(self, notify_mock):
        data = {
            "campaigns": [
                {
                    "campaignUuid": "34ed4c22-e1f9-4184-a06d-f04cbdb97452",
                    "workflowStatus": "Approved"
                }
            ],
        }
        response = self.execute_post(self.url, data=json.dumps(data), headers=self.headers)
        self.assertEqual(response.status_code, 204)
        self.assertEqual(notify_mock.call_count, 1)
        campaign = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97452").one()
        self.assertEqual(campaign.workflow_status, "Approved")
        project = db.session.query(Project).filter(Project.id == 500).one_or_none()
        self.assertNotEqual(project.last_edit_at, "2019-07-22 16:14:55.355226")