use axum::{
    http::{header::CACHE_CONTROL, HeaderValue},
    routing::{get, post},
    Router,
};
use tower::ServiceBuilder;
use tower_http::{
    services::{ServeDir, ServeFile},
    set_header::SetResponseHeaderLayer,
};

use crate::{app_state::AppState, auth, routes};

pub fn new_router(state: AppState) -> Router<()> {
    let base_path = state.settings.base_path.clone();
    let app = Router::new()
        .route("/databases", get(routes::bases::list_bases_page))
        .route("/databases/add", post(routes::bases::add_base_page))
        .route(
            "/d/{base_id}/config",
            get(routes::bases::base_config_page_get),
        )
        .route(
            "/d/{base_id}/config",
            post(routes::bases::base_config_page_post),
        )
        .route(
            "/d/{base_id}/relations",
            get(routes::relations::list_relations_page),
        )
        .route(
            "/d/{base_id}/r/{class_oid}/viewer",
            get(routes::relations::viewer_page),
        )
        .nest("/auth", auth::new_router())
        .layer(SetResponseHeaderLayer::if_not_present(
            CACHE_CONTROL,
            HeaderValue::from_static("no-cache"),
        ))
        .nest_service(
            "/js_dist",
            ServiceBuilder::new()
                .layer(SetResponseHeaderLayer::if_not_present(
                    CACHE_CONTROL,
                    HeaderValue::from_static("max-age=21600, stale-while-revalidate=86400"),
                ))
                .service(
                    ServeDir::new("js_dist").not_found_service(
                        ServiceBuilder::new()
                            .layer(SetResponseHeaderLayer::if_not_present(
                                CACHE_CONTROL,
                                HeaderValue::from_static("no-cache"),
                            ))
                            .service(ServeFile::new("static/_404.html")),
                    ),
                ),
        )
        .fallback_service(
            ServiceBuilder::new()
                .layer(SetResponseHeaderLayer::if_not_present(
                    CACHE_CONTROL,
                    HeaderValue::from_static("max-age=21600, stale-while-revalidate=86400"),
                ))
                .service(
                    ServeDir::new("static").not_found_service(
                        ServiceBuilder::new()
                            .layer(SetResponseHeaderLayer::if_not_present(
                                CACHE_CONTROL,
                                HeaderValue::from_static("no-cache"),
                            ))
                            .service(ServeFile::new("static/_404.html")),
                    ),
                ),
        )
        .with_state(state);
    if base_path.is_empty() {
        app
    } else {
        Router::new().nest(&base_path, app).fallback_service(
            ServeDir::new("static").not_found_service(ServeFile::new("static/_404.html")),
        )
    }
}

// #[derive(Deserialize)]
// struct RbacIndexPath {
//     oid: u32,
// }
//
// async fn rbac_index(
//     State(Settings {
//         base_path,
//         pg_user_role_prefix: role_prefix,
//         ..
//     }): State<Settings>,
//     DieselConn(diesel_conn): DieselConn,
//     PgConn(pg_client): PgConn,
//     CurrentUser(current_user): CurrentUser,
//     Path(params): Path<RbacIndexPath>,
// ) -> Result<Response, AppError> {
//     pg_set_role(&role_prefix, &current_user.id, &pg_client, &diesel_conn)
//         .await
//         .context("failed to set tokio_postgres role")?;
//
//     struct UserDetails {
//         user: User,
//         roles: Vec<String>,
//     }
//     let all_users = {
//         let role_prefix = role_prefix.clone();
//         diesel_conn
//             .interact(move |conn| -> Result<_> {
//                 let pg_users: Vec<PgRole> =
//                     .get_results(conn)
//                     .context("failed to query pg users with database access")?;
//                 let user_ids: Vec<Uuid> = pg_users
//                     .iter()
//                     .filter_map(|role| {
//                         let mut rolname = role.rolname.clone();
//                         rolname.replace_range(0..role_prefix.len(), "");
//                         Uuid::parse_str(&rolname).ok()
//                     })
//                     .collect();
//                 let all_users: Vec<User> = users::table
//                     .filter(users::dsl::id.eq_any(user_ids))
//                     .get_results(conn)
//                     .context("failed to query users with database access")?;
//                 Ok(all_users)
//             })
//             .await
//             .unwrap()?
//     };
//     #[derive(Template)]
//     #[template(path = "rbac.html")]
//     struct ResponseTemplate {
//         base_path: String,
//         role_prefix: String,
//         users: Vec<UserDetails>,
//     }
//
//     Ok(Html(
//         ResponseTemplate {
//             base_path,
//             role_prefix,
//             users: all_users
//                 .into_iter()
//                 .map(|user| UserDetails {
//                     user,
//                     roles: vec![],
//                 })
//                 .collect(),
//         }
//         .render()?,
//     )
//     .into_response())
// }