use std::fmt::Display;

use crate::router::AppState;

use axum::extract::{FromRef, FromRequestParts, Query, State};

use axum::headers::authorization::Basic;
use axum::headers::{Authorization, Cookie};
use axum::http::request::Parts;
use axum::http::StatusCode;

use axum::response::{ErrorResponse, IntoResponse, Redirect};
use axum::routing::get;
use axum::{async_trait, Json, RequestPartsExt, Router, TypedHeader};

use como_domain::users::User;
use como_infrastructure::register::ServiceRegister;

use serde::Deserialize;
use serde_json::json;

#[derive(Debug, Deserialize)]
pub struct ZitadelAuthParams {
    #[allow(dead_code)]
    return_url: Option<String>,
}

trait AnyhowExtensions<T, E>
where
    E: Display,
{
    fn into_response(self) -> Result<T, ErrorResponse>;
}
impl<T, E> AnyhowExtensions<T, E> for anyhow::Result<T, E>
where
    E: Display,
{
    fn into_response(self) -> Result<T, ErrorResponse> {
        match self {
            Ok(o) => Ok(o),
            Err(e) => {
                tracing::error!("failed with anyhow error: {}", e);
                Err(ErrorResponse::from((
                    StatusCode::INTERNAL_SERVER_ERROR,
                    Json(json!({
                        "status": "something",
                    })),
                )))
            }
        }
    }
}

pub async fn zitadel_auth(
    State(services): State<ServiceRegister>,
) -> Result<impl IntoResponse, ErrorResponse> {
    let url = services.auth_service.login().await.into_response()?;

    Ok(Redirect::to(&url.to_string()))
}

#[derive(Debug, Deserialize)]
#[allow(dead_code)]
pub struct AuthRequest {
    code: String,
    state: String,
}

pub async fn login_authorized(
    Query(query): Query<AuthRequest>,
    State(services): State<ServiceRegister>,
) -> Result<impl IntoResponse, ErrorResponse> {
    let (headers, url) = services
        .auth_service
        .login_authorized(&query.code, &query.state)
        .await
        .into_response()?;

    Ok((headers, Redirect::to(url.as_str())))
}

pub struct AuthController;

impl AuthController {
    pub async fn new_router(
        _service_register: ServiceRegister,
        app_state: AppState,
    ) -> anyhow::Result<Router> {
        Ok(Router::new()
            .route("/zitadel", get(zitadel_auth))
            .route("/authorized", get(login_authorized))
            .with_state(app_state))
    }
}

pub struct UserFromSession {
    pub user: User,
}

pub static COOKIE_NAME: &str = "SESSION";

#[async_trait]
impl<S> FromRequestParts<S> for UserFromSession
where
    ServiceRegister: FromRef<S>,
    S: Send + Sync,
{
    type Rejection = (StatusCode, &'static str);

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        let services = ServiceRegister::from_ref(state);

        let cookie: Option<TypedHeader<Cookie>> = parts.extract().await.unwrap();
        let session_cookie = cookie.as_ref().and_then(|cookie| cookie.get(COOKIE_NAME));
        if let None = session_cookie {
            let basic: Option<TypedHeader<Authorization<Basic>>> = parts.extract().await.unwrap();

            if let Some(basic) = basic {
                let token = services
                    .auth_service
                    .login_token(basic.username(), basic.password())
                    .await
                    .into_response()
                    .map_err(|_| {
                        (
                            StatusCode::INTERNAL_SERVER_ERROR,
                            "could not get token from basic",
                        )
                    })?;

                return Ok(UserFromSession {
                    user: User { id: token },
                });
            }

            return Err(anyhow::anyhow!("No session was found"))
                .into_response()
                .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "did not find a cookie"))?;
        }

        let session_cookie = session_cookie.unwrap();

        // continue to decode the session cookie
        let user = services
            .auth_service
            .get_user_from_session(session_cookie)
            .await
            .into_response()
            .map_err(|_| {
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    "failed to decode session cookie",
                )
            })?;

        Ok(UserFromSession {
            user: User { id: user.id },
        })
    }
}