use iced::Task;
use knotra_vcs::{
VcsAdapter,
model::operation::{OperationId, OperationKind, OperationLog, OperationResult},
};
use super::shared;
use crate::{
config::{DashboardGrouping, save_config},
message::{
BackgroundMessage, DashboardMessage, HistoryMessage, LaunchMessage, Message,
PaletteMessage, ProjectMessage, SelectionMessage, SettingsMessage, TagPushMessage,
},
persistence::load_recent_logs,
state::{AppState, OperationOwner},
};
pub(super) fn handle_project(state: &mut AppState, msg: ProjectMessage) -> Task<Message> {
match msg {
ProjectMessage::StatusRefreshRequested(id) => {
let project = shared::find_project(state, &id);
if let Some(p) = project {
Task::perform(
async move { VcsAdapter::read_project_status(&p).await },
|s| {
Message::Background(BackgroundMessage::WorkspaceStatusRefreshed(
knotra_vcs::WorkspaceStatus {
projects: vec![s],
last_refresh: Some(jiff::Timestamp::now()),
},
))
},
)
} else {
Task::none()
}
}
ProjectMessage::FetchRequested(id) => {
let project = shared::find_project(state, &id);
if let Some(p) = project {
let Some(lease_id) = shared::acquire_operation(state, OperationOwner::SingleFetch)
else {
return Task::none();
};
state.fetching_projects.insert(id.clone());
Task::perform(
async move {
let started = jiff::Timestamp::now();
let op_id = OperationId::new();
let result = VcsAdapter::fetch(&p).await;
OperationLog {
result: OperationResult {
operation_id: op_id,
kind: OperationKind::Fetch,
started_at: started,
finished_at: jiff::Timestamp::now(),
per_project: vec![result],
rollback_attempted: false,
rollback_succeeded: None,
},
recovery_hints: vec![],
}
},
move |log| {
Message::Background(BackgroundMessage::SingleFetchCompleted {
lease_id,
log,
})
},
)
} else {
state.fetching_projects.remove(&id);
Task::none()
}
}
}
}
pub(super) fn handle_history(state: &mut AppState, msg: HistoryMessage) -> Task<Message> {
match msg {
HistoryMessage::SearchChanged(s) => {
state.history_search = s;
}
HistoryMessage::EntryToggled(id) => {
if state.history_expanded.contains(&id) {
state.history_expanded.remove(&id);
} else {
state.history_expanded.insert(id);
}
}
}
Task::none()
}
pub(super) fn handle_settings(state: &mut AppState, msg: SettingsMessage) -> Task<Message> {
match msg {
SettingsMessage::LocaleChanged(l) => {
state.config.locale = l;
state.catalog = knotra_ui::i18n::Catalog::for_locale(l);
persist_config(state);
}
SettingsMessage::ThemeChanged(choice) => {
state.config.theme = choice;
state.theme = knotra_ui::KnotraTheme::from_choice(choice);
persist_config(state);
}
SettingsMessage::ZoomChanged(percent) => {
state.config.zoom_percent = percent;
persist_config(state);
}
SettingsMessage::RefreshAutoChanged(secs) => {
state.config.refresh_interval_secs = secs;
persist_config(state);
}
SettingsMessage::MaxConcurrentChanged(n) => {
state.config.max_concurrent_reads = n;
persist_config(state);
}
SettingsMessage::ExternalEditorChanged(s) => {
state.settings_edit.external_editor = s.clone();
state.config.external_editor = if s.trim().is_empty() {
None
} else {
Some(s.trim().to_owned())
};
persist_config(state);
}
SettingsMessage::ExternalMergeToolChanged(s) => {
state.settings_edit.external_merge_tool = s.clone();
state.config.external_merge_tool = if s.trim().is_empty() {
None
} else {
Some(s.trim().to_owned())
};
persist_config(state);
}
SettingsMessage::MaxLogEntriesChanged(n) => {
state.config.max_log_entries = n;
persist_config(state);
if state.operation_logs.len() > n {
let dropped = state.operation_logs.split_off(n);
for log in &dropped {
state.history_expanded.remove(&log.result.operation_id);
}
} else if state.operation_logs.len() < n {
let paths = state.paths.clone();
return Task::perform(
async move {
tokio::task::spawn_blocking(move || load_recent_logs(&paths, n))
.await
.expect("blocking task must not panic")
},
|loaded| Message::Background(BackgroundMessage::HistoryLogsReloaded(loaded)),
);
}
}
SettingsMessage::FsWatchEnabledChanged(v) => {
state.config.fs_watch_enabled = v;
persist_config(state);
}
SettingsMessage::FsDebounceSecs(secs) => {
state.config.fs_debounce_secs = secs;
persist_config(state);
}
SettingsMessage::AdvancedToggled => {
state.settings_advanced_open = !state.settings_advanced_open;
}
}
Task::none()
}
pub(super) fn handle_launch(state: &mut AppState, msg: LaunchMessage) -> Task<Message> {
let (tool_path, file_path) = match msg {
LaunchMessage::OpenInEditor(path) => (state.config.external_editor.clone(), path),
LaunchMessage::OpenInMergeTool(path) => (state.config.external_merge_tool.clone(), path),
};
let Some(tool) = tool_path else {
state.status_bar = Some(state.t("tool.not_configured").to_owned());
return Task::none();
};
match std::process::Command::new(&tool).arg(&file_path).spawn() {
Ok(_) => {
state.status_bar = Some(format!(
"{} {} {:?}",
state.t("plain.activity.launched"),
tool,
file_path
));
}
Err(e) => {
state.status_bar = Some(format!("{} {}: {e}", state.t("tool.launch_failed"), tool));
}
}
Task::none()
}
pub(super) fn handle_tag_push(state: &mut AppState, msg: TagPushMessage) -> Task<Message> {
match msg {
TagPushMessage::PushConfirmed => {
let push = match &state.pending_tag_push {
Some(p) => p.clone(),
None => return Task::none(),
};
let Some(lease_id) = shared::acquire_operation(state, OperationOwner::TagPush) else {
return Task::none();
};
if let Some(ref mut p) = state.pending_tag_push {
p.is_pushing = true;
}
let projects: Vec<_> = push
.project_ids
.iter()
.filter_map(|id| shared::find_project(state, id))
.collect();
let tag_name = push.freeze_name.clone();
let max = state.config.max_concurrent_reads;
Task::perform(
async move {
use std::sync::Arc;
use tokio::sync::Semaphore;
let sem = Arc::new(Semaphore::new(max));
let mut handles = Vec::new();
for project in projects {
let sem = Arc::clone(&sem);
let tag = tag_name.clone();
handles.push(tokio::spawn(async move {
let _permit = sem.acquire().await.expect("open");
knotra_vcs::VcsAdapter::push_tag(&project, &tag).await
}));
}
let mut results = Vec::new();
for h in handles {
if let Ok(r) = h.await {
results.push(r);
}
}
let success = results.iter().filter(|r| r.success).count();
let failed = results.iter().filter(|r| !r.success).count();
(success, failed)
},
move |(success_count, fail_count)| {
Message::Background(BackgroundMessage::TagPushCompleted {
lease_id,
success_count,
fail_count,
})
},
)
}
TagPushMessage::PushDeclined => {
if state
.pending_tag_push
.as_ref()
.is_some_and(|push| push.is_pushing)
{
return Task::none();
}
state.pending_tag_push = None;
Task::none()
}
}
}
pub(super) fn handle_selection(state: &mut AppState, msg: SelectionMessage) -> Task<Message> {
let ordered: Vec<knotra_vcs::ProjectId> = state.visible_project_ids();
match msg {
SelectionMessage::ModeEntered => state.selection_mode = true,
SelectionMessage::ModeExited => state.clear_selection_mode(),
SelectionMessage::Toggled(id) => {
let active_ids: std::collections::HashSet<_> = ordered.iter().cloned().collect();
if !active_ids.contains(&id) {
return Task::none();
}
state.selection_mode = true; state.selection.toggle(id);
}
SelectionMessage::SelectAll => {
state.selection_mode = true;
let ids = state.visible_project_ids();
state.selection.clear();
state.selection.select_all(&ids);
}
SelectionMessage::Clear => state.clear_selection_mode(),
}
Task::none()
}
pub(super) fn handle_palette(state: &mut AppState, msg: PaletteMessage) -> Task<Message> {
match msg {
PaletteMessage::Opened => {
state.palette.open_palette();
crate::state::palette::update_results(state);
}
PaletteMessage::Closed => state.palette.close(),
PaletteMessage::QueryChanged(q) => {
state.palette.query = q;
state.palette.notice_key = None;
crate::state::palette::update_results(state);
}
PaletteMessage::EntryClicked(i) => match crate::state::palette::dispatch_entry(state, i) {
crate::state::palette::PaletteDispatch::Dispatched(msg) => {
state.palette.close();
return Task::done(msg);
}
crate::state::palette::PaletteDispatch::Disabled(reason) => {
state.palette.notice_key = Some(reason);
}
crate::state::palette::PaletteDispatch::Noop => {
state.palette.notice_key = Some("palette.disabled.unavailable");
}
},
}
Task::none()
}
pub(super) fn handle_dashboard(state: &mut AppState, msg: DashboardMessage) -> Task<Message> {
match msg {
DashboardMessage::GroupingChanged(grouping) => {
state.config.dashboard_grouping = grouping;
persist_config(state);
state.reconcile_selection_with_display();
}
DashboardMessage::SortChanged(sort) => {
state.config.dashboard_sort = sort;
persist_config(state);
}
DashboardMessage::TierToggled(tier) => {
if state.config.dashboard_grouping == DashboardGrouping::Attention {
match tier {
crate::state::dashboard::DashboardTier::NeedsHelp => {}
crate::state::dashboard::DashboardTier::InProgress => {
state.config.dashboard_in_progress_collapsed =
!state.config.dashboard_in_progress_collapsed;
}
crate::state::dashboard::DashboardTier::AllSet => {
state.config.dashboard_all_set_collapsed =
!state.config.dashboard_all_set_collapsed;
}
}
persist_config(state);
state.reconcile_selection_with_display();
}
}
DashboardMessage::ArrangeToggled => {
state.dashboard_arrange_open = !state.dashboard_arrange_open;
}
}
Task::none()
}
fn persist_config(state: &mut AppState) {
match save_config(&state.config, &state.paths) {
Ok(()) => state.settings_save_msg = None,
Err(error) => {
tracing::warn!("failed to persist settings: {error}");
let msg = format!("{} {error}", state.t("settings.save_error"));
state.settings_save_msg = Some(msg.clone());
state.status_bar = Some(msg);
}
}
}