use crate::model::{
ManageModel, Pending, Pins, ViewState, enabled, filter_and_sort, manage_model, next_sort,
ordered_mods,
};
use fmm_core::{
Result,
mod_list::ModList,
store::{RUNNING_MESSAGE, Snapshot},
};
pub trait ManageEffects {
fn running(&mut self) -> bool;
fn apply(&mut self, snapshot: &Snapshot, pending: &Pending, pins: &Pins) -> Result<ModList>;
fn quit(&mut self);
}
pub struct Controller {
pub snapshot: Snapshot,
pub pending: Pending,
pub pins: Pins,
pub notice: String,
pub selection: Option<String>,
pub error: String,
pub view: ViewState,
pub changelog_revision: u64,
pub changelog: fmm_core::changelog::Changelog,
pub downloads: Vec<crate::model::Row>,
}
impl Controller {
pub fn new(snapshot: Snapshot) -> Self {
let selection = ordered_mods(&snapshot)
.iter()
.find(|m| m.source != fmm_core::local_mods::ModSource::Builtin)
.map(|m| m.name.clone());
let mut controller = Self {
snapshot,
pending: Vec::new(),
pins: Vec::new(),
notice: String::new(),
selection,
error: String::new(),
view: ViewState::default(),
changelog_revision: 0,
changelog: Default::default(),
downloads: Vec::new(),
};
controller.load_changelog();
controller
}
pub fn model(&self) -> ManageModel {
let preview = self.preview();
let mut model = manage_model(&preview, &self.pending, self.selection.as_deref());
for row in &mut model.rows {
row.pending = self.pending.iter().any(|(name, _)| name == &row.name)
|| self.pins.iter().any(|(name, _)| name == &row.name)
|| !self
.snapshot
.mod_list
.mods
.iter()
.any(|entry| entry.name == row.name);
}
model.pending_count = model.rows.iter().filter(|row| row.pending).count() as i32;
let diagnostics = fmm_core::enable::diagnose(&self.snapshot, &self.pending, &self.pins);
let conflicts = diagnostics
.iter()
.filter(|(_, d)| !d.incompatible.is_empty())
.map(|(n, d)| format!("{n} incompatible with {}", d.incompatible.join(", ")))
.collect::<Vec<_>>();
model.notice = [self.notice.clone(), conflicts.join("; ")]
.into_iter()
.filter(|s| !s.is_empty())
.collect::<Vec<_>>()
.join("\n");
model.view = self.view.clone();
model.changelog = self.changelog.clone();
for download in &self.downloads {
if let Some(row) = model.rows.iter_mut().find(|r| r.name == download.name) {
row.download = download.download;
row.failed = download.failed;
row.fraction = download.fraction;
row.progress_label = download.progress_label.clone();
if download.download {
row.title = download.title.clone();
row.version = download.version.clone();
row.pending = false;
row.placeholder = true;
row.dimmed = true;
row.locked = true;
row.checked = false;
}
} else {
model.rows.push(download.clone());
}
}
filter_and_sort(&mut model.rows, &model.view);
model
}
pub fn preview(&self) -> Snapshot {
Snapshot {
mod_list: fmm_core::enable::effective_list(&self.snapshot, &vec![], &self.pins),
..self.snapshot.clone()
}
}
pub fn pin(&mut self, index: i32) {
let Some(name) = self.selection.clone() else {
return;
};
let versions = fmm_core::enable::installed_versions(&self.snapshot, &name);
let choice = if index == 0 {
None
} else {
versions.get((index - 1) as usize).cloned()
};
if index < 0 || index as usize > versions.len() {
return;
}
match fmm_core::enable::set_pin(&self.snapshot, &self.pins, &name, choice) {
Ok(pins) => {
self.pins = pins;
self.view.changelog_version = 0;
self.view.changelog_subversion = 0;
self.load_changelog();
}
Err(e) => self.error = e.to_string(),
}
}
pub fn missing_dependencies(&self) -> Vec<fmm_core::version::Dependency> {
self.selection
.as_ref()
.map(|n| {
fmm_core::enable::install_requirements(&self.snapshot, &self.pending, &self.pins, n)
})
.unwrap_or_default()
}
fn contains(&self, name: &str) -> bool {
ordered_mods(&self.snapshot).iter().any(|m| m.name == name)
}
pub fn select(&mut self, name: &str) {
if self.contains(name) && self.selection.as_deref() != Some(name) {
self.selection = Some(name.into());
self.view.changelog_version = 0;
self.view.changelog_subversion = 0;
self.view.changelog_category = 3;
self.load_changelog();
}
}
pub fn focus_installed(&mut self, name: &str) -> bool {
if !self.contains(name) {
return false;
}
self.view.search_open = false;
self.view.search_text.clear();
self.view.show_changelog = false;
self.select(name);
true
}
fn load_changelog(&mut self) {
self.changelog_revision += 1;
self.notice.clear();
self.error.clear();
self.changelog = Default::default();
let preview = self.preview();
if let Some(mod_) = ordered_mods(&preview)
.into_iter()
.find(|m| Some(m.name.as_str()) == self.selection.as_deref())
{
match fmm_core::changelog::read(mod_) {
Ok(log) => self.changelog = log.unwrap_or_default(),
Err(e) => self.error = format!("Cannot read changelog: {e}"),
}
}
}
pub fn sort(&mut self, column: i32) {
if !matches!(column, 0..=2) {
return;
}
(self.view.sort_column, self.view.ascending) =
next_sort(self.view.sort_column, self.view.ascending, column);
}
pub fn search(&mut self, text: &str) {
self.view.search_text = text.into();
}
pub fn toggle_search(&mut self) {
self.view.search_open = !self.view.search_open;
if !self.view.search_open {
self.view.search_text.clear();
}
}
pub fn open_changelog(&mut self) {
if self.selection.is_some() {
self.view.show_changelog = true;
}
}
pub fn changelog_filter(&mut self, kind: i32, index: i32) {
let Ok(index) = usize::try_from(index) else {
return;
};
match kind {
0 if index < self.changelog.versions().len() => {
self.view.changelog_version = index;
self.view.changelog_subversion = 0;
}
1 if self
.changelog
.versions()
.get(self.view.changelog_version)
.is_some_and(|v| index < self.changelog.subversions(v).len()) =>
{
self.view.changelog_subversion = index
}
2 if index < 4 => self.view.changelog_category = index,
_ => (),
}
}
pub fn toggle(&mut self, name: &str) {
if !self.contains(name) {
return;
}
let value = !enabled(&self.snapshot, &self.pending, name);
self.pending = fmm_core::enable::set_pending(&self.snapshot, &self.pending, name, value);
self.notice.clear();
self.error.clear();
}
pub fn toggle_all(&mut self) {
let names: Vec<_> = self
.model()
.rows
.into_iter()
.filter(|m| m.name != "base")
.map(|m| m.name.clone())
.collect();
let value = !names
.iter()
.all(|n| enabled(&self.snapshot, &self.pending, n));
for name in names {
self.pending =
fmm_core::enable::set_pending(&self.snapshot, &self.pending, &name, value);
}
self.notice.clear();
self.error.clear();
}
pub fn confirm(&mut self, effects: &mut dyn ManageEffects) {
if self.save(effects) {
effects.quit();
}
}
pub fn save(&mut self, effects: &mut dyn ManageEffects) -> bool {
if self.model().pending_count == 0 {
return true;
}
if effects.running() {
self.error = RUNNING_MESSAGE.into();
return false;
}
match effects.apply(&self.snapshot, &self.pending, &self.pins) {
Ok(list) => {
self.snapshot.mod_list = list;
self.pending.clear();
self.pins.clear();
self.notice.clear();
self.error.clear();
true
}
Err(e) => {
self.error = format!("Error: {e}");
false
}
}
}
/// Back / Exit: closes without applying anything.
pub fn back(&self, effects: &mut dyn ManageEffects) {
effects.quit();
}
/// Undo: drops every pending change. Touches neither the mod list nor the disk.
pub fn undo(&mut self) {
self.pending.clear();
self.pins.clear();
self.notice.clear();
self.load_changelog();
self.error.clear();
}
}