use authdb::{AuthDB, Username};
use std::{
    net::{IpAddr, Ipv4Addr, SocketAddr},
    path::PathBuf,
    sync::{Arc, RwLock},
};
use warp::{header, Filter};

fn with_authentication(
    auth_ctx: Arc<RwLock<AuthDB>>,
) -> impl Filter<Extract = (Username,), Error = warp::Rejection> + Clone {
    header("authentication").map(|value: String| {
        println!("value: {:?}", value);
        Username::from("savanni")
    })
}

#[tokio::main]
pub async fn main() {
    let auth_db = AuthDB::new(PathBuf::from("./auth_db.sqlite"))
        .await
        .expect("AuthDB should initialize");
    let auth_ctx: Arc<RwLock<AuthDB>> = Arc::new(RwLock::new(auth_db));

    let echo_unauthenticated = warp::path!("api" / "v1" / "echo" / String).map(|param: String| {
        println!("param: {}", param);
        warp::reply::json(&vec!["unauthenticated", param.as_str()])
    });

    let authenticate = warp::path!("api" / "v1" / "auth" / String).map(|param: String| {
        println!("param: {}", param);
        warp::reply::json(&param)
    });

    let echo_authenticated = warp::path!("api" / "v1" / "echo" / String)
        .and(with_authentication(auth_ctx.clone()))
        .map(|param: String, username: Username| {
            println!("param: {:?}", username);
            println!("param: {}", param);
            warp::reply::json(&vec!["authenticated", username.as_str(), param.as_str()])
        });

    let filter = echo_authenticated.or(authenticate).or(echo_unauthenticated);

    let server = warp::serve(filter);
    server
        .run(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8001))
        .await;
}