Musify/backend/Core/Musify.Application/Mixes/GenerateMixesForUser.cs

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

namespace Musify.Application.Mixes
{
    public record GenerateMixesForUserCommand(long UserId)
        : ICommand<ErrorOr<Success>>;

    public class GenerateMixesForUserCommandHandler(
        IDatabase database,
        MixConfiguration mixConfiguration,
        ILogger<GenerateMixesForUserCommandHandler> logger)
        : ICommandHandler<GenerateMixesForUserCommand, ErrorOr<Success>>
    {
        private sealed record MixDraft(string Title, string? Subtitle, IReadOnlyList<Guid> TrackIds);

        public async ValueTask<ErrorOr<Success>> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
        {
            var userId = request.UserId;

            var libraryTrackIds = await database.UserHasTracks
                .AsNoTracking()
                .Where(userTrack => userTrack.UserId == userId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
                .Select(userTrack => userTrack.TrackId)
                .ToListAsync(cancellationToken);

            if (libraryTrackIds.Count == 0)
            {
                logger.LogInformation("User {UserId} has no tracks yet, skipping mix generation", userId);
                return new Success();
            }

            var historyTrackIds = await database.ListeningHistories
                .AsNoTracking()
                .Where(history => history.UserId == userId && history.IsCounted)
                .Select(history => history.TrackId)
                .Distinct()
                .ToListAsync(cancellationToken);

            var historySet = new HashSet<Guid>(historyTrackIds);
            var unheardTrackIds = libraryTrackIds.Where(id => !historySet.Contains(id)).ToList();

            var drafts = new List<MixDraft>();

            var discovery = Take(Shuffle(unheardTrackIds));
            if (discovery.Count > 0)
            {
                drafts.Add(new MixDraft(
                    "Descubrimiento",
                    "Canciones de tu biblioteca que todavía no has escuchado.",
                    discovery));
            }

            var daily = Take(Interleave(Shuffle(historyTrackIds), Shuffle(unheardTrackIds)));
            if (daily.Count > 0)
            {
                drafts.Add(new MixDraft(
                    "Tu mezcla diaria",
                    "Lo que más escuchas, con alguna sorpresa de tu biblioteca.",
                    daily));
            }

            if (drafts.Count == 0)
            {
                logger.LogInformation("No candidate songs found for user {UserId}, skipping mix generation", userId);
                return new Success();
            }

            await ReplaceMixesAsync(userId, drafts, cancellationToken);

            try
            {
                await database.SaveChangesAsync(cancellationToken);
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to generate mixes for user {UserId}", userId);
                return Error.Failure(description: $"Failed to generate mixes for user {userId}");
            }

            logger.LogInformation("Generated {Count} mixes for user {UserId}", drafts.Count, userId);
            return new Success();
        }

        private List<Guid> Take(IEnumerable<Guid> trackIds) =>
            [.. trackIds.Take(mixConfiguration.ItemsPerMix)];

        private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
            [.. trackIds.OrderBy(_ => Guid.NewGuid())];

        private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
        {
            var merged = new List<Guid>(first.Count + second.Count);
            for (var index = 0; index < Math.Max(first.Count, second.Count); index++)
            {
                if (index < first.Count)
                    merged.Add(first[index]);
                if (index < second.Count)
                    merged.Add(second[index]);
            }

            return merged;
        }

        private async Task ReplaceMixesAsync(long userId, IReadOnlyList<MixDraft> drafts, CancellationToken cancellationToken)
        {
            var previousMixes = await database.Mixes
                .Where(mix => mix.UserId == userId)
                .ToListAsync(cancellationToken);

            if (previousMixes.Count > 0)
            {
                var previousIds = previousMixes.Select(mix => mix.Id).ToList();
                var previousItems = await database.MixItems
                    .Where(item => previousIds.Contains(item.MixId))
                    .ToListAsync(cancellationToken);

                database.MixItems.RemoveRange(previousItems);
                database.Mixes.RemoveRange(previousMixes);
            }

            for (var position = 0; position < drafts.Count; position++)
            {
                var draft = drafts[position];
                var mix = new Mix
                {
                    UserId = userId,
                    Title = draft.Title,
                    Subtitle = draft.Subtitle,
                    Position = position
                };

                await database.Mixes.AddAsync(mix, cancellationToken);

                for (var itemPosition = 0; itemPosition < draft.TrackIds.Count; itemPosition++)
                {
                    await database.MixItems.AddAsync(new MixItem
                    {
                        MixId = mix.Id,
                        Position = itemPosition,
                        TrackId = draft.TrackIds[itemPosition]
                    }, cancellationToken);
                }
            }
        }
    }
}