PlaylistShared/PlaylistShared.Api/Services/SharedPlaylistService.cs

using AutoMapper;
using Microsoft.EntityFrameworkCore;
using PlaylistShared.Api.Data;
using PlaylistShared.Api.Entities;
using PlaylistShared.Shared.Enums;
using PlaylistShared.Shared.Playlist;
using PlaylistShared.Shared.Shared;

namespace PlaylistShared.Api.Services;

public class SharedPlaylistService
{
    private readonly ApplicationDbContext _db;
    private readonly IMapper _mapper;
    private readonly TrackAdditionLogService _trackLogService;

    public SharedPlaylistService(ApplicationDbContext db, IMapper mapper, TrackAdditionLogService trackLogService)
    {
        _db = db;
        _mapper = mapper;
        _trackLogService = trackLogService;
    }

    public async Task<SharedPlaylistDto> CreateAsync(Guid creatorUserId, SharePlaylistDto dto)
    {
        var entity = new SharedPlaylist
        {
            Id = Guid.NewGuid(),
            CreatorUserId = creatorUserId,
            YandexPlaylistKind = dto.YandexPlaylistKind,
            YandexPlaylistOwnerUid = dto.YandexPlaylistOwnerUid,
            Title = dto.Title,
            Description = dto.Description,
            CreatedAt = DateTime.UtcNow,
            UpdatedAt = DateTime.UtcNow,
            ShareToken = GenerateToken(),
            PlayPermission = dto.PlayPermission,
            ViewPermission = dto.ViewPermission,
            AddPermission = dto.AddPermission,
            RemovePermission = dto.RemovePermission
        };
        _db.SharedPlaylists.Add(entity);
        await _db.SaveChangesAsync();
        return _mapper.Map<SharedPlaylistDto>(entity);
    }

    public async Task<SharedPlaylistDto?> GetByTokenAsync(string token)
    {
        var entity = await _db.SharedPlaylists
            .Include(sp => sp.Creator)
            .FirstOrDefaultAsync(sp => sp.ShareToken == token && !sp.IsDeleted);
        return entity == null ? null : _mapper.Map<SharedPlaylistDto>(entity);
    }

    public async Task<SharedPlaylist?> GetEntityByTokenAsync(string token)
    {
        return await _db.SharedPlaylists
            .Include(sp => sp.Creator)
            .FirstOrDefaultAsync(sp => sp.ShareToken == token && !sp.IsDeleted);
    }

    public async Task<SharedPlaylistDto?> UpdatePermissionsAsync(Guid playlistId, UpdatePermissionsDto dto)
    {
        var entity = await _db.SharedPlaylists.FindAsync(playlistId);
        if (entity == null) return null;
        entity.ViewPermission = dto.ViewPermission;
        entity.PlayPermission = dto.PlayPermission;
        entity.AddPermission = dto.AddPermission;
        entity.RemovePermission = dto.RemovePermission;
        entity.UpdatedAt = DateTime.UtcNow;
        await _db.SaveChangesAsync();
        return _mapper.Map<SharedPlaylistDto>(entity);
    }

    public async Task<bool> DeleteAsync(Guid playlistId)
    {
        var entity = await _db.SharedPlaylists.FindAsync(playlistId);
        if (entity == null) return false;
        entity.IsDeleted = true;
        entity.UpdatedAt = DateTime.UtcNow;
        await _db.SaveChangesAsync();
        return true;
    }

    public async Task<bool> CanPlayAsync(SharedPlaylist playlist, Guid? currentUserId)
    {
        if (currentUserId == playlist.CreatorUserId) return true;
        return playlist.PlayPermission == ViewPermission.Everyone ||
               (playlist.PlayPermission == ViewPermission.AuthorizedOnly && currentUserId.HasValue);
    }

    public async Task<bool> CanPlayEveryoneAsync(SharedPlaylist playlist)
    {
        return playlist.PlayPermission == ViewPermission.Everyone;
    }

    public async Task<bool> CanViewAsync(SharedPlaylist playlist, Guid? currentUserId)
    {
        if (currentUserId == playlist.CreatorUserId) return true;
        return playlist.ViewPermission == ViewPermission.Everyone ||
               (playlist.ViewPermission == ViewPermission.AuthorizedOnly && currentUserId.HasValue);
    }

    public async Task<bool> CanAddTrackAsync(SharedPlaylist playlist, Guid? currentUserId)
    {
        if (currentUserId == playlist.CreatorUserId) return true;
        return playlist.AddPermission == EditPermission.Everyone ||
               (playlist.AddPermission == EditPermission.AuthorizedOnly && currentUserId.HasValue);
    }

    public async Task<bool> CanRemoveTrackAsync(SharedPlaylist playlist, Guid? currentUserId, string trackId, string sessionId)
    {
        if (currentUserId == playlist.CreatorUserId) return true;
        return playlist.RemovePermission switch
        {
            EditPermission.Everyone => true,
            EditPermission.AuthorizedOnly => currentUserId.HasValue,
            EditPermission.AddedByUserOnly when currentUserId.HasValue =>
                await _trackLogService.IsTrackAddedByCurrentUserOrSessionAsync(playlist.Id, trackId, currentUserId, sessionId),
            EditPermission.AddedByUserOnly when !currentUserId.HasValue =>
                await _trackLogService.IsTrackAddedByCurrentUserOrSessionAsync(playlist.Id, trackId, null, sessionId),
            _ => false
        };
    }

    public async Task<bool> IsCreatorAsync(Guid playlistId, Guid userId)
    {
        var playlist = await _db.SharedPlaylists.FindAsync(playlistId);
        return playlist != null && playlist.CreatorUserId == userId;
    }

    private string GenerateToken()
    {
        return Convert.ToBase64String(Guid.NewGuid().ToByteArray())
            .Replace("/", "_")
            .Replace("+", "-")
            .TrimEnd('=');
    }

    public async Task<List<SharedPlaylist>> GetAllByUserAsync(Guid userId)
    {
        return await _db.SharedPlaylists
            .Where(sp => sp.CreatorUserId == userId && !sp.IsDeleted)
            .ToListAsync();
    }
}