import json
import uuid

from db import db
from tests import BaseTestCase, FixtureLoader, mock, mock_for_user
from unittest.mock import patch
from models import models
from models.campaign import Campaign
from models.projects import ProjectCampaign, ProjectCampaignStatus
from tests.campaigns.fixtures.manage_external_campaigns_fixture import fixture

user2 = mock_for_user(2, "user-2@example.com", "sme-dna|9op0091d6cuhjp30fe6ffth34", name="User Admin")


class TestManageExternalCampaigns(BaseTestCase):
    url = "/projects/{}/manage-external-campaigns"

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

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_multiple_unassigned_campaigns(self):
        data = {
            "assignCampaignsUuids": ["34ed4c22-e1f9-4184-a06d-f04cbdb97455", "aa1490b5-832c-4852-9d28-7a96884ff399"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(204, response.status_code)

        campaign1 = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97455").one_or_none()
        campaign2 = db.session.query(Campaign).filter_by(uuid="aa1490b5-832c-4852-9d28-7a96884ff399").one_or_none()

        project_campaign1 = db.session.query(ProjectCampaign).filter_by(campaign_id=1, project_id=500).one_or_none()
        project_campaign2 = db.session.query(ProjectCampaign).filter_by(campaign_id=2, project_id=500).one_or_none()

        self.soft_assert_equal(campaign1.project_id, 500)
        self.soft_assert_equal(campaign2.project_id, 500)
        self.soft_assert_equal(project_campaign1.status, ProjectCampaignStatus.APPROVED.value)
        self.soft_assert_equal(project_campaign2.status, ProjectCampaignStatus.APPROVED.value)

        self.assert_all()

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_pending_campaign(self):
        data = {
            "assignCampaignsUuids": ["c40fe4e8-58ce-4ba6-ab10-4932e685a389"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(204, response.status_code)

        campaign = db.session.query(Campaign).filter_by(uuid="c40fe4e8-58ce-4ba6-ab10-4932e685a389").one_or_none()
        project_campaign = db.session.query(ProjectCampaign).filter_by(campaign_id=3, project_id=500).one_or_none()

        self.soft_assert_equal(campaign.project_id, 500)
        self.soft_assert_equal(project_campaign.status, ProjectCampaignStatus.APPROVED.value)

        self.assert_all()

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_campaign_pending_to_another_project(self):
        data = {
            "assignCampaignsUuids": ["2dd6f9b4-42f5-48e8-a01f-c7bb9dc6434d"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(204, response.status_code)

        campaign = db.session.query(Campaign).filter_by(uuid="2dd6f9b4-42f5-48e8-a01f-c7bb9dc6434d").one_or_none()
        project_campaign = db.session.query(ProjectCampaign).filter_by(campaign_id=4, project_id=500).one_or_none()
        rejected_project_campaign = (
            db.session.query(ProjectCampaign)
            .filter_by(campaign_id=4, project_id=501)
            .one_or_none()
        )

        self.soft_assert_equal(campaign.project_id, 500)
        self.soft_assert_equal(project_campaign.status, ProjectCampaignStatus.APPROVED.value)
        self.soft_assert_equal(rejected_project_campaign.status, ProjectCampaignStatus.REJECTED.value)

        self.assert_all()

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_unassign_multiple_campaigns(self):
        data = {
            "unassignCampaignsUuids": ["20618d97-5190-4589-8fed-9e109e5ac5b5", "0b70c231-1997-417b-a23f-9a89ffa4f6bf"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(204, response.status_code)

        campaign1 = db.session.query(Campaign).filter_by(uuid="20618d97-5190-4589-8fed-9e109e5ac5b5").one_or_none()
        campaign2 = db.session.query(Campaign).filter_by(uuid="0b70c231-1997-417b-a23f-9a89ffa4f6bf").one_or_none()
        project_campaign1 = db.session.query(ProjectCampaign).filter_by(campaign_id=5, project_id=500).one_or_none()
        project_campaign2 = db.session.query(ProjectCampaign).filter_by(campaign_id=6, project_id=500).one_or_none()

        self.soft_assert_equal(campaign1.project_id, None)
        self.soft_assert_equal(campaign2.project_id, None)
        self.soft_assert_equal(project_campaign1.status, ProjectCampaignStatus.REJECTED.value)
        self.soft_assert_equal(project_campaign2.status, ProjectCampaignStatus.REJECTED.value)

        self.assert_all()

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_and_unassign_campaigns_simultaneously(self):
        data = {
            "assignCampaignsUuids": ["34ed4c22-e1f9-4184-a06d-f04cbdb97455"],
            "unassignCampaignsUuids": ["20618d97-5190-4589-8fed-9e109e5ac5b5"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(204, response.status_code)

        campaign1 = db.session.query(Campaign).filter_by(uuid="34ed4c22-e1f9-4184-a06d-f04cbdb97455").one_or_none()
        campaign2 = db.session.query(Campaign).filter_by(uuid="20618d97-5190-4589-8fed-9e109e5ac5b5").one_or_none()
        project_campaign1 = db.session.query(ProjectCampaign).filter_by(campaign_id=1, project_id=500).one_or_none()
        project_campaign2 = db.session.query(ProjectCampaign).filter_by(campaign_id=5, project_id=500).one_or_none()

        self.soft_assert_equal(campaign1.project_id, 500)
        self.soft_assert_equal(campaign2.project_id, None)
        self.soft_assert_equal(project_campaign1.status, ProjectCampaignStatus.APPROVED.value)
        self.soft_assert_equal(project_campaign2.status, ProjectCampaignStatus.REJECTED.value)

        self.assert_all()

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_manual_campaign(self):
        data = {
            "assignCampaignsUuids": ["9d6211cf-1e47-487d-bb01-e08f6472d71e"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(403, response.status_code)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", user2.jwt_decode)
    def test_assign_campaigns_with_insufficient_access(self):
        data = {
            "assignCampaignsUuids": ["34ed4c22-e1f9-4184-a06d-f04cbdb97455"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(403, response.status_code)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_nonexistent_campaign(self):
        data = {
            "assignCampaignsUuids": ["11111111-2222-1111-2222-111111111111"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(404, response.status_code)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_campaign_approved_to_another_project(self):
        data = {
            "assignCampaignsUuids": ["9d6211cf-1e47-487d-bb01-e08f6472d333"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(400, response.status_code)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_assign_campaign_with_invalid_uuid_should_return_422(self):
        data = {
            "assignCampaignsUuids": ["111111"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(422, response.status_code)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_unassign_campaign_with_invalid_uuid_should_return_422(self):
        data = {
            "unassignCampaignsUuids": ["111111"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        self.assertEqual(422, response.status_code)

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_unassign_already_unassigned_campaign_should_return_400(self):
        data = {
            "unassignCampaignsUuids": ["9d6211cf-1e47-487d-bb01-e08f6472d777"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        response_data = response.json
        self.assertEqual(400, response.status_code)
        self.assertEqual(response_data['code'], "campaign_already_unassigned")

    @patch("auth.atlas.atlas_token_decoder.jwt.decode", mock.jwt_decode)
    def test_unassign_already_assigned_to_another_project_campaign(self):
        data = {
            "unassignCampaignsUuids": ["9d6211cf-1e47-487d-bb01-e08f6472d333"],
        }
        response = self.execute_post(self.url.format(500), data=json.dumps(data), headers=self.headers)
        response_data = response.json
        self.assertEqual(400, response.status_code)
        self.assertEqual(response_data['code'], "campaign_assigned_to_another_project")