//using System;
//using System.Collections.Generic;
//using System.Diagnostics;
//using System.Drawing.Imaging;
//using System.IO;
//using System.Linq;
//using System.Net;
//using System.Net.Http;
//using System.Text;
//using System.Threading;
//using System.Threading.Tasks;
//using CacheCow.Common;
//using Sony.Filtr.Contracts.Abstractions;
//using Sony.Filtr.Contracts.Entities;
//using Sony.Filtr.Contracts.Entities.Genre;
//using Sony.Filtr.Contracts.SpotifyIntegration;
//using Sony.Filtr.Core.EditorialPlaylists;
//using Sony.Filtr.DistributedCaching;
//using Sony.Filtr.SpotifyWebAPI;
//using Sony.Filtr.SpotifyWebAPI.Model;
//using Sony.Filtr.Tasks.Tasks;
//using Sony.Filtr.Utility.Extensions;

//namespace Sony.Filtr.Worker.Onetime
//{
//    public class UpdatePlaylistPerformanceTester
//    {
//        private readonly EditorialPlaylistManager _editorialPlaylistManager;
//        private readonly DistributedCacheHandler _distributedCacheHandler;
//        private readonly IImageFactory _imageFactory;
//        private readonly UpdatePlaylistInfoTask _updatePlaylistInfoTask;
//        private readonly SpotifyWebApi _spotifyWebApi;

//        public UpdatePlaylistPerformanceTester(EditorialPlaylistManager editorialPlaylistManager, ICacheStore cacheStore, IServiceAccountManager serviceAccountManager, DistributedCacheHandler distributedCacheHandler, IImageFactory imageFactory, UpdatePlaylistInfoTask updatePlaylistInfoTask)
//        {
//            _editorialPlaylistManager = editorialPlaylistManager;
//            _distributedCacheHandler = distributedCacheHandler;
//            _imageFactory = imageFactory;
//            _updatePlaylistInfoTask = updatePlaylistInfoTask;
//            _spotifyWebApi = new SpotifyWebApi("a281f87a91194764921de94d22fc3c2a", "c1f15bc475fa464aac6f177012fb7650", cacheStore, serviceAccountManager);
//        }

//        public async Task ExecuteAsync()
//        {
//            /*
//            Hur många fungerade playlist och playlists-tracks anrop kan vi göra på x tid.
//            Hur många spellist-uppdateringar i databasen kan vi göra på x tid.
//            Hur många spellist-låt uppdateringar i databasen kan vi göra på x tid.
//            Hur mycket snabbare kan det bli 
//            Kan vi hantera earliest added på smidigare sätt vid uppdatering?
//            Hur många spellistors låtlista behöver inte uppdateras kontinuerligt?
//            Hur bra blir det när anrop cachas. Kan vi helt skippa uppdatering vid not-modified. */

//            var editorialPlaylists =
//                await
//                    _editorialPlaylistManager.GetEditorialPlaylistsAsync(onlySony: false, onlyActive: false,
//                        lightWeight: true);
//            editorialPlaylists = editorialPlaylists.Take(5000).ToList();
//            var artists = await _editorialPlaylistManager.GetArtistsAsync(editorialPlaylists);
//            var tags = await _editorialPlaylistManager.GetTagsAsync(editorialPlaylists);
//            var tracks = await _editorialPlaylistManager.GetTracksAsync(editorialPlaylists);

//            var spotifyPlaylistUris = editorialPlaylists.Select(e => e.SpotifyLink).Distinct();

//            //Hur många fungerade playlist och playlists-tracks anrop kan vi göra på x tid.
//            //var spotifyPlaylists = await TestSpotifyCallsOnlyAsync(spotifyPlaylistUris);

//            //Hur lång tid tar att spara bilder?
//            //await TestSaveSpotifyPlaylistImageAsync(spotifyPlaylists);

//            //Hur många spellist-uppdateringar i databasen kan vi göra på x tid.
//            //await TestDbUpdateCallsOnlyAsync(editorialPlaylists);

//            //Hur många spellist-låt uppdateringar i databasen kan vi göra på x tid.
//            //await TestDbContentCallsOnlyAsync(editorialPlaylists, artists, tags, tracks);

