Mountain/Binary/Main/

Entry.rs

//! # Entry (Binary/Main)
//!
//! ## RESPONSIBILITIES
//!
//! Main application entry point that orchestrates the complete application
//! lifecycle. This function coordinates:
//! - Tokio runtime creation and management
//! - CLI argument parsing
//! - Application state initialization
//! - Tauri application builder setup
//! - Service initialization (Vine, Cocoon, Configuration)
//! - Graceful shutdown handling
//!
//! ## ARCHITECTURAL ROLE
//!
//! The Entry module is the **primary entry point** in Mountain's architecture:
//!
//! ```text
//! main.rs ──► Binary::Main::Entry::Fn()
//!                                    │
//!                                    ▼
//! AppLifecycle ──► Service Initialization ──► Tauri App Run
//!                                           │
//!                                           ▼
//!                                   Graceful Shutdown
//! ```
//!
//! ## KEY COMPONENTS
//!
//! - **Fn()**: Main entry point exported as `Binary::Main::Fn()`
//! - Tokio runtime management
//! - Application state initialization via StateBuild
//! - Tauri builder configuration via TauriBuild
//! - Service orchestration (Vine, Cocoon, Configuration)
//! - Event-driven lifecycle management
//!
//! ## ERROR HANDLING
//!
//! - Panics on fatal errors (Tokio runtime failure, Tauri build failure)
//! - Logs errors for service initialization failures
//! - Graceful degradation for non-critical service failures
//!
//! ## LOGGING
//!
//! Uses the TraceStep! macro for checkpoint logging at TRACE level.
//! Additional logging at DEBUG, INFO, WARN, and ERROR levels throughout.
//!
//! ## PERFORMANCE CONSIDERATIONS
//!
//! - Tokio multi-threaded runtime for optimal performance
//! - Asynchronous service initialization
//! - Lazy initialization where possible
//!
//! ## TODO
//! - [ ] Add crash recovery mechanism
//! - [ ] Implement proper error dialog for startup failures
//! - [ ] Add startup performance metrics

use std::sync::Arc;

use log::{debug, error, info, trace, warn};
use tauri::{App, RunEvent, Wry};
use Echo::Scheduler::{Scheduler::Scheduler, SchedulerBuilder::SchedulerBuilder};

use crate::{
	// Crate root imports
	ApplicationState::ApplicationState,
	// Binary submodule imports
	Binary::Build::LocalhostPlugin::LocalhostPlugin as LocalhostPluginFn,
	Binary::Build::LoggingPlugin::LoggingPlugin as LoggingPluginFn,
	Binary::Build::TauriBuild::TauriBuild as TauriBuildFn,
	Binary::Build::WindowBuild::WindowBuild as WindowBuildFn,
	Binary::Extension::ExtensionPopulate::ExtensionPopulate as ExtensionPopulateFn,
	Binary::Extension::ScanPathConfigure::ScanPathConfigure as ScanPathConfigureFn,
	Binary::Initialize::CliParse::Parse as CliParseFn,
	Binary::Initialize::LogLevel::Resolve as ResolveLogLevel,
	Binary::Initialize::PortSelector::BuildUrl as BuildPortUrl,
	Binary::Initialize::PortSelector::Select as SelectPort,
	Binary::Initialize::StateBuild::Build as BuildStateFn,
	Binary::Register::AdvancedFeaturesRegister::AdvancedFeaturesRegister as AdvancedFeaturesRegisterFn,
	Binary::Register::CommandRegister::CommandRegister as CommandRegisterFn,
	Binary::Register::IPCServerRegister::IPCServerRegister as IPCServerRegisterFn,
	Binary::Register::StatusReporterRegister::StatusReporterRegister as StatusReporterRegisterFn,
	Binary::Register::WindSyncRegister::WindSyncRegister as WindSyncRegisterFn,
	Binary::Service::CocoonStart::CocoonStart as CocoonStartFn,
	Binary::Service::ConfigurationInitialize::ConfigurationInitialize as ConfigurationInitializeFn,
	Binary::Service::VineStart::VineStart as VineStartFn,
	Binary::Shutdown::RuntimeShutdown::RuntimeShutdown as RuntimeShutdownFn,
	Binary::Shutdown::SchedulerShutdown::SchedulerShutdown as SchedulerShutdownFn,
	Command,
	Environment::MountainEnvironment::MountainEnvironment,
	ProcessManagement::InitializationData,
	RunTime::ApplicationRunTime::ApplicationRunTime,
	Track,
};
use super::AppLifecycle::AppLifecycleSetup;

