using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using NLog;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Contracts.Entities.Genre;
using Sony.Filtr.PlaylistGeneration.Data;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.PlaylistGeneration.Caching
{
    public class MultiplexCacheProvider : ICacheProvider
    {
        private readonly List<ICacheProvider> _cacheProviders;
        private readonly ICacheProvider _fastCacheProvider;
        private readonly DbCacheProvider _dbCacheProvider;
        private readonly Logger _logger;

        public MultiplexCacheProvider(DistributedCacheProvider distributedCacheProvider, DbCacheProvider dbCacheProvider)
        {
            _cacheProviders = new List<ICacheProvider>();

            _cacheProviders.Add(distributedCacheProvider);
            _cacheProviders.Add(dbCacheProvider);

            _fastCacheProvider = distributedCacheProvider;
            _dbCacheProvider = dbCacheProvider;

            _logger = LogManager.GetLogger("TrackSuggestionManager2");
        }

        public List<SimilarArtistMatch> FetchSimilarArtistsFromCache(string artistName)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var similarArtists = cacheProvider.FetchSimilarArtistsFromCache(artistName);
                if (similarArtists != null && similarArtists.Any())
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        _fastCacheProvider.CacheSimilarArtists(new Artist(artistName), similarArtists);
                    
                    return similarArtists;
                }
            }
            return null;
        }

        public void CacheSimilarArtists(Artist artist, List<SimilarArtistMatch> similarArtists)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                cacheProvider.CacheSimilarArtists(artist, similarArtists);
            }
        }

        public void CacheArtist(Artist artist)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                cacheProvider.CacheArtist(artist);
            }
        }

        public Artist FetchArtistFromCache(string artistName)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var result = cacheProvider.FetchArtistFromCache(artistName);
                if (result != null)
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        _fastCacheProvider.CacheArtist(result);

                    return result;
                }
            }
            return null;
        }

        public async Task<List<Artist>> FetchArtistsFromCacheAsync(List<string> artistNames)
        {
            List<Artist> artists = new List<Artist>();

            var artistResult = await _fastCacheProvider.FetchArtistsFromCacheAsync(artistNames);
            artists.AddRange(artistResult);

            var missingArtists = artistNames.Except(artistResult.Select(a=> a.Name), StringComparer.InvariantCultureIgnoreCase).ToList();
            if (missingArtists.Any())
            {
                _logger.Debug("Could not find all artist tags in fastCache, doing lookup in DB for {0} artists. Some are: {1}", missingArtists.Count, string.Join(",", missingArtists.Take(5)));

                var dbArtistResults = await _dbCacheProvider.FetchArtistsFromCacheAsync(missingArtists.ToList());
                foreach (var artist in dbArtistResults)
                {
                    _fastCacheProvider.CacheArtist(artist); //Fire and forget

                    artists.Add(artist);
                }
            }
            return artists;
        }

        public void CacheGenreMatch(Application application, Artist artist, IEnumerable<GenreMatch> genres)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                cacheProvider.CacheGenreMatch(application, artist, genres);
            }
        }

        public List<GenreMatch> FetchGenreMatchFromCache(Application application, Artist artistName)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var result = cacheProvider.FetchGenreMatchFromCache(application, artistName);
                if (result != null && result.Any())
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        _fastCacheProvider.CacheGenreMatch(application, artistName, result);
                    return result;

                }
            }
            return null;
        }

        public void CacheGenreArtists(Genre genre, IEnumerable<SimilarArtistMatch> artists)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                cacheProvider.CacheGenreArtists(genre, artists);
            }
        }

        public List<SimilarArtistMatch> FetchGenreArtists(Genre genre)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var result = cacheProvider.FetchGenreArtists(genre);
                if (result != null && result.Any())
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        _fastCacheProvider.CacheGenreArtists(genre, result);
                    return result;
                }
            }
            return null;
        }

        public string GetCacheProviderName()
        {
            return "MusicMatch.PlaylistGeneration.Caching.MultiplexCacheProvider";
        }


        public void CacheArtistTags(string artist, List<Tag> tags)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                cacheProvider.CacheArtistTags(artist, tags);
            }
        }

        public async Task<List<Tag>> FetchArtistTagsFromCacheAsync(string artist)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var tags = await cacheProvider.FetchArtistTagsFromCacheAsync(artist);
                if (tags != null)
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        _fastCacheProvider.CacheArtistTags(artist, tags);

                    return tags;
                }
            }
            return null;
        }

        public async Task<Dictionary<string, List<Tag>>> FetchArtistsTagsFromCacheAsync(List<string> artists)
        {
            var artistResult = await _fastCacheProvider.FetchArtistsTagsFromCacheAsync(artists);
            var missingArtists = artists.Except(artistResult.Keys).ToList();
            if (missingArtists.Any())
            {
                _logger.Debug("Could not find all artist tags in fastCache, doing lookup in DB for {0} artists. Some are: {1}", missingArtists.Count, string.Join(",", missingArtists.Take(5)));

                var dbResults = await _dbCacheProvider.FetchArtistsTagsFromCacheAsync(missingArtists.ToList());
                foreach (var dbResult in dbResults)
                {
                    _fastCacheProvider.CacheArtistTags(dbResult.Key, dbResult.Value); //Fire and forget

                    _logger.Debug("Found in DB, adding to fastCache: {0}", dbResult.Key);
                    if (!artistResult.ContainsKey(dbResult.Key))
                    {
                        artistResult.Add(dbResult.Key, dbResult.Value);
                    }
                }
            }
            return artistResult;
            
        }


        public async Task<List<RankedItem<Track>>> FetchTopTrackForTagAsync(string tag)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var tracks = await cacheProvider.FetchTopTrackForTagAsync(tag);
                if (tracks != null && tracks.Any())
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        await _fastCacheProvider.CacheTopTrackForTagAsync(tag, tracks);

                    return tracks;
                }
            }
            return null;
        }

        public async Task CacheTopTrackForTagAsync(string tag, List<RankedItem<Track>> topTracks)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                await cacheProvider.CacheTopTrackForTagAsync(tag, topTracks);
            }
        }

        //public void CacheSearchTracks(string mood, string genre, List<RankedItem<Track>> tracks)
        //{
        //    foreach (var cacheProvider in _cacheProviders)
        //    {
        //        cacheProvider.CacheSearchTracks(mood, genre, tracks);
        //    }
        //}

        //public List<RankedItem<Track>> FetchSearchTracks(string mood, string genre)
        //{
        //    foreach (var cacheProvider in _cacheProviders)
        //    {
        //        var tracks = cacheProvider.FetchSearchTracks(mood, genre);
        //        if (tracks != null && tracks.Any())
        //        {
        //            if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
        //                _fastCacheProvider.CacheSearchTracks(mood, genre, tracks);

        //            return tracks;
        //        }
        //    }
        //    return null;
        //}

        public async Task CacheTrackTagsAsync(Track track, List<Tag> tags)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                await cacheProvider.CacheTrackTagsAsync(track, tags);
            }
        }

        public async Task<List<Tag>> FetchTrackTagsFromCacheAsync(Track track)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var tags = await cacheProvider.FetchTrackTagsFromCacheAsync(track);
                if (tags != null && tags.Any())
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        await _fastCacheProvider.CacheTrackTagsAsync(track, tags);

                    return tags;
                }
            }
            return null;
        }

        public async Task<Dictionary<string, List<ExtendedTrack>>> FetchExtendedTopTracksForArtistsAsync(List<string> artists, ServiceType serviceType)
        {
            //Dictionary<string, List<ExtendedTrack>> artistsDictionary = new Dictionary<string, List<ExtendedTrack>>();
            var artistResult = await _fastCacheProvider.FetchExtendedTopTracksForArtistsAsync(artists, serviceType);
            var missingArtists = artists.Except(artistResult.Keys, StringComparer.InvariantCultureIgnoreCase).ToList();
            if (missingArtists.Any())
            {
                _logger.Debug("Could not find all artists in fastCache, doing lookup in DB for {0} artists. Some are: {1}", missingArtists.Count, string.Join(",", missingArtists.Take(5)));

                var dbResults = await _dbCacheProvider.FetchExtendedTopTracksForArtistsAsync(missingArtists.ToList(), serviceType);
                foreach (var dbResult in dbResults)
                {
                    _fastCacheProvider.CacheExtendedTopTracksForArtistAsync(dbResult.Key, dbResult.Value, serviceType).FireAndForget();

                    artistResult.Add(dbResult.Key, dbResult.Value);
                }
            }
            return artistResult;
        }


        public async Task<List<ExtendedTrack>> FetchExtendedTopTracksForArtistAsync(string artistName, ServiceType serviceType)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var topTracks = await cacheProvider.FetchExtendedTopTracksForArtistAsync(artistName, serviceType);
                if (topTracks != null)
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        await _fastCacheProvider.CacheExtendedTopTracksForArtistAsync(artistName, topTracks, serviceType);
                    return topTracks;
                }
            }
            return null;
        }

        public async Task CacheExtendedTopTracksForArtistAsync(string artistName, List<ExtendedTrack> tracks, ServiceType serviceType)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                await cacheProvider.CacheExtendedTopTracksForArtistAsync(artistName, tracks, serviceType);
            }
        }

        //public List<RankedItem<string>> FetchArtistMood(string artistName)
        //{
        //    foreach (var cacheProvider in _cacheProviders)
        //    {
        //        var moods = cacheProvider.FetchArtistMood(artistName);
        //        if (moods != null)
        //        {
        //            if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
        //                _fastCacheProvider.CacheArtistMood(artistName, moods);
        //            return moods;
        //        }
        //    }
        //    return null;
        //}

        //public void CacheArtistMood(string artistName, List<RankedItem<string>> moods)
        //{
        //    foreach (var cacheProvider in _cacheProviders)
        //    {
        //        cacheProvider.CacheArtistMood(artistName, moods);
        //    }
        //}

        public void CacheExtendedTopTracksForTag(string tag, List<GroupedExtendedTrack> groupedExtendedTracks)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                cacheProvider.CacheExtendedTopTracksForTag(tag, groupedExtendedTracks);
            }
        }

        public List<GroupedExtendedTrack> FetchExtendedTopTracksForTag(string tag)
        {
            foreach (var cacheProvider in _cacheProviders)
            {
                var tracks = cacheProvider.FetchExtendedTopTracksForTag(tag);
                if (tracks != null)
                {
                    if (cacheProvider.GetCacheProviderName() != _fastCacheProvider.GetCacheProviderName())
                        _fastCacheProvider.CacheExtendedTopTracksForTag(tag, tracks);
                    return tracks;
                }
            }
            return null;
        }


    }
}