//            //await TestDbReadExistingTrackListIndividualAsync(editorialPlaylists);
//            //await TestDbReadExistingTrackListParallelAsync(editorialPlaylists);
//            //await TestDbReadExistingTrackListBatchAsync(editorialPlaylists);

//            await TestSaveTracksAttributeAsync(editorialPlaylists, tracks);

//            Console.WriteLine();
//        }

//        private async Task TestSaveTracksAttributeAsync(List<EditorialPlaylist> editorialPlaylists, Dictionary<int, List<SpotifyTrack>> tracks)
//        {
//            Stopwatch swTrackAttributes = Stopwatch.StartNew();
//            Console.WriteLine("TestSaveTracksAttributeAsync");

//            var joinedTracks = tracks.Join(editorialPlaylists, pair => pair.Key, playlist => playlist.ID, (pair, playlist) =>
//                new
//                {
//                    SpotifyUri = playlist.SpotifyLink,
//                    Tracks = pair.Value
//                });
//            var spotifyPlaylistTracks = joinedTracks.GroupBy(k => k.SpotifyUri)
//                .ToDictionary(k => k.Key.Uri, v => v.First().Tracks);
//            await editorialPlaylists.Select(e => e.SpotifyLink).Distinct().ForEachAsync(100, async spotifyPlaylist =>
//            {
//                List<SpotifyTrack> spotifyTracks;
//                if (!spotifyPlaylistTracks.TryGetValue(spotifyPlaylist.Uri, out spotifyTracks))
//                    spotifyTracks = new List<SpotifyTrack>();

//                try
//                {
//                    await _updatePlaylistInfoTask.SaveTracksAttributeAsync(spotifyPlaylist, spotifyTracks, "");
//                }
//                catch (Exception ex)
//                {
//                    Console.WriteLine("Exception: " + ex);
//                }
//            });

//            swTrackAttributes.Stop();
//            Console.WriteLine("Done TestSaveTracksAttributeAsync in {0} seconds.", swTrackAttributes.Elapsed.TotalSeconds);
//        }

//        private async Task TestSaveSpotifyPlaylistImageAsync(List<PlaylistResponse> spotifyPlaylists)
//        {
//            Stopwatch swImages = Stopwatch.StartNew();

//            Console.WriteLine("TestSaveSpotifyPlaylistImageAsync");
//            int spotifyImageUpdates = 0;

//            await spotifyPlaylists.ForEachAsync(20, async playlistResponse =>
//            {
//                var image = playlistResponse.images.FirstOrDefault();
//                if (image != null)
//                {
//                    await TrySaveImageAsync(image, new SpotifyLink(playlistResponse.uri));
//                    Interlocked.Increment(ref spotifyImageUpdates);
//                }
//            });
//            Console.WriteLine("Done TestSaveSpotifyPlaylistImageAsync in {0} seconds with {1} images", swImages.Elapsed.TotalSeconds, spotifyImageUpdates);

//            swImages.Stop();
//        }

//        private async Task<string> TrySaveImageAsync(Image spotifyImage, SpotifyLink spotifyLink)
//        {
//            string filename = null;
//            try
//            {
//                var cacheKey = "PlaylistImageStored-1.1:" + spotifyLink.Uri;
//                filename = null;//_distributedCacheHandler.Get(cacheKey) as string;
//                if (filename == null)
//                {
//                    //_logger.Debug("Saving image for playlist {0} with url {1}", spotifyLink.Uri, spotifyImage.url);

//                    var imageDataTask = await new HttpClient().GetStreamAsync(spotifyImage.url);

//                    using (var image = System.Drawing.Image.FromStream(imageDataTask))
//                    using (var output = new MemoryStream())
//                    {
//                        filename = "playlist-" + spotifyLink.ExtractPlaylistID() + ".jpeg";

//                        image.Save(output, ImageFormat.Jpeg);
//                        await _imageFactory.SaveImageAsync(filename, output);
//                    }

