using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Sony.Filtr.Applications;
using Sony.Filtr.API.ViewModels;
using Sony.Filtr.API.ViewModels.v3;
using Sony.Filtr.Buzz;
using Sony.Filtr.ContentManagement;
using Sony.Filtr.ContentManagement.Data;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Contracts.Entities.Genre;
using Sony.Filtr.Core;
using Sony.Filtr.Core.Genres;
using Sony.Filtr.Core.ImageCarousel;
using Sony.Filtr.Core.LastModified;
using Sony.Filtr.Core.PromotedTracks;
using Sony.Filtr.Core.Releases;
using Sony.Filtr.Core.Settings;
using Sony.Filtr.Core.SpotifyUserCountries;
using Sony.Filtr.Core.TopLists;
using Sony.Filtr.DeezerAPI;
using Sony.Filtr.DistributedCaching;
using Sony.Filtr.Globalization.v3;
using Sony.Filtr.PlaylistGeneration;
using Sony.Filtr.PlaylistGeneration.Autocomplete;
using Sony.Filtr.Playlists;
using Sony.Filtr.Search;
using Sony.Filtr.Utility.Extensions;
using Artist = Sony.Filtr.Contracts.Entities.Artist;
using PlaylistViewModel = Sony.Filtr.API.ViewModels.v3.PlaylistViewModel;
using ReleaseViewModel = Sony.Filtr.API.ViewModels.v3.ReleaseViewModel;

namespace Sony.Filtr.API.Service
{
    public class DeezerService3 : BaseService3, IService3
    {
        private readonly DeezerReleaseManager _deezerReleaseManager;
        private readonly LastModifiedManager _lastModifiedManager;
        private readonly PlaylistGenerationManager _playlistGenerationManager;
        private readonly ImageCarouselManager _imageCarouselManager;
        private readonly ContentManager _contentManager;
        private readonly DeezerApi _deezerApi;
        private readonly SearchManager _searchManager;
        private readonly GenreManager _genreManager;
        private readonly PromotedTracksManager _promotedTracksManager;
        private readonly BuzzAccountManager _buzzAccountManager;

        public DeezerService3(DeezerReleaseManager deezerReleaseManager, 
            EditorialPlaylistManagerNew editorialPlaylistManagerNew,
            ApplicationInstanceManager applicationInstanceManager,
            LastModifiedManager lastModifiedManager, 
            MarketGlobalizationHandler marketGlobalizationHandler, 
            PlaylistGenerationManager playlistGenerationManager, 
            TrackSuggestionManager2 trackSuggestionManager2,
            ImageCarouselManager imageCarouselManager, 
            AutocompleteManager autocompleteManager, 
            DistributedCacheHandler distributedCacheHandler, 
            TopListManager topListManager,
            ContentManager contentManager, 
            DeezerApi deezerApi, 
            SearchManager searchManager, 
            GenreManager genreManager, 
            PromotedTracksManager promotedTracksManager, BuzzAccountManager buzzAccountManager, SettingsManager settingsManager)
            : base(applicationInstanceManager, marketGlobalizationHandler, lastModifiedManager, playlistGenerationManager, trackSuggestionManager2, autocompleteManager, distributedCacheHandler, topListManager, contentManager, searchManager, genreManager, settingsManager)
        {
            _deezerReleaseManager = deezerReleaseManager;
            _lastModifiedManager = lastModifiedManager;
            _playlistGenerationManager = playlistGenerationManager;
            _imageCarouselManager = imageCarouselManager;
            _contentManager = contentManager;
            _deezerApi = deezerApi;
            _searchManager = searchManager;
            _genreManager = genreManager;
            _promotedTracksManager = promotedTracksManager;
            _buzzAccountManager = buzzAccountManager;
        }

        public SeasonViewModel GetSeason(Application app)
        {
            return null;
        }

