using YandexMusic.API.Models.Landing;
using YandexMusic.API.Models.Landing.Entity.Entities;
using YandexMusic.API.Models.Playlist;
using YandexMusic.API.Models.Track;
using YandexMusic.API.Requests.Playlist;

namespace YandexMusic.API;

/// <summary>API для работы с плейлистами.</summary>
public class YPlaylistAPI : YCommonAPI
{
    public YPlaylistAPI(YandexMusicApi api) : base(api) { }

    public async Task<List<YPlaylist>> GetPersonalPlaylistsAsync()
    {
        var landing = await Api.Landing.GetAsync(YLandingBlockType.PersonalPlaylists);
        var block = landing?.Blocks?.FirstOrDefault(b => b.Type == YLandingBlockType.PersonalPlaylists);
        if (block?.Entities == null)
            return new List<YPlaylist>();

        var tasks = block.Entities
            .OfType<YLandingEntityPersonalPlaylist>()
            .Select(e => GetAsync(e.Data?.Data?.Owner?.Uid ?? Api.Storage.User.Uid, e.Data?.Data?.Kind ?? ""))
            .Where(t => t != null)
            .ToList();

        var results = await Task.WhenAll(tasks);
        return results.Where(p => p != null).ToList()!;
    }

    public Task<YPlaylist?> GetAsync(string user, string kind)
        => new YGetPlaylistBuilder(Api).ExecuteAsync((user, kind));

    public Task<YPlaylist?> GetAsync(string uuid)
        => new YGetPlaylistByUuidBuilder(Api).ExecuteAsync(uuid);

    public Task<YPlaylist?> GetAsync(YPlaylist playlist)
        => GetAsync(playlist.Owner.Uid, playlist.Kind);

    public Task<List<YPlaylist>?> GetAsync(IEnumerable<(string user, string kind)> ids)
        => new YGetPlaylistsBuilder(Api).ExecuteAsync(ids);

    public Task<List<YPlaylist>?> FavoritesAsync()
        => new YGetPlaylistFavoritesBuilder(Api).ExecuteAsync(null!);

    public async Task<YPlaylist?> OfTheDayAsync()
        => (await GetPersonalPlaylistsAsync()).FirstOrDefault(p => p?.GeneratedPlaylistType == YGeneratedPlaylistType.PlaylistOfTheDay.ToString());

    public async Task<YPlaylist?> DejaVuAsync()
        => (await GetPersonalPlaylistsAsync()).FirstOrDefault(p => p?.GeneratedPlaylistType == YGeneratedPlaylistType.NeverHeard.ToString());

    public async Task<YPlaylist?> PremiereAsync()
        => (await GetPersonalPlaylistsAsync()).FirstOrDefault(p => p?.GeneratedPlaylistType == YGeneratedPlaylistType.RecentTracks.ToString());

    public async Task<YPlaylist?> MissedAsync()
        => (await GetPersonalPlaylistsAsync()).FirstOrDefault(p => p?.GeneratedPlaylistType == YGeneratedPlaylistType.MissedLikes.ToString());

    public async Task<YPlaylist?> KinopoiskAsync()
        => (await GetPersonalPlaylistsAsync()).FirstOrDefault(p => p?.GeneratedPlaylistType == YGeneratedPlaylistType.Kinopoisk.ToString());

    public Task<YPlaylist?> CreateAsync(string name)
        => new YPlaylistCreateBuilder(Api).ExecuteAsync(name);

    public Task<YPlaylist?> RenameAsync(string kind, string name)
        => new YPlaylistRenameBuilder(Api).ExecuteAsync((kind, name));

    public Task<YPlaylist?> RenameAsync(YPlaylist playlist, string name)
        => RenameAsync(playlist.Kind, name);

    public async Task<bool> DeleteAsync(string kind)
    {
        try
        {
            await new YPlaylistRemoveBuilder(Api).ExecuteAsync(kind);
            return true;
        }
        catch
        {
            return false;
        }
    }

    public Task<bool> DeleteAsync(YPlaylist playlist)
        => DeleteAsync(playlist.Kind);

    public async Task<YPlaylist?> InsertTracksAsync(YPlaylist playlist, IEnumerable<YTrack> tracks)
    {
        var change = await new YPlaylistChangeBuilder(Api).ExecuteAsync((playlist, new[]
        {
            new YPlaylistChange
            {
                Operation = YPlaylistChangeType.Insert,
                At = 0,
                Tracks = tracks.Select(t => t.GetKey())
            }
        }));
        return change != null ? await GetAsync(change) : null;
    }

    public async Task<YPlaylist?> DeleteTracksAsync(YPlaylist playlist, IEnumerable<YTrack> tracks)
    {
        var distinctTracks = tracks.Distinct().ToList();
        var indices = distinctTracks
            .Select(t => playlist.Tracks?.FindIndex(ct => ct.Track?.GetKey() == t.GetKey()) ?? -1)
            .Where(i => i != -1)
            .ToList();

        var changes = indices.Select(i => new YPlaylistChange
        {
            Operation = YPlaylistChangeType.Delete,
            From = i,
            To = i + 1,
            Tracks = new[] { playlist.Tracks![i].Track!.GetKey() }
        });

        var change = await new YPlaylistChangeBuilder(Api).ExecuteAsync((playlist, changes));
        return change != null ? await GetAsync(change) : null;
    }
}