/*
    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
    Copyright (C) 2023 metamuffin <metamuffin.org>
*/
use super::ui::{account::session::Session, error::MyResult};
use crate::routes::ui::node::rocket_uri_macro_r_library_node;
use anyhow::anyhow;
use jellybase::database::Database;
use jellycommon::user::{NodeUserData, WatchedState};
use rocket::{
    get, post, response::Redirect, serde::json::Json, FromFormField, State, UriDisplayQuery,
};

#[derive(Debug, FromFormField, UriDisplayQuery)]
pub enum UrlWatchedState {
    None,
    Watched,
    Pending,
}

#[get("/n/<id>/userdata")]
pub fn r_node_userdata(
    session: Session,
    db: &State<Database>,
    id: &str,
) -> MyResult<Json<NodeUserData>> {
    db.node
        .get(&id.to_string())?
        .ok_or(anyhow!("node does not exist"))?;
    let key = (session.user.name.clone(), id.to_owned());
    Ok(Json(db.user_node.get(&key)?.unwrap_or_default()))
}

#[post("/n/<id>/watched?<state>")]
pub async fn r_player_watched(
    session: Session,
    db: &State<Database>,
    id: &str,
    state: UrlWatchedState,
) -> MyResult<Redirect> {
    db.node
        .get(&id.to_string())?
        .ok_or(anyhow!("node does not exist"))?;

    let key = (session.user.name.clone(), id.to_owned());

    db.user_node.fetch_and_update(&key, |t| {
        let mut t = t.unwrap_or_default();
        t.watched = match state {
            UrlWatchedState::None => WatchedState::None,
            UrlWatchedState::Watched => WatchedState::Watched,
            UrlWatchedState::Pending => WatchedState::Pending,
        };
        Some(t)
    })?;

    Ok(Redirect::found(rocket::uri!(r_library_node(id))))
}

#[post("/n/<id>/progress?<t>")]
pub async fn r_player_progress(
    session: Session,
    db: &State<Database>,
    id: &str,
    t: f64,
) -> MyResult<()> {
    db.node
        .get(&id.to_string())?
        .ok_or(anyhow!("node does not exist"))?;

    let key = (session.user.name.clone(), id.to_owned());
    db.user_node.fetch_and_update(&key, |d| {
        let mut d = d.unwrap_or_default();
        d.watched = match d.watched {
            WatchedState::None | WatchedState::Pending | WatchedState::Progress(_) => {
                WatchedState::Progress(t)
            }
            WatchedState::Watched => WatchedState::Watched,
        };
        Some(d)
    })?;
    Ok(())
}