use actix::System;
use actix_web::client::Client;
use failure::Fail;
use futures::future::{lazy, Future};
use http_signature_normalization_actix::prelude::*;
use sha2::{Digest, Sha256};

fn main() {
    System::new("client-example")
        .block_on(lazy(|| {
            let config = Config::default();
            let mut digest = Sha256::new();

            Client::default()
                .post("http://127.0.0.1:8010/")
                .header("User-Agent", "Actix Web")
                .authorization_signature_with_digest(
                    &config,
                    "my-key-id",
                    &mut digest,
                    "Hewwo-owo",
                    |s| Ok(base64::encode(s)) as Result<_, MyError>,
                )
                .unwrap()
                .send()
                .map_err(|_| ())
                .and_then(|mut res| res.body().map_err(|_| ()))
                .map(|body| {
                    println!("{:?}", body);
                })
        }))
        .unwrap();
}

#[derive(Debug, Fail)]
pub enum MyError {
    #[fail(display = "Failed to read header, {}", _0)]
    Convert(#[cause] ToStrError),

    #[fail(display = "Failed to create header, {}", _0)]
    Header(#[cause] InvalidHeaderValue),
}

impl From<ToStrError> for MyError {
    fn from(e: ToStrError) -> Self {
        MyError::Convert(e)
    }
}

impl From<InvalidHeaderValue> for MyError {
    fn from(e: InvalidHeaderValue) -> Self {
        MyError::Header(e)
    }
}