#[macro_use] extern crate rocket;

mod database;

use rocket::serde::json::Json;
use rocket::State;
use std::sync::Mutex;
use database::types::{Message, User, Info};


struct SharedDB {
    sdb: Mutex<database::Database>
}

#[derive(serde::Serialize)]
struct Response<T, Y> (Result<T, Y>);


#[get("/get_message/<id>")]
fn get_message(id: usize, db: &State<SharedDB>) -> Json<Response<Message, &'static str>> {
    let lock = db.sdb.lock().unwrap();
    match lock.get_message(id) {
        Some(n) => Json(Response(Ok(n))),
        None => Json(Response(Err("Message not found"))),
    }
}
#[get("/get_message_id_list/<id_start>/<id_end>")]
fn get_message_id_list(id_start: usize, id_end: usize, db: &State<SharedDB>) -> Json<Response<Vec<usize>, &'static str>> {
    let lock = db.sdb.lock().unwrap();
    let list = lock.get_message_id_list(id_start, id_end);

    if list.len() == 0 {
        Json(Response(Err("No messages")))
    } else {
        Json(Response(Ok(list)))
    }
}
#[get("/get_message_id_newest")]
fn get_message_id_newest(db: &State<SharedDB>) -> Json<Response<usize, &'static str>> {
    let lock = db.sdb.lock().unwrap();
    match lock.get_message_newest_id() {
        Some(n) => Json(Response(Ok(n))),
        None => Json(Response(Err("No messages")))
    }
}

#[get("/send_message/<user_id>/<msg>")]
fn send_message(user_id: usize, msg: String, db: &State<SharedDB>) -> Json<Response<usize, &'static str>> {
    let mut lock = db.sdb.lock().unwrap();

    let user = match lock.get_user(user_id) {
        Some(n) => n,
        None => return Json(Response(Err("User not found")))
    };
    let msg = Message::new(msg, user, lock.get_next_message_id(), None);

    let send = lock.send_message(&msg);
    Json(Response(send))
}

#[get("/send_reply/<user_id>/<message_id>/<msg>")]
fn send_reply(user_id: usize, message_id: usize, msg: String, db: &State<SharedDB>) -> Json<Response<usize, &'static str>> {
    let mut lock = db.sdb.lock().unwrap();

    let user = match lock.get_user(user_id) {
        Some(n) => n,
        None => return Json(Response(Err("User not found")))
    };
    let msg = Message::new(msg, user, lock.get_next_message_id(), Some(message_id));

    let send = lock.send_message(&msg);
    Json(Response(send))
}

#[get("/delete_message/<id>")]
fn delete_message(id: usize, db: &State<SharedDB>) -> Json<Response<&'static str, &'static str>> {
    let mut lock = db.sdb.lock().unwrap();

    Json(Response(lock.delete_message(id)))
}

#[get("/get_user/<id>")]
fn get_user(id: usize, db: &State<SharedDB>) -> Json<Response<User, &'static str>> {
    let lock = db.sdb.lock().unwrap();
    match lock.get_user(id) {
        Some(n) => Json(Response(Ok(n))),
        None => Json(Response(Err("User not found")))
    }
}
#[get("/get_user_by_name/<name>")]
fn get_user_by_name(name: String, db: &State<SharedDB>) -> Json<Response<User, &'static str>> {
    let lock = db.sdb.lock().unwrap();
    match lock.get_user_by_name(name) {
        Some(n) => Json(Response(Ok(n))),
        None => Json(Response(Err("User not found")))
    }
}
#[get("/create_user/<name>")]
fn create_user(name: String, db: &State<SharedDB>) -> Json<Response<usize, &'static str>> {
    let mut lock = db.sdb.lock().unwrap();

    Json(Response(lock.create_user(name)))
}

#[get("/ping")]
fn ping() -> Json<Response<&'static str, &'static str>> {
    Json(Response(Ok("pong")))
}

#[get("/api")]
fn api_index(db: &State<SharedDB>) -> Json<Info> {
    let lock = db.sdb.lock().unwrap();
    Json(Info::get(lock))
}


#[derive(serde::Serialize)]
struct HitCount {
    c: usize
}

#[launch]
fn rocket() -> _ {
    rocket::build()
    .mount("/api", routes![
        get_message,
        send_message,
        get_message_id_list,
        ping,
        get_user,
        create_user,
        get_user_by_name,
        get_message_id_newest,
        send_reply,
        delete_message,
    ])
    .mount("/", routes![api_index])
    .manage(SharedDB{sdb: Mutex::new(database::Database::new())})
}