from datetime import date

from flask import g

from utils.exceptions import NotFound
from services.artists_moments_fetcher import ArtistsMomentsFetcher
from models.projects import Project
from models.user_project import UserProject, UserProjectRoles
from utils import session_utils

from projects.repositories.projects_counter_repository import ProjectsCounterRepository
from projects.repositories.projects_repository import ProjectsRepository
from projects.schemas import ProjectListQueryParams, UpdateProjectParams, ProjectResponseSchema
from projects.services.projects_service import ProjectsService
from services.users_service import UsersService
from services.playlists_repository import PlaylistsRepository
from services.artists_repository import ArtistsRepository

from projects.repositories.unclaimed_projects_repository import UnclaimedProjectsRepository
from projects.schemas import (
    UnclaimedProjectModelSchema,
    UnclaimedProjectListResponseSchema,
    UnclaimedProjectModelDetailSchema,
    UnclaimedProjectDatesMetadata,
)
from projects.exceptions import EndDateValidationError
from projects.services.project_history_service import ProjectHistoryService
from projects.services.project_target_items_maper import ProjectTargetItemsMapper
from projects.services.project_team_service import ProjectTeamService
from linkfire.linkfire_repository import LinkfireRepository
from linkfire.schemas import LinkfireLinkSchema


class UnclaimedProjectsService:
    users_service = UsersService()
    project_service = ProjectsService()
    project_history_service = ProjectHistoryService()
    project_team_service = ProjectTeamService()
    unclaimed_project_repository = UnclaimedProjectsRepository()
    artists_repository = ArtistsRepository()
    playlists_repository = PlaylistsRepository()
    projects_repository = ProjectsRepository()
    projects_counter_repository = ProjectsCounterRepository()
    target_items_mapper = ProjectTargetItemsMapper()
    linkfire_repository = LinkfireRepository()

    def get_unclaimed_project_list(self, user_id: int, params: ProjectListQueryParams):
        fetch_result = self.unclaimed_project_repository.get_unclaimed_project_list(user_id, params)
        projects = [
            UnclaimedProjectModelSchema(item.Project, self.map_artists(item.Project.target_items))
            for item in fetch_result
        ]
        metadata = self.projects_counter_repository.get_projects_count(user_id, params)
        return UnclaimedProjectListResponseSchema(
            items=projects, metadata=metadata, limit=params.limit, offset=params.offset
        )

    def claim_project(self, project_id: int, params: UpdateProjectParams) -> ProjectResponseSchema:
        project = self.unclaimed_project_repository.get_project_by_id(project_id)
        self.__validate_project_params(project, params)

        project_state = self.project_history_service.get_project_state(project)

        project.is_claimed = True
        if project.initial_start_date is None:
            start_date = (
                project.earliest_campaign_start_date or
                project.earliest_purchase_order_date or
                date.today()
            )
            project.initial_start_date = start_date
        project.name = params.name
        project.create_user_id = g.user_id
        project.edit_user_id = g.user_id
        project.notes = params.notes
        project.end_date = params.endDate
        project.touch_last_edit()

        self.__add_editor_to_project(project.id, g.user_id)

        self.project_service.update_schedules_if_needed(project, params)

        self.project_service.set_target_items_from_params(params, project)
        self.linkfire_repository.update_project_linkfire_links(
            project,
            [
                LinkfireLinkSchema(id=link.id, link_id=link.linkId, link_url=link.linkUrl, deletable=link.deletable)
                for link in params.linkfireLinks
            ],
        )
        self.project_service.set_project_default_media_plan(project=project)

        self.projects_repository.add_or_update_project(project)
        self.projects_repository.refresh_project(project)
        self.project_history_service.log_project_claimed(project, project_state, g.user_id)

        moments_fetcher = ArtistsMomentsFetcher()
        moments_fetcher.fetch_moments_for_target_items_if_needed(project.target_items)

        return self.project_service.get_project_detail(project.id)

    def __add_editor_to_project(self, project_id, user_id):
        user_project = UserProject(
            project_id=project_id, user_id=user_id, shared_by=user_id, role=UserProjectRoles.EDITOR.value
        )
        session_utils.session_add(user_project)

    def __validate_project_params(self, project: Project, params: UpdateProjectParams):
        if params.startDate > params.endDate:
            raise EndDateValidationError()

    def get_unclaimed_project_detail(self, project_id: int) -> UnclaimedProjectModelDetailSchema:
        project = self.unclaimed_project_repository.get_project_by_id(project_id)
        if not project:
            raise NotFound()
        dates_metadata = self.projects_repository.get_gras_project_campaign_schedule(project.id)
        artists = self.map_artists(project.target_items)
        return UnclaimedProjectModelDetailSchema(
            project=project, artists=artists, dates_metadata=UnclaimedProjectDatesMetadata(dates_metadata)
        )

    def map_artists(self, target_items):
        return self.target_items_mapper.map_project_target_items_from_model(target_items).items