using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.LastModified;
using Sony.Filtr.DistributedCaching;
using System;
using System.Collections.Generic;
using System.Linq;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities.Genre;

namespace Sony.Filtr.Core.Genres
{
    public class GenreManager
    {
        private readonly GenreFactory _genreFactory;
        private readonly DistributedCacheHandler _cacheHandler;
        private readonly LastModifiedManager _lastModifiedManager;

        public GenreManager(GenreFactory factory, DistributedCacheHandler cacheHandler, LastModifiedManager lastModifiedManager)
        {
            _genreFactory = factory;
            _cacheHandler = cacheHandler;
            _lastModifiedManager = lastModifiedManager;
        }

        public Genre SaveGenre(Genre genre)
        {
            var addedGenre = _genreFactory.SaveGenre(genre);
            _lastModifiedManager.SetLastModifyDate(genre.ApplicationID, EntityType.Genres);
            ClearCache(addedGenre);

            return addedGenre;
        }

        public void DeleteGenre(Genre genre)
        {
            _genreFactory.DeleteGenre(genre);

            _lastModifiedManager.SetLastModifyDate(genre.ApplicationID, EntityType.Genres);
            ClearCache(genre);
        }

        public IEnumerable<GenreMatch> MatchGenres(ILookup<string, Genre> genres, List<Tag> tags)
        {
            List<GenreMatch> matchingGenres = new List<GenreMatch>();

            if (tags == null || !tags.Any())
                return matchingGenres;

            if (genres == null || !genres.Any())
                return matchingGenres;

            tags = tags.Where(t => t.Score > 0).ToList();
            foreach (var tag in tags)
            {
                var tagName = tag.Name.ToLower();
                if (genres.Contains(tagName))
                {
                    var genre = genres[tagName].First();
                    matchingGenres.Add(new GenreMatch(genre.Name, (int)tag.Score));
                }
            }
            return matchingGenres;
        }

        public IEnumerable<GenreMatch> MatchGenres(Application application, List<Tag> tags)
        {
            var genres = GetGenres(application).ToLookup(g => g.LastFMTag.ToLower());
            return MatchGenres(genres, tags);            
        }

        public List<RankedItem<Genre>> MatchTags(IEnumerable<Genre> genres, List<Tag> tags)
        {
            tags = tags.Where(t => t.Score > 0).ToList();
            var joined = tags.Join(genres, tag => tag.Name, applicationTag => applicationTag.LastFMTag, (tag, genre) => new RankedItem<Genre>(genre, (int)tag.Score), StringComparer.InvariantCultureIgnoreCase).ToList();
            return joined;
        }

        public List<RankedItem<Genre>> MatchTags(Application application, List<Tag> tags)
        {
            return MatchTags(GetGenres(application), tags);
        }

        public List<Genre> GetGenres(Application application)
        {
            var cacheKey = GetCacheKeyGenres(application);
            var genres = _cacheHandler.Get(cacheKey) as List<Genre>;
            if (genres == null)
            {
                genres = _genreFactory.GetGenres(application);
                _cacheHandler.Put(cacheKey, genres.ToList());
            }
            return genres;
        }
        
        public Genre GetGenre(Application application, string genreName)
        {
            var existingGenres = GetGenres(application);
            var genre = existingGenres.FirstOrDefault(g => g.Name.Equals(genreName, StringComparison.CurrentCultureIgnoreCase));
            return genre;
        }

        public void ClearCache(Genre genre)
        {
            _cacheHandler.Remove(GetCacheKeySingleGenre(genre.ID));
            _cacheHandler.Remove(GetCacheKeyGenres());
            _cacheHandler.Remove(GetCacheKeyGenres(new Application() { ID = genre.ApplicationID }));
        }

        private string GetCacheKeySingleGenre(int genreID)
        {
            return "Filtr.Genre:" + "1.1:" + typeof(Genre) + ":" + genreID.ToString();
        }

        private static string GetCacheKeyGenres()
        {
            return "Filtr.Genres-" + "1.2" + typeof(Genre);
        }

        private static string GetCacheKeyGenres(Application application)
        {
            var appKeyPart = (application != null) ? application.ID.ToString() : "null";

            return "Filtr.LocalGenres-1.2:" + typeof(Genre) + appKeyPart;
        }

        public List<GenreCategory> GetGenreCategories()
        {
            var cacheKey = GetCacheKeyGenreCategories();
            List<GenreCategory> genreCategories = _cacheHandler.Get(cacheKey) as List<GenreCategory>;
            if (genreCategories == null)
            {
                genreCategories = _genreFactory.GetGenreCategories();
                _cacheHandler.Put(cacheKey, genreCategories);
            }
            return genreCategories;
        }

        public GenreCategory SaveGenreCategory(GenreCategory genreCategory)
        {
            genreCategory = _genreFactory.SaveGenreCategory(genreCategory);
            _lastModifiedManager.SetLastModifyDate(null, EntityType.Genres);
            ClearCache(genreCategory);
            return genreCategory;
        }

        public GenreCategory GetGenreCategory(int id)
        {
            var cacheKey = GetCacheKeyGenreCategory(id);
            var genreCategory = _cacheHandler.Get(cacheKey) as GenreCategory;
            if (genreCategory == null)
            {
                genreCategory = _genreFactory.GetGenreCategory(id);
                _cacheHandler.Put(cacheKey, genreCategory);
            }
            return genreCategory;
        }

        public void DeleteGenreCategory(GenreCategory genreCategory)
        {
            _genreFactory.DeleteGenreCategory(genreCategory);
            ClearCache(genreCategory);
        }

        public void ClearCache(GenreCategory genreCategory)
        {
            _cacheHandler.Remove(GetCacheKeyGenreCategories());
            _cacheHandler.Remove(GetCacheKeyGenreCategory(genreCategory.ID));
        }

        private string GetCacheKeyGenreCategory(int id)
        {
            return "GenreCategory:" + typeof(GenreCategory) + ":" + GenreCategory.Version + ":" + id;
        }

        private string GetCacheKeyGenreCategories()
        {
            return "GenreCategories:" + typeof(GenreCategory) + ":" + GenreCategory.Version;
        }
    }
}