from tests import BaseTestCase
from tests.test_utils import FixtureLoader
from tests.workers.fixtures.labels_copy_worker_fixture import fixture
from models import models, Project, Campaign, ProjectCampaign, MarketingAccount, PRSPurchaseOrder
from models.campaign import CampaignSourceType
from models.projects import ProjectCampaignStatus

from db import db
from sqlalchemy import and_, or_
from workers.labels_copy_worker import LabelsCopyWorker

UK_ORIGINAL_LABEL = 47
US_ORIGINAL_LABEL = 6
UK_TEST_LABEL = 800
US_TEST_LABEL = 900


class LabelsCopyWorkerTest(BaseTestCase):

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

    @staticmethod
    def __get_projects_by_label_id(label_id):
        return db.session.query(Project).filter(Project.label_id == label_id, Project.is_deleted.is_(False)).all()

    @staticmethod
    def __get_assigned_to_project_campaigns(project_id):
        return (
            db.session.query(Campaign, ProjectCampaign.status)
            .outerjoin(
                ProjectCampaign,
                and_(
                    ProjectCampaign.campaign_id == Campaign.id,
                    ProjectCampaign.status == ProjectCampaignStatus.APPROVED.value
                )
            )
            .filter(
                or_(
                    Campaign.project_id == project_id,
                    ProjectCampaign.project_id == project_id,
                ),
                Campaign.is_deleted.is_(False),
                Campaign.source.in_(CampaignSourceType.all_external_sources())
            )
            .all()
        )

    @staticmethod
    def __get_unassigned_campaigns(label_id):
        query = (
            db.session.query(Campaign)
            .join(Campaign.marketing_account)
            .filter(
                MarketingAccount.label_id == label_id,
                Campaign.is_deleted.is_(False),
                Campaign.project_id.is_(None)
            )
        )
        return query.all()

    @staticmethod
    def __get_purchase_orders_by_project_id(project_id):
        query = (
            db.session.query(PRSPurchaseOrder)
            .filter(
                PRSPurchaseOrder.project_id == project_id,
                PRSPurchaseOrder.is_deleted.is_(False),
                PRSPurchaseOrder.parent_po_number.is_(None)
            )
        )
        return query.all()

    def test_copy_labels_data(self):
        LabelsCopyWorker().execute()

        original_uk_projects = self.__get_projects_by_label_id(UK_ORIGINAL_LABEL)
        copied_uk_projects = self.__get_projects_by_label_id(UK_TEST_LABEL)
        self.soft_assert_equal(len(original_uk_projects), len(copied_uk_projects))

        original_us_projects = self.__get_projects_by_label_id(US_ORIGINAL_LABEL)
        copied_us_projects = self.__get_projects_by_label_id(US_TEST_LABEL)
        self.soft_assert_equal(len(original_us_projects), len(copied_us_projects))

        original_project = original_us_projects[0]
        original_campaigns = self.__get_assigned_to_project_campaigns(project_id=original_project.id)
        copied_project = copied_us_projects[0]
        copied_campaigns = self.__get_assigned_to_project_campaigns(copied_project.id)
        self.soft_assert_equal(len(original_campaigns), len(copied_campaigns))

        original_us_unassigned_campaigns = self.__get_unassigned_campaigns(US_ORIGINAL_LABEL)
        copied_us_unassigned_campaigns = self.__get_unassigned_campaigns(US_TEST_LABEL)
        self.soft_assert_equal(len(original_us_unassigned_campaigns), len(copied_us_unassigned_campaigns))

        original_uk_unassigned_campaigns = self.__get_unassigned_campaigns(UK_ORIGINAL_LABEL)
        copied_uk_unassigned_campaigns = self.__get_unassigned_campaigns(UK_TEST_LABEL)
        self.soft_assert_equal(len(original_uk_unassigned_campaigns), len(copied_uk_unassigned_campaigns))

        original_us_purchase_orders = self.__get_purchase_orders_by_project_id(original_project.id)
        copied_us_purchase_orders = self.__get_purchase_orders_by_project_id(copied_project.id)
        self.soft_assert_equal(len(original_us_purchase_orders), len(copied_us_purchase_orders))

        self.soft_assert_equal(original_project.name, copied_project.name)
        self.soft_assert_equal(original_project.initial_start_date, copied_project.initial_start_date)
        self.soft_assert_equal(original_project.end_date, copied_project.end_date)
        self.soft_assert_equal(original_project.updated_by_import_at, copied_project.updated_by_import_at)
        self.soft_assert_equal(original_project.is_confidential, copied_project.is_confidential)
        self.soft_assert_equal(original_project.ccp_title, copied_project.ccp_title)
        self.soft_assert_equal(original_project.prs_title, copied_project.prs_title)
        self.soft_assert_equal(original_project.gras_title, copied_project.gras_title)
        self.soft_assert_equal(original_project.create_user_id, copied_project.create_user_id)
        self.soft_assert_equal(original_project.edit_user_id, copied_project.edit_user_id)
        self.soft_assert_equal(original_project.source, copied_project.source)
        self.soft_assert_equal(original_project.currency, copied_project.currency)
        self.soft_assert_equal(original_project.notes, copied_project.notes)
        self.soft_assert_equal(copied_project.is_claimed, False)

        self.soft_assert(self.assertTrue, original_project.created_at != copied_project.created_at)
        self.soft_assert(self.assertTrue, original_project.updated_at != copied_project.updated_at)
        self.soft_assert(self.assertTrue, original_project.last_edit_at != copied_project.last_edit_at)
        self.soft_assert(self.assertTrue, original_project.allocation != copied_project.allocation)
        self.soft_assert(self.assertTrue, original_project.budget != copied_project.budget)
        self.soft_assert(self.assertTrue, original_project.gras_project_code != copied_project.gras_project_code)

        self.soft_assert_equal(original_project.label_id, US_ORIGINAL_LABEL)
        self.soft_assert_equal(copied_project.label_id, US_TEST_LABEL)
        self.assert_all()