use alloc::rc::Rc;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use core::cell::RefCell;
use paperpaw_sdk::builtin::events::{self, PluginsAnswered, PluginsRequested};
use paperpaw_sdk::event::Event;
use paperpaw_sdk::replies::Confirmed;
use paperpaw_sdk::{
Arg, Commands, Env, Id, Instant, MAX_REQUESTED_PLUGINS, RegisterError, Registrar, ask, files,
};
use crate::PLUGIN;
use crate::catalog::{Entry, Index};
use crate::queue;
const ANSWERED: Event<Confirmed> = Event::new("store.request-answered");
pub(crate) const DECLINED_MS: u64 = 60_000;
type Last = Rc<RefCell<Option<(Id, Vec<String>, Instant, bool)>>>;
pub(crate) fn register(r: &mut Registrar) -> Result<(), RegisterError> {
let last: Last = Rc::new(RefCell::new(None));
let asked = last.clone();
r.on(events::PLUGINS_REQUESTED, move |env, request, out| {
requested(env, request, out, &asked);
})?;
r.on(ANSWERED, move |env, answered, out| {
confirmed(env, answered, out, &last);
})?;
Ok(())
}
fn wanted_of(env: &Env<'_>, request: &PluginsRequested) -> Vec<String> {
let mut wanted: Vec<String> = Vec::new();
for id in request.ids().take(MAX_REQUESTED_PLUGINS.saturating_mul(4)) {
if wanted.len() >= MAX_REQUESTED_PLUGINS {
break;
}
if env.plugins().get(id.as_str()).is_none() && !wanted.iter().any(|w| w == id.as_str()) {
wanted.push(id.to_string());
}
}
wanted
}
fn path() -> String {
alloc::format!("{}/request.txt", Env::plugin_dir(PLUGIN.as_str()))
}
fn result_path() -> String {
alloc::format!("{}/request-result.txt", Env::plugin_dir(PLUGIN.as_str()))
}
fn open(env: &Env<'_>) -> Option<(Id, Vec<String>)> {
let text = paperpaw_sdk::read_file(env.storage(), &path(), 4 * 1024)
.ok()
.and_then(|bytes| String::from_utf8(bytes).ok())?;
let mut lines = text.lines();
let by = Id::parse(lines.next()?).ok()?;
Some((by, lines.map(ToString::to_string).collect()))
}
fn close(env: &Env<'_>) {
#[expect(
clippy::let_underscore_must_use,
reason = "files not there are nothing to remove"
)]
{
let _ = env.storage().remove(&path());
let _ = env.storage().remove(&result_path());
}
}
pub(crate) fn outcome(env: &Env<'_>, id: &str, done: bool) {
#[expect(
clippy::let_underscore_must_use,
reason = "an outcome not kept makes the plugin count as not installed: the reader is told so, and asks again later"
)]
{
let _ = env.storage().create_dir(&Env::plugin_dir(PLUGIN.as_str()));
let line = alloc::format!("{}{id}\n", if done { '+' } else { '-' });
let _ = env.storage().append(&result_path(), line.as_bytes());
}
}
fn answer(
out: &mut Commands,
by: Id,
(installed, missing): (&[String], &[String]),
declined: bool,
error: String,
) {
out.push(events::PLUGINS_ANSWERED.emit(PluginsAnswered::new(
by,
installed.join(" "),
missing.join(" "),
declined,
error,
)));
}
pub(crate) fn entries(env: &Env<'_>, ids: &[String]) -> Vec<(String, Option<Entry>)> {
let Some(index) = Index::kept(env.storage()) else {
return ids.iter().map(|id| (id.clone(), None)).collect();
};
let mut found: Vec<Entry> = Vec::new();
index.scan(env.storage(), &mut |_, entry: Entry| {
if ids.contains(&entry.id) {
found.push(entry);
}
});
ids.iter()
.filter_map(|id| {
found
.iter()
.position(|entry| entry.id == *id)
.map(|at| (id.clone(), Some(found.swap_remove(at))))
})
.collect()
}
pub(crate) fn names(list: &[(String, Option<Entry>)]) -> String {
list.iter()
.map(|(id, entry)| entry.as_ref().map_or(id.as_str(), |e| e.name.as_str()))
.collect::<Vec<_>>()
.join(", ")
}
fn requested(env: &Env<'_>, request: &PluginsRequested, out: &mut Commands, last: &Last) {
let by = request.by.clone();
let wanted = wanted_of(env, request);
if wanted.is_empty() {
return answer(out, by, (&[], &[]), false, String::new());
}
let same = last.borrow().as_ref().and_then(|(who, ids, at, declined)| {
(*who == by && *ids == wanted && env.now().since(*at) < DECLINED_MS).then_some(*declined)
});
match same {
Some(true) => return answer(out, by, (&[], &wanted), true, String::new()),
Some(false) if open(env).is_some() => return,
_ => {}
}
if open(env).is_some() {
if queue::requested_waiting(env) {
return answer(out, by, (&[], &wanted), true, String::new());
}
close(env);
}
let list = entries(env, &wanted);
if list.is_empty() {
return answer(out, by, (&[], &wanted), false, String::new());
}
let i18n = env.i18n();
let ids: Vec<String> = list.iter().map(|(id, _)| id.clone()).collect();
if !env.caps().network {
let error = i18n.format(
"store.request.offline",
&[("names", Arg::Str(&names(&list)))],
);
return answer(out, by, (&[], &ids), false, error);
}
#[expect(
clippy::let_underscore_must_use,
reason = "a request not kept is not answered when its dialog is: the one who asked asks again"
)]
{
let _ = env.storage().create_dir(&Env::plugin_dir(PLUGIN.as_str()));
let text = alloc::format!("{by}\n{}\n", ids.join("\n"));
if env.storage().write(&path(), text.as_bytes()).is_err() {
return answer(out, by, (&[], &ids), true, String::new());
}
}
let lines: Vec<String> = list
.iter()
.map(|(id, entry)| match entry {
Some(entry) => i18n.format(
"store.request.item",
&[
("name", Arg::Str(&entry.name)),
("size", Arg::Str(&files::shown_size(env, entry.size))),
],
),
None => id.clone(),
})
.collect();
*last.borrow_mut() = Some((by.clone(), ids.clone(), env.now(), false));
let key = alloc::format!("store.request.by.{by}");
let question = i18n
.get(&key)
.unwrap_or_else(|| i18n.tr("store.request.by.other"))
.to_string();
out.push(
ask::confirm(question, &ANSWERED)
.text(lines.join("\n"))
.yes(i18n.tr("store.request.download"))
.no(i18n.tr("store.request.not-now"))
.focus_yes()
.command(),
);
}
fn confirmed(env: &Env<'_>, answered: &Confirmed, out: &mut Commands, last: &Last) {
let Some((by, ids)) = open(env) else {
return;
};
if !answered.yes {
*last.borrow_mut() = Some((by.clone(), ids.clone(), env.now(), true));
close(env);
return answer(out, by, (&[], &ids), true, String::new());
}
if !env.caps().network {
close(env);
let list: Vec<(String, Option<Entry>)> = ids.iter().map(|id| (id.clone(), None)).collect();
let error = env.i18n().format(
"store.request.offline",
&[("names", Arg::Str(&names(&list)))],
);
return answer(out, by, (&[], &ids), false, error);
}
queue::add_requested(env, &ids, out);
out.push(crate::fetch::open(&by, &ids));
}
pub(crate) fn again(env: &Env<'_>, by: &Id, ids: &[String], out: &mut Commands) {
#[expect(
clippy::let_underscore_must_use,
reason = "a request not kept is not answered when its download ends: the screen shows what was fetched, and tries again"
)]
{
let _ = env.storage().create_dir(&Env::plugin_dir(PLUGIN.as_str()));
let text = alloc::format!("{by}\n{}\n", ids.join("\n"));
let _ = env.storage().remove(&result_path());
let _ = env.storage().write(&path(), text.as_bytes());
}
queue::add_requested(env, ids, out);
}
pub(crate) fn finished(env: &Env<'_>, out: &mut Commands) {
let Some((by, ids)) = open(env) else {
return;
};
let results = paperpaw_sdk::read_file(env.storage(), &result_path(), 4 * 1024)
.ok()
.and_then(|bytes| String::from_utf8(bytes).ok())
.unwrap_or_default();
let installed: Vec<String> = ids
.iter()
.filter(|id| {
results
.lines()
.any(|l| l.strip_prefix('+') == Some(id.as_str()))
})
.cloned()
.collect();
let missing: Vec<String> = ids
.iter()
.filter(|id| !installed.contains(id))
.cloned()
.collect();
let error = match missing.is_empty() {
true => String::new(),
false => {
let list: Vec<(String, Option<Entry>)> =
missing.iter().map(|id| (id.clone(), None)).collect();
let named = entries(env, &missing);
let list = if named.is_empty() { list } else { named };
env.i18n().format(
"store.request.failed",
&[("names", Arg::Str(&names(&list)))],
)
}
};
close(env);
answer(out, by, (&installed, &missing), false, error);
}