using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.Factory;
using Sony.Filtr.Core.LastModified;
using Sony.Filtr.DistributedCaching;

namespace Sony.Filtr.Core.EditorialPlaylists
{
    public class PlaylistCategoryManager
    {
        private readonly IApplicationInstanceManager _applicationInstanceManager;
        private readonly PlaylistCategoryFactory _playlistCategoryFactory;
        private readonly DistributedCacheHandler _cacheHandler;
        private readonly ImageFactory _imageFactory;
        private readonly LastModifiedManager _lastModifiedManager;

        public PlaylistCategoryManager(IApplicationInstanceManager applicationInstanceManager, PlaylistCategoryFactory playlistCategoryFactory, DistributedCacheHandler distributedCacheHandler, ImageFactory imageFactory, LastModifiedManager lastModifiedManager)
        {
            _applicationInstanceManager = applicationInstanceManager;
            _playlistCategoryFactory = playlistCategoryFactory;
            _cacheHandler = distributedCacheHandler;
            _imageFactory = imageFactory;
            _lastModifiedManager = lastModifiedManager;
        }

        public List<PlaylistCategory> GetCategories(Application application)
        {
            var cacheKey = GetCategoryListCacheKey(application.ID);
            List<PlaylistCategory> categores = _cacheHandler.Get(cacheKey) as List<PlaylistCategory>;
            if (categores == null)
            {
                categores =  _playlistCategoryFactory.GetPlaylistCategories(application);
                _cacheHandler.Put(cacheKey, categores);
            }
            return categores;
        }

        public PlaylistCategory SaveCategory(PlaylistCategory playlistCategory)
        {
            var existingPlaylists = GetPlaylists(playlistCategory);

            var category = _playlistCategoryFactory.SaveCategory(playlistCategory);

            ClearCache(category, existingPlaylists);
            SetCategoriesLastModified(category);

            return category;
        }
        
        public PlaylistCategory GetCategory(int id)
        {
            return _playlistCategoryFactory.GetCategory(id);
        }

        public void DeleteCategory(PlaylistCategory category)
        {
            var existingPlaylists = GetPlaylists(category);

            _playlistCategoryFactory.DeleteCategory(category);
            
            ClearCache(category, existingPlaylists);
            SetCategoriesLastModified(category);
        }

        public List<PlaylistCategory> GetCategories(EditorialPlaylist playlist)
        {
            var cacheKey = GetPlaylistCategoriesCacheKey(playlist.ID);
            var categories = _cacheHandler.Get(cacheKey) as List<PlaylistCategory>;
            if (categories == null)
            {
                categories = _playlistCategoryFactory.GetCategories(playlist);
                _cacheHandler.Put(cacheKey, categories);
            }
            return categories;
        }


        public async Task<Dictionary<int, List<PlaylistCategory>>> GetCategoriesAsync(IEnumerable<EditorialPlaylist> playlists)
        {
            Dictionary<int, List<PlaylistCategory>> playlistCategories = new Dictionary<int, List<PlaylistCategory>>();

            List<EditorialPlaylist> nonCachedPlaylists = new List<EditorialPlaylist>();
            foreach (var playlist in playlists)
            {
                var cacheKey = GetPlaylistCategoriesCacheKey(playlist.ID);
                var categories = _cacheHandler.Get(cacheKey) as List<PlaylistCategory>;
                if (categories != null)
                {
                    playlistCategories.Add(playlist.ID, categories);
                }
                else
                {
                    nonCachedPlaylists.Add(playlist);
                }
            }
            
            if (nonCachedPlaylists.Any())
            {
                var nonCachedPlaylistCategories = await _playlistCategoryFactory.GetCategoriesAsync(nonCachedPlaylists);
                foreach (var nonCachedPlaylist in nonCachedPlaylistCategories)
                {
                    var cacheKey = GetPlaylistCategoriesCacheKey(nonCachedPlaylist.Key);
                    _cacheHandler.Put(cacheKey, nonCachedPlaylist.Value);
                    playlistCategories.Add(nonCachedPlaylist.Key, nonCachedPlaylist.Value);
                }
            }
            return playlistCategories;
        }

        public void SetCategories(EditorialPlaylist playlist, List<PlaylistCategory> categories)
        {
            _playlistCategoryFactory.SetCategories(playlist, categories);
            ClearCache(playlist);
            SetPlaylistLastModified(playlist);
        }

