impl<T> Future for CacheFuture<T>
where
    T: Debug + DeserializeOwned,
{
    type Item = T;
    type Error = ClientError;

    fn poll(&mut self) -> Result<Async<Self::Item>, Self::Error> {
        let cache = self.cache.lock().unwrap();
        let url = self.url.clone();
        let url2 = url.clone();
        let req = match &self.api_key {
            //Riot api request
            Some(api_key) => {
                dbg!("got api key: {}", api_key);
                Request::builder()
                    .header("X-Riot-Token", HeaderValue::from_str(api_key).unwrap())
                    .uri(url)
                    .body(Body::from(""))
                    .unwrap()
            }
            //DDragon request
            None => Request::builder().uri(url).body(Body::from("")).unwrap(),
        };
        match cache.get(&url2) {
            Some(resp) => {
                let deserialized: T = serde_json::from_str(resp).unwrap();
                return Ok(Async::Ready(deserialized));
            }
            None => {
                dbg!("got no cache");
                dbg!("beginning poll");
                match self.client.request(req).poll() {
                    Ok(Async::Ready(resp)) => {
                        dbg!("ready");
                        let body = resp.into_body();
                        match body.concat2().poll() {
                            Ok(Async::Ready(chunk)) => {
                                dbg!("ready");
                                let string_resp = String::from_utf8(chunk.to_vec()).unwrap();
                                let deserialized: T = serde_json::from_str(&string_resp).unwrap();
                                return Ok(Async::Ready(deserialized));
                            }
                            Ok(Async::NotReady) => {
                                dbg!("not ready");
                                return Ok(Async::NotReady);
                            }
                            Err(e) => {
                                dbg!(&e);
                                return Err(ClientError::Other { source: e });
                            }
                        }
                    }
                    Ok(Async::NotReady) => {
                        dbg!("not ready");
                        return Ok(Async::NotReady);
                    }
                    Err(e) => {
                        dbg!(&e);
                        return Err(ClientError::Other { source: e });
                    }
                }
            }
        }
    }
}