from typing import Optional, List

from flask import g

from campaigns.schemas import (
    CampaignDetailsResponseSchema,
    UnassignedCampaignsRequestModel,
    CampaignsTabResponseSchema,
    CampaignTabSchema
)
from campaigns.exceptions import CampaignNotFound
from campaigns.repositories.campaigns_repository import CampaignsRepository
from campaigns.services.campaigns_history_service import CampaignHistoryService
from campaigns.services.campaigns_service import CampaignsService
from campaigns.services.validators import CampaignsValidator
from models import Campaign, Project
from utils.exceptions import Forbidden
from projects.repositories.projects_repository import ProjectsRepository
import utils.session_utils as session_utils

from services.permission_role_service import PermissionsByRoleService


class UnassignedCampaignsService:
    campaigns_repository = CampaignsRepository()
    project_repository = ProjectsRepository()
    roles_service = PermissionsByRoleService()
    history_service = CampaignHistoryService()
    campaigns_service = CampaignsService()
    campaigns_validator = CampaignsValidator()

    def get_campaign_detail(self, campaign_uuid: str) -> Optional[CampaignDetailsResponseSchema]:
        campaign = self.campaigns_repository.get_unassigned_campaign_details_by_uuid(campaign_uuid)
        currency = self.campaigns_repository.get_currency(campaign_uuid)

        if not campaign:
            return None
        return CampaignDetailsResponseSchema(campaign=campaign, phases=[], is_pending=False, currency=currency)

    def get_unassigned_campaigns(self, project_id: int, params: UnassignedCampaignsRequestModel):
        project = self.project_repository.get_project_by_id(project_id)
        items, count = self.campaigns_repository.get_unassigned_campaigns_data(
            params=params,
            project=project
        )
        items = self.map_unassigned_campaigns(project_id, items, project.currency)
        return CampaignsTabResponseSchema(items=items, limit=params.limit, offset=params.offset, total=count)

    def manage_external_campaigns(
            self,
            project_id: int,
            assign_uuids: List[str] = None,
            unassign_uuids: List[str] = None,
    ):
        project = self.project_repository.get_project_by_id(project_id)
        if assign_uuids:
            assign_campaigns = self.campaigns_repository.get_campaigns_by_uuids(assign_uuids)
            if not assign_campaigns:
                raise CampaignNotFound()

            self.campaigns_validator.validate_campaigns_unassigned(assign_campaigns)
            self.campaigns_validator.validate_dsp_campaigns(assign_campaigns)

            self.__assign_and_approve_campaigns(assign_campaigns, project)

        if unassign_uuids:
            self.campaigns_validator.validate_campaigns_already_unassigned(unassign_uuids, project_id)
            self.campaigns_validator.validate_campaigns_already_assigned_to_another_project(unassign_uuids, project_id)

            unassign_campaigns = self.campaigns_repository.get_campaigns_by_uuids(unassign_uuids)
            if not unassign_campaigns:
                raise CampaignNotFound()

            self.__unassign_campaigns(unassign_campaigns, project)
        project.touch_last_edit()
        session_utils.session_commit()

        return True

    def __assign_and_approve_campaigns(self, campaigns: List[Campaign], project: Project):
        campaign_uuids = [campaign.uuid for campaign in campaigns]
        state = self.history_service.get_territories_state(project.id)
        self.campaigns_repository.assign_and_approve_campaigns(project.id, campaign_uuids)

        for campaign in campaigns:
            campaign.project_id = project.id
            campaign.edit_user_id = g.user_id
            campaign.create_user_id = g.user_id

        session_utils.session_flush()

        for campaign in campaigns:
            self.history_service.log_campaign_approved(campaign, state, g.user_id)

    def __unassign_campaigns(self, campaigns: List[Campaign], project: Project):
        for campaign in campaigns:

            self.history_service.log_campaign_rejected(campaign, project, g.user_id)
            self.campaigns_repository.unassign_campaign(project.id, campaign.uuid)

    def map_unassigned_campaigns(self, project_id: int, campaigns, currency):
        items = []
        for campaign in campaigns:
            is_pending_campaign = self.campaigns_repository.is_pending_campaign_for_project(project_id, campaign.id)
            items.append(CampaignTabSchema(campaign=campaign, is_pending=is_pending_campaign, currency=currency))
        return items