using ErrorOr;
using Mediator;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Musify.Application.Contracts;
using Musify.Application.Shared;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;

namespace Musify.Application.Albums;

/// <summary>Appends your own tracks to an album in the given order, skipping the ones it already has.</summary>
public record AddTracksToAlbumCommand(long UserId, Guid AlbumId, IReadOnlyList<Guid> TrackIds)
    : ICommand<ErrorOr<Success>>;

public class AddTracksToAlbumCommandHandler(
    IDatabase database,
    ILogger<AddTracksToAlbumCommandHandler> logger)
    : ICommandHandler<AddTracksToAlbumCommand, ErrorOr<Success>>
{
    public async ValueTask<ErrorOr<Success>> Handle(AddTracksToAlbumCommand request, CancellationToken cancellationToken)
    {
        var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
        if (album.IsError)
            return album.Errors;

        var requestedIds = request.TrackIds.Distinct().ToList();

        var tracks = await database.Tracks
            .AsNoTracking()
            .Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
            .Select(track => new { track.Id, track.OwnerUserId })
            .ToListAsync(cancellationToken);

        var missing = requestedIds.FirstOrDefault(id => tracks.All(track => track.Id != id));
        if (missing != Guid.Empty)
            return AppErrors.NotFound("Track", missing);

        var foreign = tracks.FirstOrDefault(track => track.OwnerUserId != request.UserId);
        if (foreign != null)
            return AppErrors.Forbidden("Track", foreign.Id);

        var alreadyInAlbum = await database.AlbumHasTracks
            .AsNoTracking()
            .Where(link => link.AlbumId == request.AlbumId && requestedIds.Contains(link.TrackId))
            .Select(link => link.TrackId)
            .ToListAsync(cancellationToken);

        var toAdd = requestedIds.Where(id => !alreadyInAlbum.Contains(id)).ToList();
        if (toAdd.Count == 0)
            return Result.Success;

        // Album track numbers are user-visible, so they start at 1.
        var nextTrackNumber = (await database.AlbumHasTracks
            .Where(link => link.AlbumId == request.AlbumId)
            .MaxAsync(link => (int?)link.TrackNumber, cancellationToken) ?? 0) + 1;

        foreach (var trackId in toAdd)
        {
            await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
            {
                AlbumId = request.AlbumId,
                TrackId = trackId,
                TrackNumber = nextTrackNumber++
            }, cancellationToken);
        }

        var saved = await database.TrySaveChangesAsync(
            AppErrors.Conflict("Album.ConcurrentChange", "The album changed while adding tracks. Try again."), cancellationToken);
        if (saved.IsError)
            return saved;

        logger.LogInformation("Added {Count} tracks to album {AlbumId}", toAdd.Count, request.AlbumId);

        return Result.Success;
    }
}