//! Home navigation and asynchronous private checkpoints share the normal guards.
use super::*;
use crate::{home, recovery};

impl App {
    pub(super) fn remember_local(&mut self) {
        if let Some(path) = self.path.clone() {
            let name = self.project().name.clone();
            if let Err(error) = self.home.remember(&path, &name) {
                self.home.notice = Some(error);
            }
        }
    }
    pub(super) fn home_event(&mut self, event: home::Event) -> Task<Message> {
        match event {
            home::Event::New => self.handle(Message::Request(Pending::New)),
            home::Event::Open => self.handle(Message::Request(Pending::Open)),
            home::Event::Example => self.handle(Message::Request(Pending::Demo)),
            home::Event::Walkthrough => self.handle(Message::Request(Pending::Walkthrough)),
            home::Event::Guide => self.update(Message::Page(Page::Guide)),
            home::Event::Resume => self.update(Message::Page(self.last_workspace_page)),
            home::Event::OpenRecent(path) => {
                self.recent_target = Some(path);
                self.handle(Message::Request(Pending::Recent))
            }
            home::Event::Recover(id) => self.handle(Message::Request(Pending::Recover(id))),
            home::Event::Forget(path) => {
                if let Err(error) = self.home.forget(&path) {
                    self.home.notice = Some(error);
                }
                Task::none()
            }
            home::Event::Refresh => {
                self.home.refresh();
                self.recovery.refresh();
                self.recovery.entries.retain(|entry| {
                    entry.id != self.canvas_document && Some(entry.id) != self.recovery.restored
                });
                Task::none()
            }
        }
    }
    pub(super) fn checkpoint_tick(&mut self) -> Task<Message> {
        if self.recovery.writing || self.busy {
            return Task::none();
        }
        if !self.dirty() {
            self.retire_checkpoint();
            return Task::none();
        }
        let Some(directory) = self.recovery.directory.clone() else {
            return Task::none();
        };
        let id = self.canvas_document;
        let snapshot = match recovery::Snapshot::capture(
            id,
            &self.document,
            &self.source_workspace,
            self.draft.as_ref(),
            &self.behavior,
            self.path.clone(),
            self.selected,
        )
        .and_then(|snapshot| snapshot.with_workflow(self.workflow.as_ref()))
        {
            Ok(snapshot) => snapshot,
            Err(error) => {
                self.recovery.warning = Some(error);
                return Task::none();
            }
        };
        self.recovery.writing = true;
        Task::perform(
            async move {
                tokio::task::spawn_blocking(move || recovery::write(&directory, &snapshot))
                    .await
                    .map_err(|e| e.to_string())?
            },
            move |result| Message::CheckpointWritten(id, result),
        )
    }
    pub(super) fn checkpoint_written(&mut self, id: Id, result: Result<(), String>) {
        self.recovery.writing = false;
        match result {
            Ok(()) if id == self.canvas_document && self.dirty() => {
                self.recovery.active = Some(id);
            }
            Ok(()) => {
                if let Some(directory) = &self.recovery.directory
                    && let Err(error) = recovery::remove(directory, id)
                {
                    self.recovery.warning = Some(error);
                }
            }
            Err(error) => {
                self.recovery.warning = Some(format!(
                    "Recovery checkpoint failed: {error}. Save your work explicitly."
                ))
            }
        }
    }
    pub(super) fn retire_checkpoint(&mut self) {
        let Some(directory) = &self.recovery.directory else {
            return;
        };
        for id in [self.recovery.active.take(), self.recovery.restored.take()]
            .into_iter()
            .flatten()
        {
            if let Err(error) = recovery::remove(directory, id) {
                self.recovery.warning = Some(error);
            } else {
                self.recovery.entries.retain(|e| e.id != id);
            }
        }
    }
    pub(super) fn load_checkpoint(&mut self, id: Id) -> Task<Message> {
        let Some(directory) = self.recovery.directory.clone() else {
            return Task::none();
        };
        self.busy = true;
        Task::perform(
            async move {
                tokio::task::spawn_blocking(move || recovery::read(&directory, id).map(Arc::new))
                    .await
                    .map_err(|e| e.to_string())?
            },
            Message::CheckpointLoaded,
        )
    }
    pub(super) fn checkpoint_loaded(
        &mut self,
        result: Result<Arc<recovery::Snapshot>, String>,
    ) -> Task<Message> {
        self.busy = false;
        let snapshot = match result {
            Ok(s) => s,
            Err(error) => {
                self.status = error;
                return Task::none();
            }
        };
        let id = snapshot.id;
        let restored = match (*snapshot).clone().restore() {
            Ok(r) => r,
            Err(error) => {
                self.status = error;
                return Task::none();
            }
        };
        // Fully prepare recovery before touching the currently accepted document.
        self.reset(restored.document.project().clone(), None);
        self.hosted.leave_document();
        self.document = restored.document;
        self.migration = self.document.compiled().decoded.migration.clone();
        self.selected = if self.project().layer_of(restored.selected).is_some()
            || restored.selected == self.project().id
        {
            restored.selected
        } else {
            self.project().id
        };
        // Installing the raw workspace must follow all accepted-source synchronization.
        self.source_workspace = restored.workspace;
        self.show_source_file(false);
        self.refresh_draft();
        if let Some(draft) = restored.property {
            self.selected = draft.original;
            self.exact_strings = draft.exact_strings;
            self.draft = Some(draft);
        }
        self.behavior = restored.behavior;
        self.workflow = restored.workflow;
        let focus = self.behavior.pending_owner().unwrap_or(self.selected);
        if let Some(layer) = self.project().layer_of(focus) {
            self.layer = layer;
            self.explorer_index = crate::explorer::Index::new(self.project(), layer);
            self.active_diagram = self.diagram_for(layer, focus);
        }
        self.recovery.restored = Some(id);
        self.recovery.entries.retain(|entry| entry.id != id);
        self.page = if self.behavior.has_pending() {
            Page::Behavior
        } else if self.source_dirty() {
            Page::Text
        } else {
            Page::Diagram
        };
        self.status = if self.migration.is_some() {
            "Recovered source 5 as source 6 in an unsaved local copy. Draft text is preserved; workflow previews were rebuilt and semantic impact approvals need review. Choose Save as to save it."
        } else {
            "Recovered an unsaved local copy. Choose Save as to save it; the original file and hosted model are unchanged."
        }.into();
        self.request_lint()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn home_resume_returns_to_each_actual_workspace_without_model_edits() {
        let mut app = App::with_project(Project::demo());
        let accepted = app.document.snapshot();
        for page in [
            Page::Diagram,
            Page::Catalog,
            Page::Behavior,
            Page::Data,
            Page::Traces,
            Page::Text,
            Page::Validation,
            Page::Guide,
        ] {
            let _ = app.update(Message::Page(page));
            assert_eq!(app.page, page);
            let selected = app.selected;
            let _ = app.update(Message::Page(Page::Home));
            assert_eq!(app.last_workspace_page, page);
            // Repeated Home events must not replace the remembered workspace.
            let _ = app.update(Message::Page(Page::Home));
            let _ = app.update(Message::Home(home::Event::Resume));
            assert_eq!(app.page, page);
            assert_eq!(app.selected, selected);
            assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
        }
    }

    #[test]
    fn home_resume_keeps_state_view_while_explicit_architecture_remains_reachable() {
        let mut project = Project::empty();
        let owner = project
            .add_element(Kind::System, Layer::Sa, "System", None)
            .unwrap();
        let machine = project
            .add_element(Kind::StateMachine, Layer::Sa, "Modes", Some(owner))
            .unwrap();
        let plan = crate::behavior::state_edit::create_view(&project, machine).unwrap();
        project = prepare_command(&project, &plan.command).unwrap().project;
        let mut app = App::with_project(project);
        assert_eq!(app.page, Page::Behavior);
        let accepted = app.document.snapshot();
        let _ = app.update(Message::Page(Page::Home));
        let _ = app.update(Message::Home(home::Event::Resume));
        assert_eq!(app.page, Page::Behavior);
        assert_eq!(app.state_context().unwrap().diagram, plan.diagram);
        assert_eq!(app.behavior.active_owner, Some(machine));
        let _ = app.update(Message::Page(Page::Diagram));
        assert_eq!(app.page, Page::Diagram);
        assert!(app.active_diagram.is_none());
        let _ = app.update(Message::Page(Page::Home));
        let _ = app.update(Message::Home(home::Event::Resume));
        assert_eq!(app.page, Page::Diagram);
        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
    }

    #[test]
    fn home_resume_retains_invalid_source_and_property_drafts() {
        let mut app = App::with_project(Project::demo());
        let accepted = app.document.snapshot();
        let _ = app.update(Message::Page(Page::Text));
        let raw = format!("{}\nunfinished draft", app.source_workspace.text());
        app.source_workspace
            .edit(raw.clone(), app.source_editor.cursor());
        let _ = app.update(Message::Page(Page::Home));
        let _ = app.update(Message::Home(home::Event::Resume));
        assert_eq!(app.page, Page::Text);
        assert_eq!(app.source_workspace.text(), raw);
        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));