        private void SetPlaylistLastModified(EditorialPlaylist playlist)
        {
            _lastModifiedManager.SetLastModifyDate(playlist.ApplicationID, EntityType.Playlists);
            if (playlist.ApplicationID == _applicationInstanceManager.GetGlobalPushApplication().ID)
            {
                _lastModifiedManager.SetLastModifyDate(null, EntityType.Playlists);
            }
                
        }

        private void SetCategoriesLastModified(PlaylistCategory category)
        {
            _lastModifiedManager.SetLastModifyDate(category.ApplicationId, EntityType.PlaylistCategories);
            if (category.ApplicationId == _applicationInstanceManager.GetGlobalPushApplication().ID)
            {
                _lastModifiedManager.SetLastModifyDate(null, EntityType.PlaylistCategories);
            }
                
        }


        private void ClearCache(PlaylistCategory category, List<EditorialPlaylist> playlists)
        {
            _cacheHandler.Remove(GetCategoryListCacheKey(category.ApplicationId));
            foreach (var editorialPlaylist in playlists)
            {
                ClearCache(editorialPlaylist);
            }
        }

        private void ClearCache(EditorialPlaylist playlist)
        {
            _cacheHandler.Remove(GetPlaylistCategoriesCacheKey(playlist.ID));
        }
        private string GetCategoryListCacheKey(int applicationId)
        {
            return "AllPlaylistCategories-" + typeof(PlaylistCategory) + ":" + PlaylistCategory.Version + ":" + applicationId;
        }

        private string GetPlaylistCategoriesCacheKey(int playlistId)
        {
            return "CategoriesForPlaylist-" + typeof(PlaylistCategory) + ":" + PlaylistCategory.Version + ":" + playlistId;
        }

        public List<EditorialPlaylist> GetPlaylists(PlaylistCategory existingCategory)
        {
            return _playlistCategoryFactory.GetPlaylists(existingCategory);
        }

        public PlaylistCategory SetIcon(PlaylistCategory playlistCategory, Stream requestStream)
        {
            string fileName = playlistCategory.Icon;
            if (!string.IsNullOrWhiteSpace(fileName))
                _imageFactory.DeleteImage(fileName);

            fileName = GenerateIconFileName();
            _imageFactory.SavePlaylistCategoryIcon(fileName, requestStream);
            playlistCategory.Icon = fileName;

            playlistCategory = SaveCategory(playlistCategory);

            return playlistCategory;
        }

        private string GenerateIconFileName()
        {
            return string.Format("icon-{0}.png", Guid.NewGuid());
        }

        public PlaylistCategoryIcon GetIcon(int id)
        {
            return GetIcons().FirstOrDefault(i => i.ID == id);
        }

        public List<PlaylistCategoryIcon> GetIcons()
        {
            var cacheKey = GetCategoryIconCacheKey();
            List<PlaylistCategoryIcon> icons = _cacheHandler.Get(cacheKey) as List<PlaylistCategoryIcon>;

            if (icons == null)
            {
                icons = _playlistCategoryFactory.GetIcons();
                _cacheHandler.Put(cacheKey, icons);
            }
            
            return icons;
        }

        private string GetCategoryIconCacheKey()
        {
            return "AllPlaylistCategoryIcons-" + typeof(PlaylistCategoryIcon) + ":" + PlaylistCategoryIcon.Version;
        }

        public PlaylistCategoryIcon SaveIcon(PlaylistCategoryIcon icon)
        {
            //icon = _playlistCategoryFactory.SaveIcon(icon);
            //_lastModifiedManager.SetLastModifyDate(null, EntityType.PlaylistCategoryIcons);
            //ClearCache(icon);
            return new PlaylistCategoryIcon();
        }

        private void ClearCache(PlaylistCategoryIcon category)
        {
            var cacheKey = GetCategoryIconCacheKey();
            _cacheHandler.Remove(cacheKey);
        }

        public void DeleteIcon(PlaylistCategoryIcon icon)
        {
            _playlistCategoryFactory.DeleteIcon(icon);

            _lastModifiedManager.SetLastModifyDate(null, EntityType.PlaylistCategoryIcons);

            ClearCache(icon);
        }

    }
}