//! Blocking HTTP runs off the event loop; revisions guard publication after a newer user action.
use crate::{ModsWindow, catalogue::CatalogueController};
use fmm_core::{
cache::Cache,
catalogue::Catalogue,
explore::{ExploreIndex, Sort},
net::Http,
portal::{PortalMod, PortalModFull, thumbnail_url},
portal_data::{PortalData, UPDATE_COOLDOWN},
portal_search::{self, SearchPage},
version::game_line,
};
use slint::{ComponentHandle, Model};
use std::{
cell::RefCell,
collections::{HashSet, VecDeque},
path::PathBuf,
rc::Rc,
sync::{Arc, mpsc},
time::{Duration, Instant},
};
type Outcome<T> = std::result::Result<T, String>;
const LOADING_FEEDBACK: Duration = Duration::from_millis(180);
enum Message {
Metadata(String, String, Box<Outcome<PortalModFull>>),
Search(u64, String, Box<Outcome<SearchPage>>),
Detail(u64, String, Box<Outcome<PortalModFull>>),
Catalogue(Outcome<Catalogue>),
Updates(Outcome<Vec<PortalMod>>),
Thumbnail(String, Outcome<PathBuf>),
Description(String, Outcome<fmm_core::description_images::Decoded>),
}
#[derive(Default)]
pub struct Gate {
pub revision: u64,
due: Option<Instant>,
busy: bool,
}
impl Gate {
pub fn change(&mut self, delay: Duration) {
self.revision += 1;
self.due = Some(Instant::now() + delay);
}
fn ready(&self) -> bool {
!self.busy && self.due.is_some_and(|due| Instant::now() >= due)
}
pub fn accepts(&self, revision: u64) -> bool {
self.revision == revision
}
}
struct Live {
c: Rc<RefCell<CatalogueController>>,
data: Arc<PortalData<Http>>,
catalogue_ttl: Duration,
tx: mpsc::Sender<Message>,
rx: mpsc::Receiver<Message>,
query: Gate,
detail: Gate,
pages: VecDeque<(String, SearchPage)>,
force: bool,
loading_until: Option<Instant>,
pending_search: Option<Box<Outcome<SearchPage>>>,
update_at: Option<Instant>,
updates_busy: bool,
thumbs_busy: HashSet<String>,
thumbs_failed: HashSet<String>,
tab: i32,
}
fn send(tx: mpsc::Sender<Message>, weak: slint::Weak<ModsWindow>, message: Message) {
if tx.send(message).is_ok() {
let _ = slint::invoke_from_event_loop(move || {
if let Some(app) = weak.upgrade() {
app.invoke_catalogue_loaded();
}
});
}
}
impl Live {
fn detail_name(&self, app: &ModsWindow) -> Option<String> {
if app.get_current_tab() == 2 {
let name = app.get_updates_picked();
(!name.is_empty()).then(|| name.to_string())
} else {
self.c.borrow().selection.clone()
}
}
fn change(&mut self, delay: Duration) {
self.c.borrow_mut().exact_name = None;
self.query.change(delay);
self.c.borrow_mut().loading = true;
self.loading_until = Some(Instant::now() + LOADING_FEEDBACK);
self.pending_search = None;
}
fn search_received(&mut self, revision: u64, url: String, result: Box<Outcome<SearchPage>>) {
if let Ok(page) = &*result {
self.pages.retain(|(key, _)| key != &url);
self.pages.push_back((url, page.clone()));
while self.pages.len() > 16 {
self.pages.pop_front();
}
}
if self.query.accepts(revision) {
self.pending_search = Some(result);
}
}
fn update(&mut self, app: &ModsWindow) {
if self.updates_busy
|| self
.update_at
.is_some_and(|t| t.elapsed() < UPDATE_COOLDOWN)
{
return;
}
self.update_at = Some(Instant::now());
self.updates_busy = true;
let names = self.c.borrow().installed_names();
let line = game_line(&self.c.borrow().game_version);
let data = self.data.clone();
let tx = self.tx.clone();
let weak = app.as_weak();
let catalogue_ttl = self.catalogue_ttl;
std::thread::spawn(move || {
let cached = data.cached_catalogue();
let refresh = cached.is_none() || !data.cache.fresh("catalogue.json", catalogue_ttl);
if let Some(catalogue) = cached {
send(tx.clone(), weak.clone(), Message::Catalogue(Ok(catalogue)));
}
if refresh {
send(
tx.clone(),
weak.clone(),
Message::Catalogue(
data.catalogue_with_ttl(&line, catalogue_ttl)
.map_err(|e| e.to_string()),
),
);
}
send(
tx,
weak,
Message::Updates(data.updates(&names).map_err(|e| e.to_string())),
);
});
}
fn drain(&mut self, app: &ModsWindow) {
let mut publish = false;
while let Ok(message) = self.rx.try_recv() {
match message {
Message::Description(url, result) => {
self.thumbs_busy.remove(&url);
let c = self.c.borrow_mut();
let mut images = c.description_images.borrow_mut();
match result {
Ok(decoded) => images.insert(url, decoded),
Err(error) => {
eprintln!("Description image {url}: {error}");
images.failed.insert(url);
}
}
publish = true;
}
Message::Metadata(name, version, result) => match *result {
Ok(full) => {
let mut c = self.c.borrow_mut();
if c.local
.iter()
.any(|m| m.name == name && m.version == version)
{
if let Some(url) = thumbnail_url(full.mod_.thumbnail.as_deref())
&& let Ok(path) = self.data.thumbnail_path(&url)
&& path.is_file()
&& let Ok(image) = slint::Image::load_from_path(&path)
{
c.thumbnails.insert(url, image);
}
c.installed_full
.insert((name.clone(), version), full.clone());
c.full.entry(name).or_insert(full);
publish = true;
}
}
Err(e) => eprintln!("Installed metadata {name} {version}: {e}"),
},
Message::Search(revision, url, result) => {
self.query.busy = false;
self.search_received(revision, url, result);
}
Message::Detail(revision, name, result) => {
self.detail.busy = false;
if let Err(e) = &*result
&& self.detail.accepts(revision)
&& self.detail_name(app).as_deref() == Some(&name)
{
app.set_results_banner(
format!("Cannot load {name} from the mod portal: {e}").into(),
);
}
if let Ok(full) = *result {
let mut c = self.c.borrow_mut();
if self.detail.accepts(revision)
&& (if app.get_current_tab() == 2
&& !app.get_updates_picked().is_empty()
{
app.get_updates_picked().as_str() == name
} else {
c.selection.as_deref() == Some(&name)
})
{
c.full.insert(name, full);
publish = true;
}
}
}
Message::Catalogue(result) => {
match result {
Ok(catalogue) => {
let mut c = self.c.borrow_mut();
let version = c.game_version.clone();
c.set_catalogue(Some(ExploreIndex::new(catalogue.results, &version)));
}
Err(e) => eprintln!("Catalogue refresh failed (keeping cache): {e}"),
}
publish = true;
}
Message::Updates(result) => {
self.updates_busy = false;
match result {
Ok(mods) => self.c.borrow_mut().set_updates(&mods),
Err(e) => {
eprintln!("Update check failed: {e}");
if !self.c.borrow().has_update_data() {
self.c.borrow_mut().updates_failed = true;
}
}
}
publish = true;
}
Message::Thumbnail(url, result) => {
self.thumbs_busy.remove(&url);
let image = result
.ok()
.and_then(|p| slint::Image::load_from_path(&p).ok());
if let Some(image) = image {
self.c.borrow_mut().thumbnails.insert(url, image);
publish = true;
} else {
self.thumbs_failed.insert(url);
}
}
}
}
let mut reset_scroll = false;
// Even an in-memory or very fast refresh gets a visible frame of feedback.
if self
.loading_until
.is_none_or(|until| Instant::now() >= until)
&& let Some(result) = self.pending_search.take()
{
let mut c = self.c.borrow_mut();
match *result {
Ok(page) => {
c.portal_page = Some(page);
c.notice.clear();
}
Err(e) => {
eprintln!("Portal search failed: {e}");
c.portal_page = None;
c.notice = "Portal search unavailable; showing cached catalogue".into();
let pages = c
.index
.as_ref()
.map(|i| i.query(&c.view).rows.len().div_ceil(20).max(1))
.unwrap_or(1);
c.page = c.page.min(pages);
}
}
c.loading = false;
self.loading_until = None;
publish = true;
reset_scroll = true;
}
if publish {
self.c.borrow().publish(app);
}
if reset_scroll {
app.set_explore_scroll_tick(app.get_explore_scroll_tick().wrapping_add(1));
}
}
fn drive(&mut self, app: &ModsWindow) {
app.global::<crate::DescriptionImages>()
.set_paused(app.window().is_minimized());
self.drain(app);
if self.tab != app.get_current_tab() {
self.tab = app.get_current_tab();
self.detail.change(Duration::from_millis(250));
self.c.borrow().publish(app);
if self.tab == 1 && self.query.revision == 0 && self.c.borrow().exact_name.is_none() {
self.change(Duration::ZERO);
self.c.borrow().publish(app);
}
}
if self.tab == 1 && self.query.ready() && self.c.borrow().exact_name.is_none() {
self.query.due = None;
let c = self.c.borrow();
let view = c.view.clone();
let page = c.page;
let line = game_line(&c.game_version);
let url = portal_search::url(&view, &line, page);
drop(c);
if !self.force
&& let Some((_, page)) = self.pages.iter().find(|(key, _)| key == &url)
{
self.search_received(self.query.revision, url, Box::new(Ok(page.clone())));
} else {
self.force = false;
self.query.busy = true;
let revision = self.query.revision;
let data = self.data.clone();
let tx = self.tx.clone();
let weak = app.as_weak();
std::thread::spawn(move || {
send(
tx,
weak,
Message::Search(
revision,
url,
Box::new(data.search(&view, &line, page).map_err(|e| e.to_string())),
),
)
});
}
}
if self.tab != 0 && self.detail.ready() {
self.detail.due = None;
let name = self.detail_name(app);
if let Some(name) = name {
self.detail.busy = true;
let revision = self.detail.revision;
let data = self.data.clone();
let tx = self.tx.clone();
let weak = app.as_weak();
std::thread::spawn(move || {
let result = data.full(&name).map_err(|e| e.to_string());
send(tx, weak, Message::Detail(revision, name, Box::new(result)));
});
}
}
app.set_detail_loading(self.detail.busy || self.detail.due.is_some());
let c = self.c.borrow();
let visible = if self.tab == 1 {
c.visible_mods()
} else {
vec![]
};
let mut urls: Vec<_> = visible
.into_iter()
.skip(app.get_explore_first().max(0) as usize)
.take(app.get_explore_visible().clamp(0, 100) as usize)
.filter_map(|m| thumbnail_url(m.thumbnail.as_deref()))
.collect();
if self.tab == 0 || self.tab == 2 {
let rows = if self.tab == 0 {
app.get_manage_rich_rows()
} else {
app.get_updates_rich_rows()
};
urls.extend(rows.iter().take(100).filter_map(|r| {
(!r.thumbnail_url.is_empty()).then(|| r.thumbnail_url.to_string())
}));
}
let detail_name = self.detail_name(app);
let selected = detail_name
.as_ref()
.and_then(|name| c.full.get(name))
.map(|f| &f.mod_)
.or_else(|| {
if self.tab == 1 {
c.selected_mod()
} else {
None
}
});
if let Some(m) = selected
&& let Some(url) = thumbnail_url(m.thumbnail.as_deref())
{
urls.insert(0, url);
}
if let Some(name) = &detail_name
&& let Some(full) = c.full.get(name)
{
let gallery: Vec<_> = full
.images
.iter()
.filter(|img| {
fmm_core::markdown::image_url(&img.thumbnail)
&& fmm_core::markdown::image_url(&img.url)
})
.collect();
if let Some(image) = gallery
.get(app.get_detail_gallery().max(0) as usize)
.filter(|_| app.get_detail_gallery() >= 0)
{
urls.insert(0, image.url.clone());
}
urls.extend(gallery.iter().map(|image| image.thumbnail.clone()));
}
let descriptions =
if self.tab != 0 && !app.get_show_portal_changelog() && !app.get_show_changelog() {
crate::description::pending(&app.get_portal_detail().blocks)
} else {
Vec::new()
};
urls.extend(descriptions.iter().cloned());
urls.retain(|url| {
(descriptions.contains(url) || !c.thumbnails.contains_key(url))
&& !self.thumbs_busy.contains(url)
&& (descriptions.contains(url) || !self.thumbs_failed.contains(url))
&& (!descriptions.contains(url) || !c.description_images.borrow().contains(url))
});
drop(c);
for url in urls {
if self.thumbs_busy.len() >= 4 {
break;
}
if !self.thumbs_busy.insert(url.clone()) {
continue;
}
let data = self.data.clone();
let tx = self.tx.clone();
let weak = app.as_weak();
let is_description = descriptions.contains(&url);
std::thread::spawn(move || {
if is_description {
let result = fmm_core::description_images::fetch(
&fmm_core::description_images::Http,
&data.cache,
&url,
)
.and_then(|path| fmm_core::description_images::decode(&std::fs::read(path)?))
.map_err(|e| e.to_string());
send(tx, weak, Message::Description(url, result));
} else {
let result = data.thumbnail(&url).map_err(|e| e.to_string());
send(tx, weak, Message::Thumbnail(url, result));
}
});
}
}
}
pub struct Runtime {
_timer: slint::Timer,
}
pub fn start(
app: &ModsWindow,
c: Rc<RefCell<CatalogueController>>,
cache: Cache,
catalogue_ttl: Duration,
) -> Runtime {
let (tx, rx) = mpsc::channel();
let data = Arc::new(PortalData {
fetcher: Http::default(),
cache,
});
let state = Rc::new(RefCell::new(Live {
c: c.clone(),
data: data.clone(),
catalogue_ttl: catalogue_ttl.max(fmm_core::portal_data::CATALOGUE_TTL),
tx: tx.clone(),
rx,
query: Gate::default(),
detail: Gate::default(),
pages: VecDeque::new(),
force: false,
loading_until: None,
pending_search: None,
update_at: None,
updates_busy: false,
thumbs_busy: HashSet::new(),
thumbs_failed: HashSet::new(),
tab: -1,
}));
let shown_state = state.clone();
app.global::<crate::DescriptionImages>()
.on_shown(move |url| {
shown_state
.borrow()
.c
.borrow()
.description_images
.borrow_mut()
.shown(url.as_str());
});
let clear_state = state.clone();
let weak = app.as_weak();
app.global::<crate::DescriptionImages>()
.on_clear_cache(move || {
let mut state = clear_state.borrow_mut();
if let Some(app) = weak.upgrade() {
if !state.thumbs_busy.is_empty() {
app.set_settings_error(
"Images are loading. Try Clear cache when they finish.".into(),
);
return;
}
state.thumbs_failed.clear();
match state.data.cache.clear() {
Ok(()) => {
let mut c = state.c.borrow_mut();
c.description_images.borrow_mut().clear();
c.thumbnails.clear();
c.publish(&app);
app.set_settings_error("Cache cleared.".into());
}
Err(error) => {
app.set_settings_error(format!("Cannot clear cache: {error}").into())
}
}
}
});
macro_rules! bind {
($callback:ident, |$s:ident $(, $arg:ident)*| $body:expr) => {{
let state = state.clone(); let weak = app.as_weak();
app.$callback(move |$($arg),*| { let mut $s = state.borrow_mut(); $body; if let Some(app) = weak.upgrade() { $s.c.borrow().publish(&app); app.set_detail_loading($s.detail.busy || $s.detail.due.is_some()); } });
}};
}
bind!(on_explore_search, |s, text| {
s.c.borrow_mut().view.search = text.into();
s.c.borrow_mut().page = 1;
s.change(Duration::from_millis(300));
});
let dependency = state.clone();
let weak = app.as_weak();
app.on_dependency_activated(move |name| {
if let Some(app) = weak.upgrade() {
let mut s = dependency.borrow_mut();
s.query.change(Duration::ZERO);
s.query.due = None;
s.pending_search = None;
{
let mut c = s.c.borrow_mut();
c.focus_dependency(name.as_str());
}
app.set_current_tab(1);
app.set_show_changelog(false);
app.set_show_portal_changelog(false);
s.detail.change(Duration::ZERO);
s.c.borrow().publish(&app);
}
});
bind!(on_explore_sort_changed, |s, index| {
s.c.borrow_mut().view.sort = match index {
1 => Sort::Downloads,
2 => Sort::Updated,
3 => Sort::Trending,
_ => Sort::Relevance,
};
s.c.borrow_mut().page = 1;
s.change(Duration::ZERO);
});
bind!(on_explore_filter, |s, id, exclude| {
s.c.borrow_mut().view.toggle_filter(id.as_str(), exclude);
s.c.borrow_mut().page = 1;
s.change(Duration::ZERO);
});
bind!(on_explore_page, |s, page| {
if page > 0 {
s.c.borrow_mut().page = page as usize;
s.change(Duration::ZERO);
}
});
bind!(on_explore_refresh, |s| {
s.force = true;
s.change(Duration::ZERO);
s.thumbs_failed.clear();
});
bind!(on_detail_selected, |s, _name| {
s.c.borrow_mut().changelog_filter = [0, 0, 3];
s.detail.change(Duration::from_millis(250));
});
bind!(on_explore_selected, |s, name| {
s.c.borrow_mut().select(name.as_str());
s.c.borrow_mut().changelog_filter = [0, 0, 3];
s.detail.change(Duration::from_millis(250));
});
let refresh = state.clone();
let weak = app.as_weak();
app.on_updates_refresh(move || {
if let Some(app) = weak.upgrade() {
refresh.borrow_mut().update(&app);
}
});
let events = state.clone();
let weak = app.as_weak();
app.on_catalogue_loaded(move || {
if let Some(app) = weak.upgrade() {
events.borrow_mut().drain(&app);
}
});
if let Ok(root) = fmm_core::metadata::app_metadata_dir() {
let store = fmm_core::metadata::MetadataStore::new(root);
let missing = store.missing(&c.borrow().local);
let data = data.clone();
let tx = tx.clone();
let weak = app.as_weak();
// One background worker, with a polite gap between mods, including failures.
std::thread::spawn(move || {
for (name, version) in missing {
let result = (|| -> fmm_core::Result<_> {
let full = data.full(&name)?;
store.retain(&data, &full, &version)?;
if let Err(e) = store.retain_thumbnail(&data, &full) {
eprintln!("Metadata thumbnail: {e}");
}
Ok(full)
})()
.map_err(|e| e.to_string());
send(
tx.clone(),
weak.clone(),
Message::Metadata(name, version, Box::new(result)),
);
std::thread::sleep(Duration::from_millis(500));
}
});
}
// The worker publishes cached rows before any potentially slow network refresh.
state.borrow_mut().update(app);
let timer = slint::Timer::default();
let weak = app.as_weak();
timer.start(
slint::TimerMode::Repeated,
Duration::from_millis(30),
move || {
if let Some(app) = weak.upgrade() {
state.borrow_mut().drive(&app);
}
},
);
Runtime { _timer: timer }
}
#[cfg(test)]
pub fn check_offline_publication(
app: &ModsWindow,
controller: CatalogueController,
cache_dir: PathBuf,
) {
let c = Rc::new(RefCell::new(controller));
let (tx, rx) = mpsc::channel();
let mut live = Live {
c: c.clone(),
catalogue_ttl: fmm_core::portal_data::CATALOGUE_TTL,
data: Arc::new(PortalData {
fetcher: Http::default(),
cache: Cache::new(cache_dir),
}),
tx: tx.clone(),
rx,
query: Gate::default(),
detail: Gate::default(),
pages: VecDeque::new(),
force: false,
loading_until: None,
pending_search: None,
update_at: Some(Instant::now()),
updates_busy: false,
thumbs_busy: HashSet::new(),
thumbs_failed: HashSet::new(),
tab: 1,
};
live.query.change(Duration::from_millis(300));
assert!(!live.query.ready());
live.change(Duration::ZERO);
live.loading_until = Some(Instant::now() + Duration::from_secs(60));
assert!(live.query.ready());
live.query.busy = true;
assert!(!live.query.ready());
assert!(!live.query.accepts(1));
assert!(live.query.accepts(2));
let page =
portal_search::parse(include_str!("../../core/tests/fixtures/search-query.html")).unwrap();
c.borrow_mut().portal_page = Some(page.clone());
c.borrow_mut().loading = false;
c.borrow().publish(app);
assert_eq!(app.get_explore_count(), 64);
let before_rows = app.get_explore_rows();
let before_tick = app.get_explore_scroll_tick();
c.borrow_mut().page = 2;
c.borrow_mut().view.search = "missing".into();
c.borrow_mut().loading = true;
c.borrow().publish(app);
assert!(app.get_explore_loading());
assert!(app.get_explore_rows() == before_rows);
assert_eq!(app.get_explore_count(), 64);
assert_eq!(app.get_explore_page_number(), 1);
assert_eq!(app.get_explore_scroll_tick(), before_tick);
tx.send(Message::Search(
1,
"old".into(),
Box::new(Err("stale failure".into())),
))
.unwrap();
live.drain(app);
assert_eq!(app.get_explore_count(), 64);
assert!(app.get_explore_notice().is_empty());
assert!(app.get_explore_loading());
tx.send(Message::Search(
2,
"current".into(),
Box::new(Err("simulated failure".into())),
))
.unwrap();
live.drain(app);
// A fast result waits for the feedback interval; no new rows or scroll reset yet.
assert!(app.get_explore_loading());
assert_eq!(app.get_explore_count(), 64);
assert_eq!(app.get_explore_scroll_tick(), before_tick);
c.borrow_mut().view.search.clear();
live.loading_until = None;
live.drain(app);
assert!(!app.get_explore_notice().is_empty());
assert!(app.get_explore_count() > 0);
assert!(!app.get_explore_loading());
assert_eq!(app.get_explore_scroll_tick(), before_tick + 1);
assert_eq!(app.get_explore_page_number(), 1);
let counts = c
.borrow()
.index
.as_ref()
.unwrap()
.query(&c.borrow().view)
.counts;
for (i, expected) in counts.iter().enumerate() {
use slint::Model;
assert_eq!(
app.get_explore_filters().row_data(i).unwrap().count,
*expected as i32
);
}
assert!(counts.iter().any(|n| *n > 0));
live.change(Duration::ZERO);
live.loading_until = None;
tx.send(Message::Search(3, "current".into(), Box::new(Ok(page))))
.unwrap();
live.drain(app);
assert_eq!(app.get_explore_count(), 64);
assert!(app.get_explore_notice().is_empty());
assert_eq!(live.pages.len(), 1);
assert_eq!(app.get_explore_scroll_tick(), before_tick + 2);
// Selection/details publish in-place, preserving ListView geometry and a press in flight.
let rows = app.get_explore_rows();
c.borrow_mut().select("RateCalculator");
c.borrow().publish(app);
assert!(app.get_explore_rows() == rows);
assert_eq!(app.get_explore_scroll_tick(), before_tick + 2);
// An early refresh is ignored before spawning a worker or making any network request.
live.update(app);
assert!(!live.updates_busy);
assert!(live.rx.try_recv().is_err());
c.borrow_mut().select("RateCalculator");
let full: PortalModFull = serde_json::from_str(include_str!(
"../../core/tests/fixtures/full-rate-calculator.json"
))
.unwrap();
live.detail.change(Duration::from_millis(250));
assert!(!live.detail.ready());
live.detail.change(Duration::ZERO);
tx.send(Message::Detail(
1,
"RateCalculator".into(),
Box::new(Ok(full.clone())),
))
.unwrap();
let before = app.get_explore_detail().description;
live.drain(app);
assert_eq!(app.get_explore_detail().description, before);
tx.send(Message::Detail(
2,
"RateCalculator".into(),
Box::new(Ok(full)),
))
.unwrap();
live.drain(app);
let detail = app.get_explore_detail();
assert!(detail.has_changelog);
assert_eq!(detail.version, "3.3.8");
assert!(detail.description.contains("Installation"));
assert!(!detail.description.contains("img.shields.io"));
}