use async_trait::async_trait;
use crate::Context;
use crate::Error;
use crate::model::ErrorBody;
use crate::model::ErrorsBody;
use crate::model::OAuth2Data;
use crate::model::Token;
use crate::model::UnsafeToken;

pub enum LoginError {
    Error400(ErrorsBody),
    Error401(ErrorBody),
    Error500(ErrorBody),
}

#[async_trait]
pub trait LoginClient {
    async fn v_2_oauth_2_post(&self, provider: &str, access_token: &str) -> Result<UnsafeToken, Error<LoginError>>;
    async fn v_2_login_token_get(&self) -> Result<Token, Error<LoginError>>;
    async fn login_oauth_2_device_start_post(&self) -> Result<OAuth2Data, Error<LoginError>>;
    async fn login_oauth_2_device_complete_post(&self, value: &str) -> Result<UnsafeToken, Error<LoginError>>;
}

pub struct LoginClientLive {
    pub context: Context,
}

#[async_trait]
impl LoginClient for LoginClientLive {
    async fn v_2_oauth_2_post(&self, provider: &str, access_token: &str) -> Result<UnsafeToken, Error<LoginError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("oauth2");

        url.query_pairs_mut().append_pair("provider", &provider);

        url.query_pairs_mut().append_pair("access-token", &access_token);

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/oauth2", url=url.to_string(), "v_2_oauth_2_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<UnsafeToken>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(LoginError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error401(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn v_2_login_token_get(&self) -> Result<Token, Error<LoginError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("login")
            .push("token");

        let mut request = self
            .context
            .client
            .get(url.clone());

        {
            tracing::info!(method="get", endpoint="/v2/login/token", url=url.to_string(), "v_2_login_token_get");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<Token>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(LoginError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error401(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn login_oauth_2_device_start_post(&self) -> Result<OAuth2Data, Error<LoginError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("login")
            .push("oauth2")
            .push("device")
            .push("start");

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/login/oauth2/device/start", url=url.to_string(), "login_oauth_2_device_start_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<OAuth2Data>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(LoginError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error401(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn login_oauth_2_device_complete_post(&self, value: &str) -> Result<UnsafeToken, Error<LoginError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("login")
            .push("oauth2")
            .push("device")
            .push("complete");

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/login/oauth2/device/complete", url=url.to_string(), body=?value, "login_oauth_2_device_complete_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        request = request.json(value);

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<UnsafeToken>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(LoginError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error401(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(LoginError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }
}