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

namespace Sony.Filtr.DistributedCaching
{
    public class DistributedCachingStore : CacheCow.Common.ICacheStore
    {
        private readonly DistributedCacheHandler _distributedCacheHandler;
        private readonly IHttpMessageSerializerAsync _serializer = new MessageContentHttpMessageSerializer();

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

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

            return null;
        }

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

            _distributedCacheHandler.Put(key.HashBase64, ms.ToArray());
        }

        public async Task<bool> TryRemoveAsync(CacheKey key)
        {
            _distributedCacheHandler.Remove(key.HashBase64);
            return true;
        }

        public async Task ClearAsync()
        {
            //    //We are in a shared keyspace so we do no flushing
            //    return;
        }

        public void Dispose()
        {
        }
    }
}