use std::io::Write;

use bytes::Bytes;

use http::header::AUTHORIZATION;

use http::header::{HeaderValue, AUTHORIZATION, CONTENT_TYPE};

use self::private::AuthDeserialize;

}
#[derive(Clone, Debug, Deserialize)]
#[non_exhaustive]
pub struct AccessToken2 {
    pub access_token: Box<str>,

impl<T: de::DeserializeOwned, F: HttpTryFuture> AuthFuture<T, F> {

impl<T: AuthDeserialize, F: HttpTryFuture> AuthFuture<T, F> {

impl<T: de::DeserializeOwned, F: HttpTryFuture> Future for AuthFuture<T, F> {

impl<T: AuthDeserialize, F: HttpTryFuture> Future for AuthFuture<T, F> {

        let data = serde_urlencoded::from_bytes(&res.data).map_err(|_| Error::Unexpected)?;

        let data = T::deserialize(res.data).ok_or(Error::Unexpected)?;

impl AuthDeserialize for Credentials<Box<str>> {
    fn deserialize(input: Bytes) -> Option<Self> {
        serde_urlencoded::from_bytes(&input).ok()
    }
}
impl AuthDeserialize for AccessToken {
    fn deserialize(input: Bytes) -> Option<Self> {
        serde_urlencoded::from_bytes(&input).ok()
    }
}
impl AuthDeserialize for AccessToken2 {
    fn deserialize(input: Bytes) -> Option<Self> {
        serde_json::from_slice(&input).ok()
    }
}

pub fn token<C, S, B>(
    client_credentials: &Credentials<C>,
    client: &mut S,
) -> AuthFuture<AccessToken2, S::Future>
where
    C: AsRef<str>,
    S: HttpService<B>,
    B: From<&'static [u8]>,
{
    let req = token_request(client_credentials.as_ref());
    AuthFuture::new(client.call(req.map(Into::into)))
}
fn token_request(client_credentials: Credentials<&str>) -> http::Request<&'static [u8]> {
    const URI: &str = "https://api.twitter.com/oauth2/token";
    let authorization = basic_auth(client_credentials);
    let application_www_form_urlencoded =
        HeaderValue::from_static("application/x-www-form-urlencoded");
    http::Request::post(Uri::from_static(URI))
        .header(AUTHORIZATION, authorization)
        .header(CONTENT_TYPE, application_www_form_urlencoded)
        .body(&b"grant_type=client_credentials"[..])
        .unwrap()
}
fn basic_auth(credentials: Credentials<&str>) -> String {
    let b64len = (credentials.identifier.len() + credentials.secret.len()) / 3 * 4 + 4;
    let mut authorization = String::with_capacity("Basic ".len() + b64len);
    authorization.push_str("Basic ");
    let mut enc = base64::write::EncoderStringWriter::from(authorization, base64::STANDARD);
    enc.write_all(credentials.identifier.as_bytes()).unwrap();
    enc.write_all(b":").unwrap();
    enc.write_all(credentials.secret.as_bytes()).unwrap();
    enc.into_inner()
}
mod private {
    use bytes::Bytes;
    pub trait AuthDeserialize: Sized {
        fn deserialize(input: Bytes) -> Option<Self>;
    }
}

base64 = "0.13"