#[macro_use]
extern crate rocket;

use rocket::fs::FileServer;
use rocket::response::Redirect;
use rocket::State;
use rocket_dyn_templates::tera;
use rocket_dyn_templates::Template;

use rand::distributions::Uniform;
use rand::Rng;

use std::collections::HashMap;
use std::ops::Deref;
use std::sync::Arc;

use chgk_ledb_lib::async_db;
use chgk_ledb_lib::questions::Question;

use mini_moka::sync::Cache;
use std::time::Duration;

const DB_FILENAME: &str = "db.dat";

trait ErrorEmpty {
    type Output;
    fn err_empty(self) -> Result<Self::Output, ()>;
}

impl<T, E> ErrorEmpty for Result<T, E> {
    type Output = T;
    fn err_empty(self) -> Result<Self::Output, ()> {
        self.map_err(|_| ())
    }
}

#[derive(Debug, Responder)]
enum WebError {
    #[response(status = 404)]
    NotFound(Template),
}

impl WebError {
    fn not_found() -> Self {
        let context: HashMap<String, String> = HashMap::new();
        WebError::NotFound(Template::render("404", context))
    }
}

#[derive(Clone)]
struct ArcTemplateData {
    value: Arc<tera::Value>,
}

impl ArcTemplateData {
    fn new(value: tera::Value) -> ArcTemplateData {
        ArcTemplateData {
            value: Arc::new(value),
        }
    }
    fn render(&self, name: &'static str) -> Template {
        Template::render(name, self.value.deref())
    }
}

type TemplateCache = mini_moka::sync::Cache<usize, ArcTemplateData>;

type DataBaseInner = async_db::Reader<Question>;
type DataBase = Arc<DataBaseInner>;
struct AppState {
    db: DataBase,
    database_distribution: Uniform<usize>,
}

impl From<DataBaseInner> for AppState {
    fn from(db: DataBaseInner) -> Self {
        let last_id = db.len();
        let database_distribution = rand::distributions::Uniform::new_inclusive(1usize, last_id);
        let db = Arc::new(db);

        Self {
            db,
            database_distribution,
        }
    }
}

fn random_question_id(database_distribution: &Uniform<usize>) -> usize {
    let mut rng = rand::thread_rng();
    rng.sample(database_distribution)
}

async fn get_question(db: &DataBase, id: usize) -> Result<Question, ()> {
    db.get(id - 1).await.err_empty()
}

async fn show_question_details(
    template_name: &'static str,
    data: &AppState,
    cache: &TemplateCache,
    id: usize,
) -> Option<Template> {
    if let Some(value) = cache.get(&id) {
        return Some(value.render(template_name));
    }

    match get_question(&data.db, id).await {
        Ok(question) => {
            let mut context = tera::to_value(question).expect("question serialize");
            if context.is_object() {
                let next_id = random_question_id(&data.database_distribution);
                context["next"] = tera::to_value(next_id).expect("question id serialize");
            }

            let value = ArcTemplateData::new(context);
            let result = value.render(template_name);
            cache.insert(id, value);

            Some(result)
        }
        Err(_) => None,
    }
}

#[get("/q/<id>")]
async fn show_question(
    data: &State<AppState>,
    cache: &State<TemplateCache>,
    id: usize,
) -> Option<Template> {
    show_question_details("question", data.inner(), cache.inner(), id).await
}

#[get("/q/<id>/a")]
async fn show_answer(
    data: &State<AppState>,
    cache: &State<TemplateCache>,
    id: usize,
) -> Option<Template> {
    show_question_details("answer", data.inner(), cache.inner(), id).await
}

#[get("/q/0")]
fn question0() -> Redirect {
    Redirect::to("/")
}

#[get("/q/0/a")]
fn answer0() -> Redirect {
    Redirect::to("/")
}

#[get("/")]
fn index(data: &State<AppState>) -> Redirect {
    let id = random_question_id(&data.database_distribution);
    Redirect::temporary(format!("/q/{}", id))
}

#[catch(404)]
fn not_found(_req: &rocket::Request) -> WebError {
    WebError::not_found()
}

#[launch]
async fn rocket() -> _ {
    let state: AppState = async_db::Reader::new(DB_FILENAME)
        .await
        .expect("open db")
        .into();
    let cache: TemplateCache = Cache::builder()
        .time_to_idle(Duration::from_secs(15 * 60))
        .max_capacity(300)
        .build();

    rocket::build()
        .manage(state)
        .manage(cache)
        .register("/", catchers![not_found])
        .mount(
            "/",
            routes![index, show_question, show_answer, question0, answer0],
        )
        .mount("/q", routes![index])
        .mount("/q/static", FileServer::from("static/"))
        .attach(Template::fairing())
}