/*
    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>
*/
pub mod log;
pub mod user;

use super::{
    assets::{resolve_asset, AVIF_QUALITY, AVIF_SPEED},
    error::MyResult,
};
use crate::{helper::A, locale::AcceptLanguage};
use anyhow::{anyhow, Context};
use jellycommon::routes::u_admin_dashboard;
use jellyimport::{asset_token::AssetInner, import_wrap, is_importing};
use jellylogic::{
    admin::{get_import_errors, list_invites},
    session::AdminSession,
    Database,
};
use jellyui::{
    admin::AdminDashboardPage,
    render_page,
    scaffold::{RenderInfo, SessionInfo},
};
use rand::Rng;
use rocket::{
    form::Form,
    get, post,
    response::{content::RawHtml, Redirect},
    FromForm, State,
};
use std::time::Instant;
use tokio::{sync::Semaphore, task::spawn_blocking};

#[get("/admin/dashboard")]
pub async fn r_admin_dashboard(
    session: A<AdminSession>,
    database: &State<Database>,
    lang: AcceptLanguage,
) -> MyResult<RawHtml<String>> {
    let AcceptLanguage(lang) = lang;
    let flash = None;

    let invites = list_invites(&session.0, database)?;
    let last_import_err = get_import_errors(&session.0).await;

    let busy = if is_importing() {
        Some("An import is currently running.")
    } else if is_transcoding() {
        Some("Currently transcoding posters.")
    } else {
        None
    };

    Ok(RawHtml(render_page(
        &AdminDashboardPage {
            busy,
            last_import_err: &last_import_err,
            invites: &invites,
            flash,
            lang: &lang,
        },
        RenderInfo {
            importing: is_importing(),
            session: Some(SessionInfo {
                user: session.0 .0.user,
            }),
        },
        lang,
    )))
}

#[post("/admin/generate_invite")]
pub async fn r_admin_invite(
    _session: A<AdminSession>,
    database: &State<Database>,
) -> MyResult<Redirect> {
    let i = format!("{}", rand::rng().random::<u128>());
    database.create_invite(&i)?;
    // admin_dashboard(database, Some(Ok(format!("Invite: {}", i)))).await
    Ok(Redirect::temporary(u_admin_dashboard()))
}

#[derive(FromForm)]
pub struct DeleteInvite {
    invite: String,
}

#[post("/admin/remove_invite", data = "<form>")]
pub async fn r_admin_remove_invite(
    session: A<AdminSession>,
    database: &State<Database>,
    form: Form<DeleteInvite>,
) -> MyResult<Redirect> {
    drop(session);
    if !database.delete_invite(&form.invite)? {
        Err(anyhow!("invite does not exist"))?;
    };
    // admin_dashboard(database, Some(Ok("Invite invalidated".into()))).await
    Ok(Redirect::temporary(u_admin_dashboard()))
}

#[post("/admin/import?<incremental>")]
pub async fn r_admin_import(
    session: A<AdminSession>,
    database: &State<Database>,
    incremental: bool,
) -> MyResult<Redirect> {
    drop(session);
    let t = Instant::now();
    if !incremental {
        database.clear_nodes()?;
    }
    let r = import_wrap((*database).clone(), incremental).await;
    // let flash = r
    //     .map_err(|e| e.into())
    //     .map(|_| format!("Import successful; took {:?}", t.elapsed()));
    // admin_dashboard(database, Some(flash)).await
    Ok(Redirect::temporary(u_admin_dashboard()))
}

#[post("/admin/update_search")]
pub async fn r_admin_update_search(
    _session: A<AdminSession>,
    database: &State<Database>,
) -> MyResult<Redirect> {
    let db2 = (*database).clone();
    let r = spawn_blocking(move || db2.search_create_index())
        .await
        .unwrap();
    // admin_dashboard(
    //     database,
    //     Some(
    //         r.map_err(|e| e.into())
    //         .map(|_| "Search index updated".to_string()),
    //     ),
    // )
    // .await
    Ok(Redirect::temporary(u_admin_dashboard()))
}

static SEM_TRANSCODING: Semaphore = Semaphore::const_new(1);
fn is_transcoding() -> bool {
    SEM_TRANSCODING.available_permits() == 0
}

#[post("/admin/transcode_posters")]
pub async fn r_admin_transcode_posters(
    session: A<AdminSession>,
    database: &State<Database>,
) -> MyResult<Redirect> {
    drop(session);
    let _permit = SEM_TRANSCODING
        .try_acquire()
        .context("transcoding in progress")?;

    let t = Instant::now();

    {
        let nodes = database.list_nodes_with_udata("")?;
        for (node, _) in nodes {
            if let Some(poster) = &node.poster {
                let asset = AssetInner::deser(&poster.0)?;
                if asset.is_federated() {
                    continue;
                }
                let source = resolve_asset(asset).await.context("resolving asset")?;
                jellytranscoder::image::transcode(&source, AVIF_QUALITY, AVIF_SPEED, 1024)
                    .await
                    .context("transcoding asset")?;
            }
        }
    }
    drop(_permit);

    // admin_dashboard(
    //     database,
    //     Some(Ok(format!(
    //         "All posters pre-transcoded; took {:?}",
    //         t.elapsed()
    //     ))),
    // )
    // .await
    Ok(Redirect::temporary(u_admin_dashboard()))
}