/*
    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) 2025 metamuffin <metamuffin.org>
*/
use crate::{helper::A, ui::error::MyResult};
use jellybase::database::Database;
use jellycommon::{
    routes::u_node_id,
    user::{NodeUserData, WatchedState},
    NodeID,
};
use jellylogic::session::Session;
use rocket::{
    form::Form, get, post, response::Redirect, serde::json::Json, FromForm, FromFormField, State,
    UriDisplayQuery,
};

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

#[get("/n/<id>/userdata")]
pub fn r_node_userdata(
    session: A<Session>,
    db: &State<Database>,
    id: A<NodeID>,
) -> MyResult<Json<NodeUserData>> {
    let u = db
        .get_node_udata(id.0, &session.0.user.name)?
        .unwrap_or_default();
    Ok(Json(u))
}

#[post("/n/<id>/watched?<state>")]
pub async fn r_node_userdata_watched(
    session: A<Session>,
    db: &State<Database>,
    id: A<NodeID>,
    state: UrlWatchedState,
) -> MyResult<Redirect> {
    // TODO perm
    db.update_node_udata(id.0, &session.0.user.name, |udata| {
        udata.watched = match state {
            UrlWatchedState::None => WatchedState::None,
            UrlWatchedState::Watched => WatchedState::Watched,
            UrlWatchedState::Pending => WatchedState::Pending,
        };
        Ok(())
    })?;
    Ok(Redirect::found(u_node_id(id.0)))
}

#[derive(FromForm)]
pub struct UpdateRating {
    #[field(validate = range(-10..=10))]
    rating: i32,
}

#[post("/n/<id>/update_rating", data = "<form>")]
pub async fn r_node_userdata_rating(
    session: A<Session>,
    db: &State<Database>,
    id: A<NodeID>,
    form: Form<UpdateRating>,
) -> MyResult<Redirect> {
    // TODO perm
    db.update_node_udata(id.0, &session.0.user.name, |udata| {
        udata.rating = form.rating;
        Ok(())
    })?;
    Ok(Redirect::found(u_node_id(id.0)))
}

#[post("/n/<id>/progress?<t>")]
pub async fn r_node_userdata_progress(
    session: A<Session>,
    db: &State<Database>,
    id: A<NodeID>,
    t: f64,
) -> MyResult<()> {
    // TODO perm
    db.update_node_udata(id.0, &session.0.user.name, |udata| {
        udata.watched = match udata.watched {
            WatchedState::None | WatchedState::Pending | WatchedState::Progress(_) => {
                WatchedState::Progress(t)
            }
            WatchedState::Watched => WatchedState::Watched,
        };
        Ok(())
    })?;
    Ok(())
}