/*
    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 super::{format_form_error, hash_password};
use crate::{helper::A, locale::AcceptLanguage, ui::error::MyResult};
use jellycommon::user::{PlayerKind, Theme};
use jellyimport::is_importing;
use jellylogic::{session::Session, Database};
use jellyui::{
    account::settings::SettingsPage,
    locale::{tr, Language},
    render_page,
    scaffold::{RenderInfo, SessionInfo},
};
use rocket::{
    form::{self, validate::len, Contextual, Form},
    get, post,
    response::content::RawHtml,
    FromForm, State,
};
use std::ops::Range;

#[derive(FromForm)]
pub struct SettingsForm {
    #[field(validate = option_len(4..64))]
    password: Option<String>,
    #[field(validate = option_len(4..32))]
    display_name: Option<String>,
    theme: Option<A<Theme>>,
    player_preference: Option<A<PlayerKind>>,
    native_secret: Option<String>,
}

fn option_len<'v>(value: &Option<String>, range: Range<usize>) -> form::Result<'v, ()> {
    value.as_ref().map(|v| len(v, range)).unwrap_or(Ok(()))
}

fn settings_page(
    session: Session,
    flash: Option<Result<String, String>>,
    lang: Language,
) -> RawHtml<String> {
    RawHtml(render_page(
        &SettingsPage {
            flash,
            session: &SessionInfo {
                user: session.user.clone(),
            },
            lang: &lang,
        },
        RenderInfo {
            importing: is_importing(),
            session: Some(SessionInfo { user: session.user }),
        },
        lang,
    ))
}

#[get("/account/settings")]
pub fn r_account_settings(session: A<Session>, lang: AcceptLanguage) -> RawHtml<String> {
    let AcceptLanguage(lang) = lang;
    settings_page(session.0, None, lang)
}

#[post("/account/settings", data = "<form>")]
pub fn r_account_settings_post(
    session: A<Session>,
    database: &State<Database>,
    form: Form<Contextual<SettingsForm>>,
    lang: AcceptLanguage,
) -> MyResult<RawHtml<String>> {
    let AcceptLanguage(lang) = lang;
    let A(session) = session;

    let form = match &form.value {
        Some(v) => v,
        None => {
            return Ok(settings_page(
                session,
                Some(Err(format_form_error(form).to_string())),
                lang,
            ))
        }
    };

    let mut out = String::new();

    database.update_user(&session.user.name, |user| {
        if let Some(password) = &form.password {
            user.password = hash_password(&session.user.name, password);
            out += &*tr(lang, "settings.account.password.changed");
            out += "\n";
        }
        if let Some(display_name) = &form.display_name {
            user.display_name = display_name.clone();
            out += &*tr(lang, "settings.account.display_name.changed");
            out += "\n";
        }
        if let Some(theme) = form.theme {
            user.theme = theme.0;
            out += &*tr(lang, "settings.account.theme.changed");
            out += "\n";
        }
        if let Some(player_preference) = form.player_preference {
            user.player_preference = player_preference.0;
            out += &*tr(lang, "settings.player_preference.changed");
            out += "\n";
        }
        if let Some(native_secret) = &form.native_secret {
            user.native_secret = native_secret.to_owned();
            out += "Native secret updated.\n";
        }
        Ok(())
    })?;

    Ok(settings_page(
        session, // using the old session here, results in outdated theme being displayed
        Some(Ok(if out.is_empty() {
            tr(lang, "settings.no_change").to_string()
        } else {
            out
        })),
        lang,
    ))
}