// Note: Tauri commands are used with fully qualified paths in generate_handler
// because the __cmd_* macros generated by #[tauri::command] are module-local.

/// Logs a checkpoint message at TRACE level.
macro_rules! TraceStep {
	($($arg:tt)*) => {{
		trace!($($arg)*);
	}};
}

/// The main function that orchestrates the application lifecycle.
///
/// This function:
/// 1. Creates a Tokio runtime
/// 2. Parses CLI arguments
/// 3. Builds application state
/// 4. Creates a scheduler
/// 5. Selects a port for the local server
/// 6. Resolves the log level
/// 7. Sets up the Tauri builder
/// 8. Configures the application lifecycle
/// 9. Runs the Tauri application
/// 10. Handles graceful shutdown
pub fn Fn() {
	// -------------------------------------------------------------------------
	// [Boot] [Runtime] Tokio runtime creation
	// -------------------------------------------------------------------------
	TraceStep!("[Boot] [Runtime] Building Tokio runtime...");

	let Runtime = tokio::runtime::Builder::new_multi_thread()
		.enable_all()
		.build()
		.expect("FATAL: Cannot build Tokio runtime.");

	TraceStep!("[Boot] [Runtime] Tokio runtime built.");

	Runtime.block_on(async {
		// ---------------------------------------------------------------------
		// [Boot] [Args] CLI parsing (using CliParse module)
		// ---------------------------------------------------------------------
		let _WorkspaceConfigurationPath = CliParseFn();
		let _InitialFolders: Vec<String> = vec![];

		// ---------------------------------------------------------------------
		// [Boot] [State] ApplicationState (using StateBuild module)
		// ---------------------------------------------------------------------
		debug!("[Boot] [State] Building ApplicationState...");

		// Create application state directly (StateBuild::Build with default config)
		let AppState = ApplicationState::default();

		debug!(
			"[Boot] [State] ApplicationState created with {} workspace folders.",
			AppState.Workspace.WorkspaceFolders.lock().map(|f| f.len()).unwrap_or(0)
		);

		// Create Arc for application state to be managed by Tauri
		let AppStateArcForClosure = Arc::new(AppState.clone());

		// ---------------------------------------------------------------------
		// [Boot] [Runtime] Scheduler handles (using RuntimeBuild module)
		// ---------------------------------------------------------------------
		let Scheduler = Arc::new(SchedulerBuilder::Create().Build());
		let SchedulerForClosure = Scheduler.clone();
		TraceStep!("[Boot] [Echo] Scheduler handles prepared.");

		// ---------------------------------------------------------------------
		// [Boot] [Localhost] Port selection (using PortSelector module)
		// ---------------------------------------------------------------------
		let ServerPort = SelectPort();
		let LocalhostUrl = BuildPortUrl(ServerPort);

		// ---------------------------------------------------------------------
		// [Boot] [Logging] Log level resolution (using LogLevel module)
		// ---------------------------------------------------------------------
		let log_level = ResolveLogLevel();

		// ---------------------------------------------------------------------
		// [Boot] [Tauri] Builder setup (using TauriBuild module)
		// ---------------------------------------------------------------------
		let Builder = TauriBuildFn();

		Builder
			.plugin(LoggingPluginFn(log_level))
			.plugin(LocalhostPluginFn(ServerPort))
			.manage(AppStateArcForClosure.clone())
			.setup({
				let LocalhostUrl = LocalhostUrl.clone();
				move |app:&mut App| {
					info!("[Lifecycle] [Setup] Setup hook started.");
					debug!("[Lifecycle] [Setup] LocalhostUrl={}", LocalhostUrl);

					let AppHandle = app.handle().clone();
					TraceStep!("[Lifecycle] [Setup] AppHandle acquired.");

					// ---------------------------------------------------------
					// Setup application lifecycle through AppLifecycle module
					// ---------------------------------------------------------
					let AppStateArcFromClosure = AppStateArcForClosure.clone();
					
					if let Err(e) = AppLifecycleSetup(
						app,
						AppHandle.clone(),
						LocalhostUrl.clone(),
						SchedulerForClosure.clone(),
						AppStateArcFromClosure,
					) {
						error!("[Lifecycle] [Setup] Failed to setup lifecycle: {}", e);
					}

					Ok(())
				}
			})
			.plugin(tauri_plugin_dialog::init())
			.plugin(tauri_plugin_fs::init())
			.invoke_handler(tauri::generate_handler![
				crate::Binary::Tray::SwitchTrayIcon::SwitchTrayIcon,
				crate::Binary::IPC::WorkbenchConfigurationCommand::MountainGetWorkbenchConfiguration,
				Command::TreeView::GetTreeViewChildren,
				Command::LanguageFeature::MountainProvideHover,
				Command::LanguageFeature::MountainProvideCompletions,
				Command::LanguageFeature::MountainProvideDefinition,
				Command::LanguageFeature::MountainProvideReferences,
				Command::SourceControlManagement::GetAllSourceControlManagementState,
				Command::Keybinding::GetResolvedKeybinding,
				Track::FrontendCommand::DispatchFrontendCommand,
				Track::UIRequest::ResolveUIRequest,
				Track::Webview::MountainWebviewPostMessageFromGuest,
				crate::Binary::IPC::MessageReceiveCommand::MountainIPCReceiveMessage,
				crate::Binary::IPC::StatusGetCommand::MountainIPCGetStatus,
				crate::Binary::IPC::InvokeCommand::MountainIPCInvoke,
				crate::Binary::IPC::WindConfigurationCommand::MountainGetWindDesktopConfiguration,
				crate::Binary::IPC::ConfigurationUpdateCommand::MountainUpdateConfigurationFromWind,
				crate::Binary::IPC::ConfigurationSyncCommand::MountainSynchronizeConfiguration,
				crate::Binary::IPC::ConfigurationStatusCommand::MountainGetConfigurationStatus,
				crate::Binary::IPC::IPCStatusCommand::MountainGetIPCStatus,
				crate::Binary::IPC::IPCStatusHistoryCommand::MountainGetIPCStatusHistory,
				crate::Binary::IPC::IPCStatusReportingStartCommand::MountainStartIPCStatusReporting,
				crate::Binary::IPC::PerformanceStatsCommand::MountainGetPerformanceStats,
				crate::Binary::IPC::CacheStatsCommand::MountainGetCacheStats,
				crate::Binary::IPC::CollaborationSessionCommand::MountainCreateCollaborationSession,
				crate::Binary::IPC::CollaborationSessionCommand::MountainGetCollaborationSessions,
				crate::Binary::IPC::DocumentSyncCommand::MountainAddDocumentForSync,
				crate::Binary::IPC::DocumentSyncCommand::MountainGetSyncStatus,
				crate::Binary::IPC::UpdateSubscriptionCommand::MountainSubscribeToUpdates,
				crate::Binary::IPC::ConfigurationDataCommand::GetConfigurationData,
				crate::Binary::IPC::ConfigurationDataCommand::SaveConfigurationData,
			])
			.build(tauri::generate_context!())
			.expect("FATAL: Error while building Mountain Tauri application")
			.run(move |app_handle:&tauri::AppHandle, event:tauri::RunEvent| {
				// Debug-only: log selected lifecycle events
				if cfg!(debug_assertions) {
					match &event {
						RunEvent::MainEventsCleared => {},
						RunEvent::WindowEvent { .. } => {},
						_ => debug!("[Lifecycle] [RunEvent] {:?}", event),
					}
				}

				if let RunEvent::ExitRequested { api, .. } = event {
					warn!("[Lifecycle] [Shutdown] Exit requested. Starting graceful shutdown...");
					api.prevent_exit();

					let SchedulerHandle = Scheduler.clone();
					let app_handle_clone = app_handle.clone();

					tokio::spawn(async move {
						debug!("[Lifecycle] [Shutdown] Shutting down ApplicationRunTime...");
						let _ = RuntimeShutdownFn(&app_handle_clone).await;

						debug!("[Lifecycle] [Shutdown] Stopping Echo scheduler...");
						let _ = SchedulerShutdownFn(SchedulerHandle).await;

						info!("[Lifecycle] [Shutdown] Done. Exiting process.");
						app_handle_clone.exit(0);
					});
				}
			});

		info!("[Lifecycle] [Exit] Mountain application has shut down.");
	});
}