//                    _distributedCacheHandler.Put(cacheKey, filename, DateTime.Now.AddDays(1));
//                }
//                else
//                {
//                    //_logger.Debug("Not storing image for playlist {0} since we have a recent version", spotifyLink.Uri);
//                }
//            }
//            catch (Exception ex)
//            {
//                //_logger.Error(ex, "Could not get image for {0}. Exception: {1}", spotifyImage.url, ex.ToString());
//            }
//            return filename;
//        }


//        private async Task TestDbReadExistingTrackListIndividualAsync(List<EditorialPlaylist> editorialPlaylists)
//        {
//            Stopwatch swTrackList = Stopwatch.StartNew();
//            Console.WriteLine("TestDbReadExistingTrackListAsync");

//            foreach (var editorialPlaylist in editorialPlaylists)
//            {
//                Console.WriteLine("editorialPlaylist:" + editorialPlaylist.ID);
//                var tracks = await _editorialPlaylistManager.GetTracksAsync(editorialPlaylist.AsEnumerable().ToList());
//            }


//            swTrackList.Stop();
//            Console.WriteLine("Done TestDbReadExistingTrackListAsync in {0} seconds", swTrackList.Elapsed.TotalSeconds);
//        }

//        private async Task TestDbReadExistingTrackListParallelAsync(List<EditorialPlaylist> editorialPlaylists)
//        {
//            Stopwatch swTrackList = Stopwatch.StartNew();
//            Console.WriteLine("TestDbReadExistingTrackListParallelAsync");

//            await editorialPlaylists.ForEachAsync(100, async editorialPlaylist =>
//            {
//                Console.WriteLine("editorialPlaylist:" + editorialPlaylist.ID);
//                var tracks = await _editorialPlaylistManager.GetTracksAsync(editorialPlaylist.AsEnumerable().ToList());
//            });


//            swTrackList.Stop();
//            Console.WriteLine("Done TestDbReadExistingTrackListParallelAsync in {0} seconds", swTrackList.Elapsed.TotalSeconds);
//        }

//        private async Task TestDbReadExistingTrackListBatchAsync(List<EditorialPlaylist> editorialPlaylists)
//        {
//            Stopwatch swTrackList = Stopwatch.StartNew();
//            Console.WriteLine("TestDbReadExistingTrackListBatchAsync");

//            var tracks = await _editorialPlaylistManager.GetTracksAsync(editorialPlaylists);


//            swTrackList.Stop();
//            Console.WriteLine("Done TestDbReadExistingTrackListBatchAsync in {0} seconds", swTrackList.Elapsed.TotalSeconds);
//        }

//        private async Task TestDbUpdateCallsOnlyAsync(List<EditorialPlaylist> editorialPlaylists)
//        {
//            Stopwatch swDbOnly = Stopwatch.StartNew();
//            Console.WriteLine("TestDbUpdateCallsOnlyAsync");
//            await editorialPlaylists.ForEachAsync(100, async playlist =>
//            {
//                Console.WriteLine(playlist.ID);

//                await _editorialPlaylistManager.UpdateSpotifyFieldsAsync(playlist);
//            });
//            swDbOnly.Stop();
//            Console.WriteLine("Done TestDbUpdateCallsOnlyAsync in {0} seconds", swDbOnly.Elapsed.TotalSeconds);
//        }

//        private async Task TestDbContentCallsOnlyAsync(List<EditorialPlaylist> editorialPlaylists,
//            Dictionary<int, List<SimilarArtistMatch>> allArtists, Dictionary<int, List<GenreMatch>> allTags,
//            Dictionary<int, List<SpotifyTrack>> allTracks)
//        {
//            Stopwatch swDbOnly = Stopwatch.StartNew();
//            Console.WriteLine("TestDbContentCallsOnlyAsync");
//            await editorialPlaylists.ForEachAsync(100, async playlist =>
//            {
//                Console.WriteLine(playlist.ID);
//                List<SpotifyTrack> playlistTracks;
//                if (allTracks.TryGetValue(playlist.ID, out playlistTracks))
//                {
//                    playlistTracks = new List<SpotifyTrack>();
//                }