        let mut app = App::with_project(Project::demo());
        let accepted = app.document.snapshot();
        let _ = app.update(Message::Page(Page::Data));
        let _ = app.update(Message::Field("/id".into(), "-".into()));
        let raw = serde_json::to_value(app.draft.as_ref().unwrap().recovery_snapshot()).unwrap();
        assert!(app.draft_dirty());
        let _ = app.update(Message::Page(Page::Home));
        let _ = app.update(Message::Home(home::Event::Resume));
        assert_eq!(app.page, Page::Data);
        assert_eq!(
            serde_json::to_value(app.draft.as_ref().unwrap().recovery_snapshot()).unwrap(),
            raw
        );
        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
    }

    #[test]
    fn walkthrough_request_keeps_unfinished_source_behind_the_normal_pending_guard() {
        let mut app = App::with_project(Project::demo());
        let accepted = app.document.snapshot();
        let raw = format!(
            "{}\nunfinished walkthrough draft",
            app.source_workspace.text()
        );
        app.source_workspace
            .edit(raw.clone(), app.source_editor.cursor());
        let task = app.update(Message::Home(home::Event::Walkthrough));
        assert!(matches!(app.pending, Some(Pending::Walkthrough)));
        assert!(!app.busy);
        assert!(iced_runtime::task::into_stream(task).is_none());
        assert_eq!(app.source_workspace.text(), raw);
        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
        let _ = app.update(Message::Escape);
        assert!(app.pending.is_none());
        assert_eq!(app.source_workspace.text(), raw);
        assert!(Arc::ptr_eq(&accepted, &app.document.snapshot()));
    }

    fn retained_snapshot(app: &App) -> recovery::Snapshot {
        recovery::Snapshot::capture(
            app.canvas_document,
            &app.document,
            &app.source_workspace,
            app.draft.as_ref(),
            &app.behavior,
            app.path.clone(),
            app.selected,
        )
        .unwrap()
    }

    #[test]
    fn saving_an_older_snapshot_keeps_recovery_for_newer_unsaved_work() {
        let directory = tempfile::tempdir().unwrap();
        let mut app = App::with_project(Project::demo());
        app.recovery.directory = Some(directory.path().join("recovery"));
        let id = app.project().id;
        app.execute(Command::Rename(id, "Saved milestone".into()));
        let path = directory.path().join(&app.document.bundle().entry);
        let receipt = write_snapshot(
            app.canvas_document,
            app.document.revision(),
            app.document.snapshot(),
            path,
            None,
        )
        .unwrap();
        app.execute(Command::Rename(id, "Later unsaved engineering".into()));
        let snapshot = retained_snapshot(&app);
        let recovery_directory = app.recovery.directory.clone().unwrap();
        recovery::write(&recovery_directory, &snapshot).unwrap();
        app.recovery.active = Some(app.canvas_document);
        let _ = app.update(Message::Saved(Ok(Some(receipt))));
        assert!(app.dirty());
        assert_eq!(app.project().name, "Later unsaved engineering");
        assert_eq!(app.recovery.active, Some(app.canvas_document));
        let restored = recovery::read(&recovery_directory, app.canvas_document)
            .unwrap()
            .restore()
            .unwrap();
        assert_eq!(
            restored.document.project().name,
            "Later unsaved engineering"
        );
    }

    #[test]
    fn checkpoint_completion_releases_the_writer_while_a_context_menu_is_open() {
        let directory = tempfile::tempdir().unwrap();
        let mut app = App::with_project(Project::demo());
        app.recovery.directory = Some(directory.path().into());
        let id = app.project().id;
        app.execute(Command::Rename(id, "Unsaved engineering".into()));
        let snapshot = retained_snapshot(&app);
        recovery::write(directory.path(), &snapshot).unwrap();
        app.recovery.writing = true;
        let _ = app.update(Message::Menu(crate::model_menu::Event::Open(
            crate::model_menu::Request::object(id, iced::Point::ORIGIN),
        )));
        assert!(app.model_menu.is_some());
        let _ = app.update(Message::CheckpointWritten(app.canvas_document, Ok(())));
        assert!(
            !app.recovery.writing,
            "A passive completion cannot be swallowed by an open menu"
        );
        assert_eq!(app.recovery.active, Some(app.canvas_document));
        assert!(
            app.model_menu.is_some(),
            "Saving a checkpoint does not dismiss the menu"
        );
        assert_eq!(app.project().name, "Unsaved engineering");
    }

    #[test]
    fn discard_and_close_waits_for_the_late_checkpoint_then_retires_it() {
        let directory = tempfile::tempdir().unwrap();
        let mut app = App::with_project(Project::demo());
        app.recovery.directory = Some(directory.path().into());
        app.execute(Command::Rename(
            app.project().id,
            "Discarded on close".into(),
        ));
        let snapshot = retained_snapshot(&app);
        let document = app.canvas_document;
        app.recovery.writing = true;
        let window = window::Id::unique();
        let _ = app.update(Message::Request(Pending::Close(window)));
        assert!(matches!(app.pending, Some(Pending::Close(id)) if id == window));
        let closing = app.update(Message::Discard);
        assert!(
            iced_runtime::task::into_stream(closing).is_none(),
            "The window must remain until its outstanding writer finishes"
        );
        assert_eq!(app.checkpoint_close, Some(window));
        assert!(app.busy);
        recovery::write(directory.path(), &snapshot).unwrap();
        assert!(recovery::read(directory.path(), document).is_ok());
        let close = app.update(Message::CheckpointWritten(document, Ok(())));
        assert!(
            iced_runtime::task::into_stream(close).is_some(),
            "Close is emitted after checkpoint cleanup"
        );
        assert!(app.checkpoint_close.is_none());
        assert!(recovery::read(directory.path(), document).is_err());
        assert!(app.recovery.active.is_none());
    }
    #[test]
    fn recent_and_recovery_navigation_respect_unsaved_decision() {
        let mut app = App::with_project(Project::demo());
        let id = app.project().id;
        app.execute(Command::Rename(id, "Retained work".into()));
        let _ = app.update(Message::Home(home::Event::OpenRecent(PathBuf::from(
            "missing.arcadia",
        ))));
        assert!(matches!(app.pending, Some(Pending::Recent)));
        assert!(!app.busy);
        assert_eq!(app.project().name, "Retained work");
        let _ = app.update(Message::Cancel);
        let recovery_id = Id::new_v4();
        let _ = app.update(Message::Home(home::Event::Recover(recovery_id)));
        assert!(matches!(app.pending,Some(Pending::Recover(id)) if id==recovery_id));
        assert!(!app.busy);
    }
    #[test]
    fn restored_copy_keeps_raw_property_and_requires_save_without_local_or_hosted_binding() {
        let mut app = App::with_project(Project::demo());
        let selected = app.project().id;
        app.draft
            .as_mut()
            .unwrap()
            .input("/name", "Not yet applied".into());
        let snapshot = recovery::Snapshot::capture(
            Id::new_v4(),
            &app.document,
            &app.source_workspace,
            app.draft.as_ref(),
            &app.behavior,
            Some(PathBuf::from("original.arcadia")),
            selected,
        )
        .unwrap();
        let checkpoint_id = snapshot.id;
        app.recovery.entries.push(recovery::Entry {
            id: checkpoint_id,
            name: "Retained work".into(),
            origin: None,
            modified: snapshot.modified,
        });
        let _ = app.checkpoint_loaded(Ok(Arc::new(snapshot)));
        assert!(app.path.is_none());
        assert!(app.disk_project.is_none());
        assert!(app.hosted.session.is_none());
        assert!(app.document.dirty());
        assert!(app.draft_dirty());
        assert_eq!(app.recovery.restored, Some(checkpoint_id));
        assert!(
            app.recovery.entries.is_empty(),
            "Home must not offer the copy currently being recovered again"
        );
        assert_eq!(
            app.draft.as_ref().unwrap().inputs["/name"].raw,
            "Not yet applied"
        );
        assert_ne!(app.project().name, "Not yet applied");
    }
    #[test]
    fn stale_write_completion_cannot_recover_a_discarded_document() {
        let directory = tempfile::tempdir().unwrap();
        let mut app = App::with_project(Project::demo());
        app.recovery.directory = Some(directory.path().into());
        let old = app.canvas_document;
        let s = recovery::Snapshot::capture(
            old,
            &app.document,
            &app.source_workspace,
            None,
            &app.behavior,
            None,
            app.selected,
        )
        .unwrap();
        app.reset(Project::empty(), None);
        recovery::write(directory.path(), &s).unwrap();
        app.checkpoint_written(old, Ok(()));
        assert!(recovery::read(directory.path(), old).is_err());
        assert!(app.recovery.active.is_none());
    }
    #[test]
    fn malformed_checkpoint_does_not_replace_the_current_model() {
        let mut app = App::with_project(Project::demo());
        let original = app.document.bundle().clone();
        let _ = app.checkpoint_loaded(Err("Damaged checkpoint".into()));
        assert_eq!(app.document.bundle(), &original);
        assert!(app.status.contains("Damaged"));
    }
}