using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using CacheCow.Client;
using CacheCow.Common;

namespace Sony.Filtr.DistributedCaching
{
    public interface IRedisCacheStore : CacheCow.Common.ICacheStore { }

    public class RedisCacheStore : IRedisCacheStore
    {
        private readonly IGenericCacheProvider _cacheProvider;
        private readonly IHttpMessageSerializerAsync _serializer = new MessageContentHttpMessageSerializer();


        public RedisCacheStore(IGenericCacheProvider cacheProvider)
        {
            this._cacheProvider = cacheProvider;
        }

        public async Task AddOrUpdateAsync(CacheKey key, HttpResponseMessage response)
        {
            var ms = new MemoryStream();
            await _serializer.SerializeAsync(response, ms);

            this._cacheProvider.Set(key.HashBase64, ms.ToArray());
        }

        public Task ClearAsync()
        {
            this._cacheProvider.Clear();

            return Task.FromResult(1);
        }

        public void Dispose()
        {
        }

        public async Task<HttpResponseMessage> GetValueAsync(CacheKey key)
        {
            var result = this._cacheProvider.Get<byte[]>(key.HashBase64);
            if (result != null)
            {
                var ms = new MemoryStream(result);
                var response = await _serializer.DeserializeToResponseAsync(ms);

                return response;
            }

            return null;
        }

        public Task<bool> TryRemoveAsync(CacheKey key)
        {
            return Task.FromResult(this._cacheProvider.Remove(key.HashBase64));
        }
    }
}