#[macro_use] extern crate rocket;

use rocket::request::{self, Outcome, Request, FromRequest};
use rocket::response::{status::NotFound};
use rocket::serde::json::Json;

mod api_model;

static USER1: api_model::User = api_model::User {
    username: "u1",
    name: "User #1",
    active: true,
};

static USER2: api_model::User = api_model::User {
    username: "u2",
    name: "User #2",
    active: true,
};

static USER3: api_model::User = api_model::User {
    username: "u3",
    name: "User #3",
    active: true,
};

fn make_r1<'r>() -> api_model::Review<'r> {
    api_model::Review {
        id: 1,
        title: "Review #1",
        description: "Description for review #1",
        owner: &USER1,
        reviewers: vec![&USER2, &USER3],
        watchers: vec![],
        state: api_model::ReviewState::OPEN,
        progress: 0.42,
    }
}

fn make_r2<'r>() -> api_model::Review<'r> {
    api_model::Review {
        id: 2,
        title: "Review #2",
        description: "Description for review #2",
        owner: &USER2,
        reviewers: vec![&USER1],
        watchers: vec![&USER3],
        state: api_model::ReviewState::OPEN,
        progress: 0.9999,
    }
}

struct User {
    username: String,
}

#[derive(Debug)]
enum UserError {
    Missing,
    Invalid,
}

#[rocket::async_trait]
impl<'r> FromRequest<'r> for User {
    type Error = UserError;

    async fn from_request(_req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
        Outcome::Success(User{ username: String::from("foo") })
    }
}

fn review_entry<'r>(review: &api_model::Review<'r>) -> api_model::ReviewEntry<'r> {
    api_model::ReviewEntry {
        id: review.id,
        title: review.title,
        owner: review.owner,
        state: review.state,
        progress: review.progress,
    }
}

#[get("/reviews")]
async fn reviews<'r>(_user: User) -> Json<api_model::Reviews<'r>> {
    Json(
        api_model::Reviews {
            offset: 0,
            limit: 10,
            total_count: 2,
            more: false,
            reviews: vec![review_entry(&make_r1()), review_entry(&make_r2())],
        },
    )
}

#[get("/review/<id>")]
async fn review<'r>(id: u64, _user: User) -> Result<Json<api_model::Review<'r>>, NotFound<String>> {
    match id {
        1 => Ok(Json(make_r1())),
        2 => Ok(Json(make_r2())),
        _ => Err(NotFound(id.to_string()))
    }
}

#[rocket::main]
async fn main() -> Result<(), rocket::Error> {
    let _rocket = rocket::build()
        .mount("/api/v1", routes![reviews, review])
        .launch()
        .await?;

    Ok(())
}