from typing import List, Optional

from sqlalchemy import and_, literal
from sqlalchemy.orm import joinedload
from models.artist_moment_category import ArtistMomentCategory
from db import db
from models import Artist, ProjectTargetItem, Project, ArtistMomentTypeGroup
from models.artist_moment import ArtistMoment
from models.project_entity_type import ProjectEntityType
from services.territory.territories_repository import TerritoriesRepository


class ArtistsMomentsRepository:
    territories_repository = TerritoriesRepository()

    def get_artists_moments_for_project(self, project_id: int) -> List[ArtistMoment]:
        return (
            self.__base_artist_moments_query(project_id)
            .options(
                joinedload(ArtistMoment.type),
                joinedload(ArtistMoment.category),
                joinedload(ArtistMoment.territories),
                joinedload(ArtistMoment.create_user),
                joinedload(ArtistMoment.edit_user),
            )
            .order_by(ArtistMoment.id)
            .all()
        )

    def __base_artist_moments_query(self, project_id):
        return (
            db.session.query(ArtistMoment)
            .join(Artist, ArtistMoment.artist_id == Artist.id)
            .join(
                ProjectTargetItem,
                and_(
                    Artist.id == ProjectTargetItem.entity_id,
                    ProjectTargetItem.entity_type == ProjectEntityType.PRIMARY_ARTIST.value,
                ),
            )
            .join(
                Project,
                and_(
                    Project.id == ProjectTargetItem.project_id, Project.id == project_id, Project.is_deleted.isnot(True)
                ),
            )
        )

    def get_moments_types(self) -> List[ArtistMomentTypeGroup]:
        return db.session.query(ArtistMomentTypeGroup).all()

    def get_moments_categories(self) -> List[ArtistMomentCategory]:
        return db.session.query(ArtistMomentCategory).all()

    def get_artists_moment_by_id(self, project_id: int, artist_moment_id: int) -> Optional[ArtistMoment]:
        return self.__base_artist_moments_query(project_id).filter(ArtistMoment.id == artist_moment_id).one_or_none()

    def create_moment(self, artist_moment: ArtistMoment) -> ArtistMoment:
        db.session.add(artist_moment)
        db.session.commit()
        db.session.refresh(artist_moment)
        return artist_moment

    def update_moment(self, artist_moment: ArtistMoment) -> ArtistMoment:
        db.session.commit()
        db.session.refresh(artist_moment)
        return artist_moment

    def delete_moment(self, moment_id: int):
        db.session.query(ArtistMoment).filter(ArtistMoment.id == moment_id).delete()
        db.session.commit()

    def is_primary_artist_for_project(self, project_id: int, artist_id: str) -> bool:
        query = (
            db.session.query(Artist)
            .join(
                ProjectTargetItem,
                and_(
                    Artist.id == ProjectTargetItem.entity_id,
                    ProjectTargetItem.entity_type == ProjectEntityType.PRIMARY_ARTIST.value,
                ),
            )
            .join(
                Project,
                and_(
                    Project.id == ProjectTargetItem.project_id, Project.id == project_id, Project.is_deleted.isnot(True)
                ),
            )
            .filter(Artist.external_id == artist_id)
        )
        return db.session.query(literal(True)).filter(query.exists()).scalar()