        public async Task<List<ReleaseViewModel>> GetNewReleasesAsync(Application app, string countryCode)
        {
            var releases = _deezerReleaseManager.GetReleases(app);

            var releaseViewModels = new List<ReleaseViewModel>();
            var genreCategories = _genreManager.GetGenreCategories().ToDictionary(g => g.ID, g => g.Name);
            var artists = releases.Select(a => a.ArtistName).Distinct().Select(a => new Artist(a)).ToList();
            var allArtistTags = await _playlistGenerationManager.GetArtistTagsAsync(app, artists);
            foreach (var releaseIndex in releases.ItemIndex())
            {
                var release = releaseIndex.Item;

                IEnumerable<RankedItem<Genre>> artistTags;
                if (!allArtistTags.TryGetValue(release.ArtistName, out artistTags))
                {
                    artistTags = new List<RankedItem<Genre>>();
                }
                var viewModel = ReleaseViewModel.Build(release, releaseIndex.Index, artistTags, genreCategories);
                releaseViewModels.Add(viewModel);
            }
            return releaseViewModels;
        }

        public Task<DateTime> GetNewReleasesLastModifiedDateAsync(Application application)
        {
            return _lastModifiedManager.GetLastModifyDateAsync(application, EntityType.DeezerReleases);
        }

        public async Task<IEnumerable<PlaylistViewModel>> GetPlaylistsAsync(Application app)
        {
            //var playlists = _editorialPlaylistManagerNew.GetPlaylists(app);
            //return playlists.Where(p => p.DeezerPlaylist != null).Select(p => PlaylistViewModel.BuildViewModel(p));
            return new List<PlaylistViewModel>();
        }

        public List<PlaylistCategoryViewModel> GetCategories(Application app)
        {
            return new List<PlaylistCategoryViewModel>();
        }

        public async Task<PlaylistViewModel> GetPlaylistAsync(string playlistId, bool detailedViewModels = true)
        {
            return null;
        }

        public async Task<List<PlaylistViewModel>> GetPlaylistsAsync(Application app, DateTime? lastModified = null)
        {
            return new List<PlaylistViewModel>();
        }

        public Task<List<PlaylistTrackViewModel>> GetPlaylistTracksAsync(string playlistId)
        {
            return null;
        }

        public async Task<List<TrackViewModel>> GetPromotedTracksAsync(Application app)
        {
            var promotedTracks = await _promotedTracksManager.GetPromotedTracksAsync(app);
            promotedTracks = promotedTracks.Where(p => p.ServiceType == ServiceType.Deezer).ToList();

            promotedTracks = promotedTracks.Where(HasMatchData).ToList(); //Filter in case something is missing.

            var genreCategories = _genreManager.GetGenreCategories().ToDictionary(g => g.ID, g => g.Name);
            var trackViewModels = new ConcurrentBag<TrackViewModel>();
            Parallel.ForEach(promotedTracks.ItemIndex(), promotedTrack =>
            {
                var localTags = _genreManager.MatchTags(app, promotedTrack.Item.Tags);
                var tags = localTags.Select(t => new TagViewModel(t, genreCategories));

                var trackSuggestion = new ExtendedTrackSuggestion()
                {
                    ExtendedTrack = promotedTrack.Item.ExtendedTrack,
                    Score = promotedTrack.Index
                };

                var viewModel = TrackViewModel.BuildTrackViewModel(trackSuggestion, tags, null);
                trackViewModels.Add(viewModel);
            });
            return trackViewModels.OrderBy(t => t.Match).ToList();
        }

        private bool HasMatchData(PromotedTrack promotedTrack)
        {
            return (promotedTrack.Tags != null);
        }

        public Sony.Filtr.API.ViewModels.MyJsonDictionary<string, Sony.Filtr.API.ViewModels.MyJsonDictionary<string, string>> GetGlobalization(Application app)
        {
            return new MyJsonDictionary<string, MyJsonDictionary<string, string>>();
        }

