using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using NLog;
using Sony.Filtr.ApolloAPI;
using Sony.Filtr.ApolloAPI.Models;
using Sony.Filtr.Core.Buzz;
using Sony.Filtr.Playlists.Spotify;
using Sony.Filtr.Playlists.Spotify.Model;
using Sony.Filtr.SpotifyWebAPI.Model;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.Tasks.Tasks.Spotify
{
    public class ImportBuzzArtistPlaylists : IScheduledTask
    {
        private readonly BuzzArtistManager _buzzArtistManager;
        private readonly SpotifyPlaylistManager _spotifyPlaylistManager;
        private readonly Logger _logger;
        private readonly IApolloWebApi _vendorApi;

        public ImportBuzzArtistPlaylists(BuzzArtistManager buzzArtistManager, IApolloWebApi vendorApi, SpotifyPlaylistManager spotifyPlaylistManager)
        {
            _buzzArtistManager = buzzArtistManager;
            _vendorApi = vendorApi;
            _spotifyPlaylistManager = spotifyPlaylistManager;
            _logger = NLog.LogManager.GetLogger("ImportBuzzArtistPlaylists");
        }

        public async Task<ScheduledTaskLog> ExecuteAsync(Guid scheduledTaskLogId)
        {
            _logger.Debug("Begin ImportBuzzArtistPlaylists.");

            var taskLog = new ScheduledTaskLog();

            var buzzArtists = _buzzArtistManager.GetBuzzArtists();

            _logger.Debug("Importing for {0} artists.", buzzArtists.Count);

            var uniqueSpotifyUsernames = buzzArtists.Select(a => a.ArtistSpotifyUserName).Where(a=> !string.IsNullOrWhiteSpace(a)).Distinct();

            var spotifyPlaylists = await GetOwnSpotifyPlaylists(uniqueSpotifyUsernames);

            var playlistsToAdd = spotifyPlaylists.Values.SelectMany(p => p).Select(BuildSpotifyPlaylist).ToList();
            _logger.Debug($"Adding {playlistsToAdd} playlists");
            await _spotifyPlaylistManager.AddSpotifyPlaylistsForTrackingAsync(playlistsToAdd);
            
            _logger.Debug("Done with ImportBuzzArtistPlaylists.");
            return taskLog;
        }

        public SpotifyPlaylistTrackingReference BuildSpotifyPlaylist(SpotifyPlaylistItem playlistItem)
        {
            var spotifyPlaylist = new SpotifyPlaylistTrackingReference()
            {
                PlaylistId = playlistItem.id,
                Name = playlistItem.name,
                User = playlistItem.owner.id,
                SaveTracklist = true
            };
            return spotifyPlaylist;
        }

        //Synchronize and unify with ImportBuzzPlaylists
        private async Task<IDictionary<string, List<SpotifyPlaylistItem>>> GetOwnSpotifyPlaylists(IEnumerable<string> uniqueSpotifyUsers)
        {
            var playlists = new ConcurrentDictionary<string, List<SpotifyPlaylistItem>>();
            await uniqueSpotifyUsers.ForEachAsync(5, async spotifyUser =>
            {
                try
                {
                    _logger.Debug("Begin GetPublicPlaylists for user: {0}", spotifyUser);

                    const string fields = "items(id,name,owner.id),total";
                    var userPlaylists = await _vendorApi.GetAllPublicPlaylistsAsync(spotifyUser, fields);
                    if (userPlaylists != null && userPlaylists.Any())
                    {
                        Console.WriteLine("Found {0} playlists for {1}", userPlaylists.Count(), spotifyUser);
                        var ownPlaylists = userPlaylists.Where(p => p.owner.id.Equals(spotifyUser, StringComparison.InvariantCultureIgnoreCase)).ToList();

                        _logger.Debug("Found {0} own playlists for {1}", ownPlaylists.Count, spotifyUser);
                        playlists.TryAdd(spotifyUser.ToLowerInvariant(), ownPlaylists);
                    }
                }
                catch (Exception ex)
                {
                    _logger.Error(ex, "Could not get playlist for user {0}", spotifyUser);
                }
            });

            return playlists;
        }
    }
}