using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using MoreLinq;
using NLog;
using PetaPoco;
using PetaPoco.Business;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.DistributedCaching;
using Sony.Filtr.PlaylistGeneration;
using Sony.Filtr.PlaylistSynchronization.Data;
using Sony.Filtr.PlaylistSynchronization.Synchronizer;
using Sony.Filtr.SpotifyWebAPI;

namespace Sony.Filtr.PlaylistSynchronization
{
    public class FlaggedChannelsManager
    {
        private readonly DistributedCacheHandler _distributedCacheHandler;

        public FlaggedChannelsManager(DistributedCacheHandler distributedCacheHandler)
        {
            _distributedCacheHandler = distributedCacheHandler;
        }

        public List<string> GetWhitelistedChannels()
        {
            return GetFlaggedChannels(ChannelFlagType.Whitelist).Select(c => c.ChannelId).ToList();
        }

        public List<string> GetBlacklistedChannels()
        {
            return GetFlaggedChannels(ChannelFlagType.Blacklist).Select(c => c.ChannelId).ToList();
        }

        public List<FlaggedChannel> GetFlaggedChannels(ChannelFlagType flagType)
        {
            var channels = _distributedCacheHandler.Get(GetFlaggedCacheKey()) as List<FlaggedChannel>;

            if (channels == null)
            {
                channels = PetaPocoRepository.ReadOnlyInstance.Fetch<FlaggedChannel>();

                _distributedCacheHandler.Put(GetFlaggedCacheKey(), channels);
            }

            return channels.Where(c => c.FlagType == flagType).ToList();
        }

        private FlaggedChannel GetFlaggedChannel(string channelId, ChannelFlagType flagType)
        {
            var channels = GetFlaggedChannels(flagType);

            return
                channels.FirstOrDefault(channel => channel.ChannelId.Equals(channelId, StringComparison.CurrentCultureIgnoreCase));
        }

        public void DeleteWhitelistedChannel(string channelId)
        {
            DeleteFlaggedChannel(channelId, ChannelFlagType.Whitelist);
        }

        public void DeleteBlacklistedChannel(string channelId)
        {
            DeleteFlaggedChannel(channelId, ChannelFlagType.Blacklist);
        }

        public void DeleteFlaggedChannel(string channelId, ChannelFlagType flagType)
        {
            var channel = GetFlaggedChannel(channelId, flagType);

            if (channel != null)
                PetaPocoRepository.Instance.Delete<FlaggedChannel>(channel);

            ClearCache();
        }

        public void AddWhitelistedChannel(string channelId)
        {
            AddFlaggedChannel(channelId, ChannelFlagType.Whitelist);
        }

        public void AddBlacklistedChannel(string channelId)
        {
            AddFlaggedChannel(channelId, ChannelFlagType.Blacklist);
        }

        public FlaggedChannel AddFlaggedChannel(string channelId, ChannelFlagType flagType)
        {
            var existingChannel = GetFlaggedChannel(channelId, flagType);

            if (existingChannel != null)
                return existingChannel;

            var newId = PetaPocoRepository.Instance.Insert(new FlaggedChannel() {ChannelId = channelId});

            ClearCache();

            return PetaPocoRepository.ReadOnlyInstance.Single<FlaggedChannel>(newId);
        }

        private string GetFlaggedCacheKey()
        {
            return "PlaylistSync_Whitelisting";
        }

        private void ClearCache()
        {
            _distributedCacheHandler.Remove(GetFlaggedCacheKey());
        }
    }
}