        public Dictionary<string, string> GetGlobalizationForLanguage(string language)
        {
            return new Dictionary<string, string>();
        }

        public BootstrapViewModel GetWorkoutBootstrap(Application application)
        {
            return new BootstrapViewModel();
        }

        public async Task<List<TrackViewModel>> SearchTracksAsync(Application app, string countryCode, SearchTracksParameters searchTracksParameters)
        {
            return new List<TrackViewModel>();
        }

        public async Task<EditorialPlaylist> GetEditorialPlaylistAsync(int id)
        {
            throw new NotImplementedException();
        }

        public ContentPage GetPage(Application application, string pageKey)
        {
            return _contentManager.GetPage(application, ServiceType.Deezer, pageKey);
        }

        public ServiceType ServiceType
        {
            get { return ServiceType.Deezer; }
        }

        public async Task<List<TrackViewModel>> GetTracks(Application app, string countryCode, string tag, string artist)
        {
            return await base.GetTracks(app, countryCode, tag, artist, ServiceType.Deezer);
        }


        public List<CarouselImageViewModel> GetCarouselImages(Application application)
        {
            var images = _imageCarouselManager.GetImages(application);
            var imagesToUse = images.Where(i => i.Active && i.ServiceType == ServiceType.Deezer).ToList();
            return imagesToUse.Select(CarouselImageViewModel.BuildViewModel).ToList();
        }

        public async Task<SearchResultViewModel> SearchAsync(Application application, string searchString)
        {
            var result = await _searchManager.SearchStuffAsync(application, ServiceType.Deezer, searchString);
            return await BuildSearchResultViewModelAsync(application, result);
        }

        public async Task<DateTime> GetFiltrUsersLastModifiedAsync()
        {
            return await _lastModifiedManager.GetLastModifyDateAsync(null, EntityType.FiltrUsers);
        }

        public async Task<List<FiltrUserCountryViewModel>> GetFiltrUsersAsync()
        {
            var sonyBuzzUsers = await _buzzAccountManager.GetBuzzUsersAsync((int)StaticBuzzCategory.SonyMusic, (int)MusicService.Deezer);
            return sonyBuzzUsers.Select(u => new FiltrUserCountryViewModel()
            {
                Username = u.Username,
                CountryCode = u.CountryCode,
            }).ToList();
        }

        public async Task<List<string>> GetAvailableRegionsAsync()
        {
            return new List<string>();
        }

        public async Task<DateTime> GetAvailableRegionsLastModifiedAsync()
        {
            return DateTime.Now;
        }

        private async Task<SearchResultViewModel> BuildSearchResultViewModelAsync(Application application, SearchResult searchResult)
        {
            var playlistViewModels = await GetPlaylistsAsync(application, null);
            var releaseViewModels = await GetNewReleasesAsync(application, null);

            var searchResultViewModel = new SearchResultViewModel();
            if (searchResult != null)
            {
                searchResultViewModel.Artists = searchResult.Artists;
                searchResultViewModel.Tags = searchResult.Tags;
                searchResultViewModel.Releases =
                    searchResult.Releases.Select(
                        r => releaseViewModels.FirstOrDefault(
                                ri => new SpotifyLink(r.TrackLink).ExtractTrackID() == ri.TrackId))
                        .Where(r => r != null)
                        .ToList();

                searchResultViewModel.Playlists =
                    searchResult.Playlists.Select(p => playlistViewModels.FirstOrDefault(pi => pi.Id == p.Id))
                        .Where(r => r != null)
                        .ToList();
            }
            return searchResultViewModel;
        }

        public async Task<List<string>> GetPopularTagsAsync(Application market)
        {
            var playlists = await GetPlaylistsAsync(market);
            return playlists.SelectMany(p => p.Tags)
                    .GroupBy(t => t.Label)
                    .OrderByDescending(t => t.Sum(ti => ti.Match))
                    .Select(t => t.Key)
                    .Take(25)
                    .ToList();
        }
    }
}