//                List<SimilarArtistMatch> playlistArtists;
//                if (allArtists.TryGetValue(playlist.ID, out playlistArtists))
//                {
//                    playlistArtists = new List<SimilarArtistMatch>();
//                }

//                List<GenreMatch> playlistTags;
//                if (allTags.TryGetValue(playlist.ID, out playlistTags))
//                {
//                    playlistTags = new List<GenreMatch>();
//                }
//                if (playlistArtists != null && playlistTags != null && playlistTracks != null)
//                {
//                    await
//                        _editorialPlaylistManager.SetEditorialPlaylistContentAsync(playlist, playlistArtists,
//                            playlistTags, playlistTracks);
//                }

//            });
//            swDbOnly.Stop();
//            Console.WriteLine("Done TestDbContentCallsOnlyAsync in {0} seconds", swDbOnly.Elapsed.TotalSeconds);
//        }

//        private async Task TestDbContentCallsOnlyAsync(List<EditorialPlaylist> editorialPlaylists,
//            Dictionary<int, List<SpotifyTrack>> allTracks)
//        {
//            Stopwatch swDbOnly = Stopwatch.StartNew();
//            Console.WriteLine("TestDbContentCallsOnlyAsync");
//            await editorialPlaylists.ForEachAsync(100, async playlist =>
//            {
//                Console.WriteLine(playlist.ID);
//                List<SpotifyTrack> playlistTracks;
//                if (allTracks.TryGetValue(playlist.ID, out playlistTracks))
//                {
//                    playlistTracks = new List<SpotifyTrack>();
//                }
//                await
//                    _editorialPlaylistManager.SetEditorialPlaylistContentAsync(playlist, playlist.Artists,
//                        playlist.Genres, playlistTracks);
//            });
//            swDbOnly.Stop();
//            Console.WriteLine("Done TestDbContentCallsOnlyAsync in {0} seconds", swDbOnly.Elapsed.TotalSeconds);
//        }

//        private const string playlistFields =
//            "uri,name,description,images.url,tracks.total,tracks.items.added_at,tracks.items.track(artists.name,artists.uri,name,duration_ms,uri,external_ids.isrc,popularity,album.name,album.uri)";

//        private const string trackFields =
//            "items.added_at,items.track(artists.name,artists.uri,name,duration_ms,uri,external_ids.isrc,popularity,album.name,album.uri),total";

//        private async Task<List<PlaylistResponse>> TestSpotifyCallsOnlyAsync(IEnumerable<SpotifyLink> spotifyPlaylistUris)
//        {
//            int counter = 0;
//            ServicePointManager.DefaultConnectionLimit = 100;
//            Console.WriteLine("TestSpotifyCallsOnlyAsync");

//            List<PlaylistResponse> playlists = new List<PlaylistResponse>();
//            Stopwatch swSpotifyOnly = Stopwatch.StartNew();

//            await spotifyPlaylistUris.ForEachAsync(100, async link =>
//            {
//                try
//                {
//                    var userName = link.ExtractSpotifyPlaylistUserName();
//                    var playlistId = link.ExtractPlaylistID();

//                    Console.WriteLine("Start" + link.Uri);

//                    var playlist = await _spotifyWebApi.GetPlaylistAsync(userName, playlistId, playlistFields);

//                    Console.WriteLine("Done " + link.Uri);
//                    if (playlist.Tracks.total > 100)
//                    {
//                        Console.WriteLine("Start Tracks" + link.Uri);
//                        var playlistTracks =
//                            await _spotifyWebApi.GetAllPlaylistTracksAsync(userName, playlistId, trackFields);
//                        Console.WriteLine("Done Tracks" + link.Uri);
//                    }

//                    playlists.Add(playlist);
//                }
//                catch (Exception ex)
//                {
//                    Console.WriteLine("Failed" + link.Uri);
//                }

//                Interlocked.Increment(ref counter);
//            });
//            swSpotifyOnly.Stop();
//            Console.WriteLine("Done with TestSpotifyCallsOnlyAsync in {0} seconds", swSpotifyOnly.Elapsed.TotalSeconds);
//            return playlists;
//        }
//    }
//}