mod handlers;
mod db;
mod errors;

use warp::{
    Filter,
    Rejection,
    Reply,
    body
};

#[macro_use]
extern crate log;
extern crate env_logger;

use u_lib::{
    MASTER_PORT,
    api::Paths,
    models::*
};
use db::*;
use serde::{
    de::DeserializeOwned
};
use uuid::Uuid;

fn get_content<M>()
        -> impl Filter<Extract = (BaseMessage<'static, M>,),
        Error = Rejection> + Clone
where
    M: ToMsg + Sync + Send + DeserializeOwned + 'static
{
    body::content_length_limit(1024*64)
        .and(body::json::<BaseMessage<M>>())
}


#[tokio::main]
async fn main() {
    env_logger::init();

    let base_db = UDB::new().unwrap();
    let db = warp::any().map(move || base_db.clone());

    let new_client = warp::post()
        .and(warp::path(Paths::init))
        .and(get_content::<IAgent>())
        .and(db.clone())
        .and_then(handlers::add_agent);

    let get_agents = warp::get()
        .and(warp::path(Paths::get_agents))
        .and(db.clone())
        .and_then(handlers::get_agents);

    let upload_jobs = warp::post()
        .and(warp::path(Paths::upload_jobs))
        .and(get_content::<Vec<JobMeta>>())
        .and(db.clone())
        .and_then(handlers::upload_jobs);

    let get_jobs = warp::get()
        .and(warp::path(Paths::get_jobs))
        .and(warp::path::param::<Option<Uuid>>())
        .and(db.clone())
        .and_then(handlers::get_jobs);

    let get_agent_jobs = warp::get()
        .and(warp::path(Paths::get_agent_jobs))
        .and(warp::path::param::<Option<Uuid>>())
        .and(db.clone())
        .and_then(handlers::get_agent_jobs);

    let del = warp::get()
        .and(warp::path(Paths::del))
        .and(warp::path::param::<Uuid>())
        .and(db.clone())
        .and_then(handlers::del);
/*
    let set_jobs = warp::post()
        .and(warp::path(Paths::set_jobs))
        .and(warp::path::param::<Uuid>().map(Some))
        .and(get_content::<JobMetaStorage>())
        .and(db.clone())
        .and_then(handlers::set_jobs);

    let get_job_results = warp::get()
        .and(warp::path(Paths::get_job_results))
        .and(warp::path::param::<Uuid>())
        .and(db.clone())
        .and_then(handlers::get_job_results);

    let report = warp::post()
        .and(warp::path(Paths::report))
        .and(get_content::<Vec<JobResult>>())
        .and(db.clone())
        .and_then(handlers::report);
*/
    let auth_token = warp::header::exact("authorization", "Bearer 123qwe");

    let agent_zone = new_client
        .or(get_agent_jobs)
//        .or(report)
        ;

    let auth_zone = auth_token
        .and(get_agents
                 .or(get_jobs)
                 .or(upload_jobs)
                 .or(del)
//            .or(set_jobs)
//            .or(get_job_results)
        );

    let routes = auth_zone
        .or(agent_zone);
    warp::serve(routes.with(warp::log("warp")))
        .run(([0,0,0,0], MASTER_PORT)).await;
}


#[cfg(test)]
mod tests {
    use super::*;
/*
    #[tokio::test]
    async fn test_gather() {
    }
*/
}