using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.DistributedCaching;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Sony.Filtr.Core.Blacklists
{
    public class BlacklistManager
    {
        private readonly DistributedCacheHandler _cacheHandler;
        private readonly BlacklistFactory _blacklistFactory;

        public BlacklistManager(DistributedCacheHandler distributedCacheHandler, BlacklistFactory blacklistFactory)
        {
            _cacheHandler = distributedCacheHandler;
            _blacklistFactory = blacklistFactory;
        }

        public bool IsBlackListed(Application application, Artist artist)
        {
            return (GetBlacklistedArtist(application, artist.Name) != null);
        }

        public BlacklistedArtist GetBlacklistedArtist(Application application, string artistName)
        {
            return GetBlacklistedArtists(application).FirstOrDefault(ba => string.Equals(ba.ArtistName, artistName, StringComparison.InvariantCultureIgnoreCase));
        }

        public BlacklistedArtist GetBlacklistedArtist(int blacklistArtistID)
        {
            return GetBlacklistedArtists(null).FirstOrDefault(a => a.ID == blacklistArtistID);
        }

        public IEnumerable<BlacklistedArtist> GetBlacklistedArtists(Application application)
        {
            var cacheKey = GetBlackListCacheKey(application);
            IEnumerable<BlacklistedArtist> artists = (IEnumerable<BlacklistedArtist>)_cacheHandler.Get(cacheKey);
            if (artists == null)
            {
                artists = _blacklistFactory.GetBlacklistedArtists(application);
                _cacheHandler.Put(cacheKey, artists.ToList());
            }
            return artists;
        }

        private static string GetBlackListCacheKey(Application application)
        {
            var cacheKey = "BlacklistedArtists:" + typeof(BlacklistedArtist) + ":" + BlacklistedArtist.Version + ":" + (application != null ? application.ID.ToString() : "null");
            return cacheKey;
        }

        public BlacklistedArtist SaveBlacklistedArtists(BlacklistedArtist artist)
        {
            if (artist.ID == default(int))
                artist = _blacklistFactory.AddBlacklistedArtists(artist);
            else
                _blacklistFactory.UpdateBlacklistedArtists(artist);

            ClearCache(artist);
            return artist;
        }

        public void DeleteBlacklistedArtists(BlacklistedArtist artist)
        {
            _blacklistFactory.DeleteBlacklistedArtists(artist);
            ClearCache(artist);
        }

        private void ClearCache(BlacklistedArtist artist)
        {
            _cacheHandler.Remove(GetBlackListCacheKey(new Application() { ID = artist.ApplicationID }));
            _cacheHandler.Remove(GetBlackListCacheKey(null));
        }
    }
}