from typing import List, Optional
from flask import g

from auth.models import UserDataSchema
from models.user import User
from utils.exceptions import Unauthorized, NotFoundError
from services.users_repository import UsersRepository
from users.schemas import UserResponseModel, UserModel
from users.schemas import UpdateUserParams
from shared.schemas import LabelSchema
from services.labels_repository import LabelsRepository
from config import LABEL_IMAGE_SERVICE_URL
from utils import session_utils
from utils.list_utils import diff


class UsersService:
    users_repository = UsersRepository()
    labels_repository = LabelsRepository()

    def __map_user(self, user: User) -> UserResponseModel:
        user_model = UserModel(user)
        projects_count = self.users_repository.get_projects_count_for_user(g.user_id)
        labels = self.labels_repository.get_all_labels_for_user(user.id)
        return UserResponseModel(
            currentUser=user_model,
            labels=[
                LabelSchema(id=label.id, name=label.name, imageUrl=LABEL_IMAGE_SERVICE_URL.format(id=label.id))
                for label in labels
            ],
            projectsCount=projects_count,
        )

    def create_or_update_user(self, user_schema: UserDataSchema) -> User:
        return self.users_repository.create_or_update_user(user_schema)

    def get_current_user(self) -> UserResponseModel:
        if "user_external_id" in g:
            user = self.users_repository.get_user_by_external_id(g.user_external_id)
            return self.__map_user(user)
        raise Unauthorized()

    def get_user_by_id(self, user_id: int) -> Optional[User]:
        return self.users_repository.get_user_by_id(user_id)

    def get_users_for_label(self, label_id: int) -> List[UserModel]:
        users = self.users_repository.get_label_users(label_id)
        return [UserModel(user) for user in users]

    def get_all_users(self) -> List[UserModel]:
        users = self.users_repository.get_all_users()
        return [UserModel(user) for user in users]

    def get_user_label_ids(self, user_id: int) -> List[int]:
        return self.users_repository.get_user_labels_ids(user_id)

    def get_user_label(self, user_id: int, label_id: int):
        return self.users_repository.get_user_label(user_id, label_id)

    def is_user_exists(self, user_id) -> bool:
        return self.users_repository.is_user_exists(user_id)

    def update_user_phone(self, user_id: int, phone: str) -> User:
        user = self.users_repository.update_user_phone(user_id, phone)
        if not user:
            raise NotFoundError("User not found")
        return user

    def update_user(self, user: User, params: UpdateUserParams) -> UserResponseModel:
        if params.phone:
            user.phone = params.phone
        if params.dateTimeFormat:
            user.date_time_format = params.dateTimeFormat
        session_utils.session_commit()
        return self.__map_user(user)

    def remove_user_labels(self, user_id: int, labels_ids: List[int]):
        self.users_repository.delete_user_from_artist_teams_in_label_unclaim_projects(user_id, labels_ids)
        self.users_repository.delete_user_labels(user_id, labels_ids)

    def add_or_remove_labels_from_user(self, user_id: int, labels_ids: List[int]):
        user_labels_ids = self.users_repository.get_user_labels_ids(user_id)
        labels_diff = diff(user_labels_ids, labels_ids)
        if labels_diff:
            removed_labels = list(set(user_labels_ids).difference(set(labels_ids)))
            if removed_labels:
                self.remove_user_labels(user_id, removed_labels)
            new_labels = list(set(labels_ids).difference(set(user_labels_ids)))
            if new_labels:
                self.users_repository.add_labels_to_user_if_needed(user_id, new_labels)
        session_utils.session_commit()