public void AddOrUpdate(CacheKey key, TimedEntityTagHeaderValue eTag)
        {
            TimedEntityTagHeaderValue test;
            if (!TryGetValue(key, out test))
            {
                var cacheKey = new PersistentCacheKey
                {
                    Hash = key.Hash,
                    RoutePattern = key.RoutePattern,
                    CustomEtag = eTag.Tag,
                    LastModified = eTag.LastModified,
                    ResourceUri = key.ResourceUri
                };

                _session.Store(cacheKey);
            }
            else
            {
                var cacheKey = _session.Query<PersistentCacheKey>()
                    .Customize(x => x.WaitForNonStaleResults())
                    .FirstOrDefault(x => x.Hash == key.Hash);

                cacheKey.CustomEtag = eTag.Tag;
                cacheKey.LastModified = eTag.LastModified;
                cacheKey.ResourceUri = key.ResourceUri;
                cacheKey.RoutePattern = key.RoutePattern;
                _session.Store(cacheKey);
            }
        }

        public void AddOrUpdate(CacheKey key, TimedEntityTagHeaderValue eTag)
        {
            TimedEntityTagHeaderValue test;
            if (!TryGetValue(key, out test))
            {
                var cacheKey = new PersistentCacheKey
                {
                    Hash = key.Hash,
                    RoutePattern = key.RoutePattern,
                    ETag = eTag.Tag,
                    LastModified = eTag.LastModified
                };

                using (var connection = new MongoEntiryStoreConnection(this.connectionString))
                {
                    connection.DocumentStore.Save(cacheKey);
                }
            }
            else
            {
                using (var connection = new MongoEntiryStoreConnection(this.connectionString))
                {
                    var cacheKey = connection.DocumentStore.AsQueryable().FirstOrDefault(x => x.Hash == key.Hash);
                    if (cacheKey != null)
                    {
                        cacheKey.ETag = eTag.Tag;
                        cacheKey.LastModified = eTag.LastModified;
                        connection.DocumentStore.Save(cacheKey);
                    }
                }
            }
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            string uri = request.RequestUri.ToString();
            IEnumerable<string> varyHeaders;
            if(!VaryHeaderStore.TryGetValue(uri, out varyHeaders))
            {
                varyHeaders = DefaultVaryHeaders;
            }
            var cacheKey = new CacheKey(uri,
                request.Headers.Where(x=> varyHeaders.Any(y=> y.Equals(x.Key,
                    StringComparison.CurrentCultureIgnoreCase)))
                    .SelectMany(z=>z.Value)
                );

            HttpResponseMessage response;
            if(_cacheStore.TryGetValue(cacheKey, out response))
            {
                response.RequestMessage = request;
                var taskCompletionSource = new TaskCompletionSource<HttpResponseMessage>();
                taskCompletionSource.SetResult(response);
                return taskCompletionSource.Task;
            }
            // TODO: ..... REST)

            return base.SendAsync(request, cancellationToken);
        }

        public void AddOrUpdate(CacheKey key, TimedEntityTagHeaderValue eTag)
        {
            TimedEntityTagHeaderValue test;
            if (!TryGetValue(key, out test))
            {
                var cacheKey = new PersistentCacheKey()
                {
                    Hash = key.Hash,
                    RoutePattern = key.RoutePattern,
                    ETag = eTag.Tag,
                    LastModified = eTag.LastModified
                };
                using (var session = _documentStore.OpenSession())
                {
                    session.Store(cacheKey);
                    session.SaveChanges();
                }

            }
            else
            {
                using (var session = _documentStore.OpenSession())
                {
                    var cacheKey =
                        session.Query<PersistentCacheKey>()
                        .Customize(x => x.WaitForNonStaleResults())
                        .FirstOrDefault(x => x.Hash == key.Hash);
                    cacheKey.ETag = eTag.Tag;
                    cacheKey.LastModified = eTag.LastModified;
                    session.Store(cacheKey);
                    session.SaveChanges();
                }
            }
        }

        public void AddTest()
        {
            var cacheKey = new CacheKey("/api/Cars", new[] { "1234", "abcdef" });
            var documentStore = new EmbeddableDocumentStore()
            {
                RunInMemory = true
            }.Initialize();

            new RavenDocumentsByEntityName().Execute(documentStore);

            var store = new RavenDbEntityTagStore(documentStore);
            var value = new TimedEntityTagHeaderValue("\"abcdef1234\"") { LastModified = DateTime.Now };

            // first remove them
            store.RemoveAllByRoutePattern(cacheKey.RoutePattern);

            // add
            store.AddOrUpdate(cacheKey, value);

            // get
            TimedEntityTagHeaderValue dbValue;
            store.TryGetValue(cacheKey, out dbValue);

            Assert.AreEqual(value.Tag, dbValue.Tag);
            Assert.AreEqual(value.LastModified.ToString(), dbValue.LastModified.ToString());
        }

		public bool TryGetValue(CacheKey key, out TimedEntityTagHeaderValue eTag)
		{
			eTag = null;
			using (var connection = new SqlConnection(this._connectionString))
			using (var command = new SqlCommand())
			{
				connection.Open();
				command.Connection = connection;
				command.CommandText = this.GetStoredProcedureName(StoredProcedureNames.GetCache);
				command.CommandType = CommandType.StoredProcedure;
				command.Parameters.AddWithValue(ColumnNames.CacheKeyHash, key.Hash);

				using (var reader = command.ExecuteReader( CommandBehavior.CloseConnection))
				{
					if(!reader.HasRows)
						return false;

					reader.Read(); // there must be only one record

					eTag= new TimedEntityTagHeaderValue((string) reader[ColumnNames.ETag])
					      	{
					      		LastModified = DateTime.SpecifyKind((DateTime)reader[ColumnNames.LastModified], DateTimeKind.Utc)
					      	};
					return true;
				}
			}
		}

        // TODO: !!! routePattern implementation needs to be changed to Cas
        public void AddOrUpdate(CacheKey key, TimedEntityTagHeaderValue eTag)
        {
            // add item
            _memcachedClient.ExecuteStore(StoreMode.Set, key.HashBase64, eTag.ToString());

            // add route pattern if not there
            string keyForRoutePattern = GetKeyForRoutePattern(key.RoutePattern);
            string keyForResourceUri = GetKeyForResourceUri(key.ResourceUri);
            var routePatternEntries = GetRoutePatternEntries(key.RoutePattern);
            var resourceUriEntries = GetResourceUriEntries(key.ResourceUri);

            if (!routePatternEntries.Contains(key.HashBase64))
            {
                var bytes = new List<byte>();
                foreach (var routePatternEntry in routePatternEntries)
                {
                    bytes.AddRange(new LengthedPrefixedString(routePatternEntry).ToByteArray());
                }
                bytes.AddRange(new LengthedPrefixedString(key.HashBase64).ToByteArray());
                _memcachedClient.ExecuteStore(StoreMode.Set, keyForRoutePattern, bytes.ToArray());

            }

            if (!resourceUriEntries.Contains(key.HashBase64))
            {
                var bytes = new List<byte>();
                foreach (var routePatternEntry in resourceUriEntries)
                {
                    bytes.AddRange(new LengthedPrefixedString(routePatternEntry).ToByteArray());
                }
                bytes.AddRange(new LengthedPrefixedString(key.HashBase64).ToByteArray());
                _memcachedClient.ExecuteStore(StoreMode.Set, keyForResourceUri, bytes.ToArray());

            }
        }

        public void AddOrUpdate(CacheKey key, HttpResponseMessage response)
        {
            // removing reference to request so that the request can get GCed
            response.RequestMessage = null;

            _responseCache.AddOrUpdate(key, response, (ky, resp) => resp);
        }

		public void UpdateTest()
		{
			var cacheKey = new CacheKey("/api/Cars", new[] { "1234", "abcdef" });
			var store = new SqlServerEntityTagStore();
			var value = new TimedEntityTagHeaderValue("\"abcdef1234\"") { LastModified = DateTime.Now };


			// first remove them
			store.RemoveAllByRoutePattern(cacheKey.RoutePattern);

			// add
			store.AddOrUpdate(cacheKey, value);

			// get
			TimedEntityTagHeaderValue dbValue;
			store.TryGetValue(cacheKey, out dbValue);

			value.LastModified = DateTime.Now.AddDays(-1);

			// update
			store.AddOrUpdate(cacheKey, value);

			// get
			TimedEntityTagHeaderValue dbValue2;
			store.TryGetValue(cacheKey, out dbValue2);

			Assert.AreEqual(dbValue.Tag, dbValue2.Tag);
			Assert.Greater(dbValue.LastModified, dbValue2.LastModified);
			Console.WriteLine(dbValue2.Tag);
			Console.WriteLine(dbValue2.LastModified);
		}

		public static void TestCacheInvalidationForPost(string method)
		{
		    const string relatedUrl = "http://api/SomeLocationUrl/";
			// setup
			var locationUrl = new Uri(relatedUrl);
			var mocks = new MockRepository();
			var request = new HttpRequestMessage(new HttpMethod(method), TestUrl);
			string routePattern = "http://myserver/api/stuffs/*";
			var entityTagStore = mocks.StrictMock<IEntityTagStore>();

			var cachingHandler = new CachingHandler(new HttpConfiguration(), entityTagStore)
			{
				
			};
			var entityTagKey = new CacheKey(TestUrl, new string[0], routePattern);
			var response = new HttpResponseMessage();
			response.Headers.Location = locationUrl;
			var invalidateCacheForPost = cachingHandler.PostInvalidationRule(entityTagKey, request, response);
			if(method == "POST")
			{
                entityTagStore.Expect(x => x.RemoveAllByRoutePattern("/SomeLocationUrl/")).Return(1);				
			}
			mocks.ReplayAll();

			// run
			invalidateCacheForPost();

			// verify
			mocks.VerifyAll();

			
		}

        public static void AddCaching(string method,
			bool existsInStore,
			bool addVaryHeader,
			bool addLastModifiedHeader,
			bool alreadyHasLastModified,
			string[] varyByHeader)
        {
            // setup
            var mocks = new MockRepository();
            var request = new HttpRequestMessage(new HttpMethod(method), TestUrl);
            request.Headers.Add(HttpHeaderNames.Accept, "text/xml");
            request.Headers.Add(HttpHeaderNames.AcceptLanguage, "en-GB");
            var entityTagStore = mocks.StrictMock<IEntityTagStore>();
            var entityTagHeaderValue = new TimedEntityTagHeaderValue("\"12345678\"");
            var cachingHandler = new CachingHandler(entityTagStore, varyByHeader)
            {
                AddLastModifiedHeader = addLastModifiedHeader,
                AddVaryHeader = addVaryHeader,
                ETagValueGenerator = (x,y) => entityTagHeaderValue
            };

            var entityTagKey = new CacheKey(TestUrl, new[] {"text/xml", "en-GB"}, TestUrl + "/*");

            entityTagStore.Expect(x => x.TryGetValue(Arg<CacheKey>.Matches(etg => etg.ResourceUri == TestUrl),
                out Arg<TimedEntityTagHeaderValue>.Out(entityTagHeaderValue).Dummy)).Return(existsInStore);

            if (!existsInStore)
            {
                entityTagStore.Expect(
                    x => x.AddOrUpdate(Arg<CacheKey>.Matches(etk => etk == entityTagKey),
                        Arg<TimedEntityTagHeaderValue>.Matches(ethv => ethv.Tag == entityTagHeaderValue.Tag)));
            }

            var response = new HttpResponseMessage();
            response.Content = new ByteArrayContent(new byte[0]);
            if (alreadyHasLastModified)
                response.Content.Headers.Add(HttpHeaderNames.LastModified, DateTimeOffset.Now.ToString("r"));

            var cachingContinuation = cachingHandler.AddCaching(entityTagKey, request, response, request.Headers);
            mocks.ReplayAll();

            // run
            cachingContinuation();

            // verify

            // test kast modified only if it is GET and PUT
            if (addLastModifiedHeader && method.IsIn("PUT", "GET"))
            {
                Assert.That(response.Content.Headers.Any(x => x.Key == HttpHeaderNames.LastModified),
                    "LastModified does not exist");
            }
            if (!addLastModifiedHeader && !alreadyHasLastModified)
            {
                Assert.That(!response.Content.Headers.Any(x => x.Key == HttpHeaderNames.LastModified),
                    "LastModified exists");
            }
            mocks.VerifyAll();
        }

		public void AddOrUpdate(CacheKey key, HttpResponseMessage response)
		{
			var memoryStream = new MemoryStream();
		    Task.Factory.StartNew(() => _serializer.SerializeAsync(response.ToTask(), memoryStream).Wait()).Wait(); // offloading
		    memoryStream.Position = 0;
		    var data = memoryStream.ToArray();
		    _database.StringSet(key.HashBase64, data);
		}

 public void AddOrUpdate(CacheKey key, TimedEntityTagHeaderValue eTag)
 {
     cache.Put(key.HashBase64, eTag.ToString(), new[]
                                        {
                                            new DataCacheTag(key.ResourceUri),
                                            new DataCacheTag(key.RoutePattern),
                                        }, CacheRegion);
 }

        public void AddOrUpdate(CacheKey key, HttpResponseMessage response)
        {
            var ms = new MemoryStream();

            this.serializer.SerializeAsync(TaskHelpers.FromResult(response), ms)
                .Wait();

            this.cache.Add(key.HashBase64, ms.ToArray(), CacheRegion);
        }

        public void AddOrUpdate(CacheKey key, HttpResponseMessage response)
        {
            var ms = new MemoryStream();

            _serializer.SerializeAsync(TaskHelpers.FromResult(response), ms)
                .Wait();

            _memcachedClient.ExecuteStore(StoreMode.Set, key.HashBase64, ms.ToArray());
        }

		public bool TryGetValue(CacheKey key, out TimedEntityTagHeaderValue eTag)
		{
            var cacheObject = _cache.Get(key.HashBase64, _regionName) as string;

			if (!TimedEntityTagHeaderValue.TryParse(cacheObject, out eTag))
				return false;

			return true;
		}

 public void AddOrUpdate(CacheKey key, HttpResponseMessage response)
 {
     // removing reference to request so that the request can get GCed
     var req = response.RequestMessage;
     response.RequestMessage = null;
     var memoryStream = new MemoryStream();
     _messageSerializer.SerializeAsync(TaskHelpers.FromResult(response), memoryStream).Wait();
     response.RequestMessage = req;
     _responseCache.AddOrUpdate(key, memoryStream.ToArray(), (ky, old) => memoryStream.ToArray());
 }

 public void AddOrUpdate(CacheKey key, TimedEntityTagHeaderValue eTag)
 {
     _eTagCache.AddOrUpdate(key, eTag, (theKey, oldValue) => eTag);
     _routePatternCache.AddOrUpdate(key.RoutePattern, new HashSet<CacheKey>() { key },
         (routePattern, hashSet) =>
         {
             hashSet.Add(key);
             return hashSet;
         });
 }

 public bool TryGetValue(CacheKey key, out HttpResponseMessage response)
 {
     response = null;
     var result = _responseCache.Get(key.HashBase64);
     if (result!=null)
     {
         response = _messageSerializer.DeserializeToResponseAsync(new MemoryStream((byte[])result)).Result;
     }
     return result!=null;
 }

 public void AddOrUpdate(CacheKey key, HttpResponseMessage response)
 {
     // removing reference to request so that the request can get GCed
     var req = response.RequestMessage;
     response.RequestMessage = null;
     var memoryStream = new MemoryStream();
     Task.Factory.StartNew(() => _messageSerializer.SerializeAsync(TaskHelpers.FromResult(response), memoryStream)).Wait();
     response.RequestMessage = req;
     _responseCache.Set(key.HashBase64, memoryStream.ToArray(), GetExpiry(response));
 }