use axum::{
    extract::{FromRequest, Form, Json, Query},
    http::{self, Request, StatusCode},
    response::{IntoResponse, Response},
    RequestExt,
};
use axum_typed_multipart::{TryFromMultipart, TypedMultipart};

#[derive(Debug, TryFromMultipart, Deserialize)]
pub struct LoginForm {
    username: String,
    #[allow(dead_code)]
    password: String,
}

#[async_trait]
impl<S, B> FromRequest<S, B> for LoginForm
where
    Json<LoginForm>: FromRequest<(), B>,
    Form<LoginForm>: FromRequest<(), B>,
    TypedMultipart<LoginForm>: FromRequest<S, B>,
    B::Data: Into<axum::body::Bytes>,
    B::Error: Into<axum::BoxError> + Send + std::error::Error,
    B: Send + 'static + axum::body::HttpBody,
    S: Send
{
    type Rejection = Response;

    async fn from_request(req: Request<B>, _state: &S) -> Result<Self, Self::Rejection> {
        let headers = req.headers();

        if let Some(mime) = headers.get(http::header::CONTENT_TYPE).and_then(|v| v.to_str().ok()) {
            if mime.starts_with("application/json") {
                let Json(login_form): Json<LoginForm> = req.extract().await.map_err(IntoResponse::into_response)?;
                return Ok(login_form);
            }

            if mime.starts_with("application/x-www-form-urlencoded") {
                let Form(login_form) = req.extract().await.map_err(IntoResponse::into_response)?;
                return Ok(login_form);
            }

            if mime.starts_with("multipart/form-data") {
                let TypedMultipart(login_form): TypedMultipart<LoginForm> = req.extract().await.map_err(IntoResponse::into_response)?;
                return Ok(login_form);
            }
            Err(StatusCode::UNSUPPORTED_MEDIA_TYPE.into_response())
        } else {
            Err("No POST Content-Type".into_response())
        }
    }
}

#[debug_handler]
pub async fn route(form: LoginForm) -> String {
    format!("Welcome {}", form.username)
}