Mountain/Binary/Main/

Entry.rs

#![allow(unused_imports)]

//! # 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 tauri::{App, Manager, RunEvent, Wry};
use Echo::Scheduler::{Scheduler::Scheduler, SchedulerBuilder::SchedulerBuilder};

use crate::dev_log;
use crate::{
	// Crate root imports
	ApplicationState::ApplicationState,
	Binary::Build::DnsCommands::init_dns_startup_time,
	Binary::Build::DnsCommands::{
		self,
		dns_get_forward_allowlist,
		dns_get_health_status,
		dns_get_server_info,
		dns_get_zone_info,
		dns_health_check,
		dns_resolve,
		dns_test_resolution,
	},
	// Binary submodule imports
	Binary::Build::LocalhostPlugin::LocalhostPlugin as LocalhostPluginFn,
	Binary::Build::LoggingPlugin::LoggingPlugin as LoggingPluginFn,
	Binary::Build::Scheme::{self, DnsPort, init_service_registry, land_scheme_handler, register_land_service},
	Binary::Build::ServiceRegistry::ServiceRegistry as ServiceRegistryFn,
	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)*) => {{
		dev_log!("lifecycle", $($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)
		// ---------------------------------------------------------------------
		dev_log!("lifecycle", "[Boot] [State] Building ApplicationState...");

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

		dev_log!(
			"lifecycle",
			"[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();
				let ServerPortForClosure = ServerPort;
				move |app:&mut App| {
					dev_log!("lifecycle", "[Lifecycle] [Setup] Setup hook started.");
					dev_log!("lifecycle", "[Lifecycle] [Setup] LocalhostUrl={}", LocalhostUrl);

					// ---------------------------------------------------------
					// [Service Registry] Initialize service registry for land:// routing
					// ---------------------------------------------------------
					dev_log!(
						"lifecycle",
						"[Lifecycle] [Setup] Initializing ServiceRegistry for land:// scheme..."
					);
					let service_registry = ServiceRegistryFn::new();
					init_service_registry(service_registry.clone());

					// ---------------------------------------------------------
					// [Service Registry] Register local HTTP services
					// ---------------------------------------------------------
					// Register the main code editor service
					dev_log!(
						"lifecycle",
						"[Lifecycle] [Setup] Registering code.editor.land service on port {}",
						ServerPortForClosure
					);
					register_land_service("code.editor.land", ServerPortForClosure);

					// Register API editor service (same port for now, can be separate later)
					register_land_service("api.editor.land", ServerPortForClosure);

					// Register assets editor service (same port for now, can be separate later)
					register_land_service("assets.editor.land", ServerPortForClosure);

					// Make the registry available as managed state for Tauri commands
					app.manage(service_registry);
					dev_log!(
						"lifecycle",
						"[Lifecycle] [Setup] ServiceRegistry initialized and services registered."
					);

					// ---------------------------------------------------------
					// [DNS Server] Start the Hickory DNS server
					// ---------------------------------------------------------
					// The DNS server must start BEFORE any webview loads to ensure
					// that land:// protocol_resolution is available
					dev_log!("lifecycle", "[Lifecycle] [Setup] Starting DNS server on preferred port 5380...");
					let dns_port = Mist::start(5380).unwrap_or_else(|e| {
						dev_log!(
							"lifecycle",
							"warn: [Lifecycle] [Setup] Failed to start DNS server on port 5380: {}",
							e
						);
						// Fallback to random port if preferred port fails
						Mist::start(0).unwrap_or_else(|e| {
							dev_log!(
								"lifecycle",
								"error: [Lifecycle] [Setup] Completely failed to start DNS server: {}",
								e
							);
							0 // Return 0 as error indicator
						})
					});

					if dns_port == 0 {
						dev_log!(
							"lifecycle",
							"warn: [Lifecycle] [Setup] DNS server failed to start, land:// protocol will not be \
							 available"
						);
					} else {
						dev_log!(
							"lifecycle",
							"[Lifecycle] [Setup] DNS server started successfully on port {}",
							dns_port
						);
						// Initialize DNS startup time for tracking
						crate::Binary::Build::DnsCommands::init_dns_startup_time();
					}

					// Register DnsPort as managed state for Tauri commands
					app.manage(DnsPort(dns_port));

					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,
					) {
						dev_log!("lifecycle", "error: [Lifecycle] [Setup] Failed to setup lifecycle: {}", e);
					}

					Ok(())
				}
			})
			.register_asynchronous_uri_scheme_protocol("land", |_ctx, request, responder| {
				// Implemented: delegate to synchronous scheme handler
				let response = crate::Binary::Build::Scheme::land_scheme_handler(&request);
				responder.respond(response);
			})
			.register_asynchronous_uri_scheme_protocol("vscode-file", |ctx, request, responder| {
				// VS Code Electron workbench uses vscode-file:// to load assets.
				// Maps to embedded frontend assets from Sky/Target.
				let AppHandle = ctx.app_handle().clone();
				std::thread::spawn(move || {
					let response = crate::Binary::Build::Scheme::VscodeFileSchemeHandler(&AppHandle, &request);
					responder.respond(response);
				});
			})
			.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,
				crate::Binary::Build::DnsCommands::dns_get_server_info,
				crate::Binary::Build::DnsCommands::dns_get_zone_info,
				crate::Binary::Build::DnsCommands::dns_get_forward_allowlist,
				crate::Binary::Build::DnsCommands::dns_get_health_status,
				crate::Binary::Build::DnsCommands::dns_resolve,
				crate::Binary::Build::DnsCommands::dns_test_resolution,
				crate::Binary::Build::DnsCommands::dns_health_check,
				// Process commands (direct Tauri invoke from ProcessPolyfill)
				crate::Binary::IPC::ProcessCommand::process_get_exec_path,
				crate::Binary::IPC::ProcessCommand::process_get_platform,
				crate::Binary::IPC::ProcessCommand::process_get_arch,
				crate::Binary::IPC::ProcessCommand::process_get_pid,
				crate::Binary::IPC::ProcessCommand::process_get_shell_env,
				crate::Binary::IPC::ProcessCommand::process_get_memory_info,
				// Health check commands (direct Tauri invoke from SharedProcessProxy)
				crate::Binary::IPC::HealthCommand::cocoon_extension_host_health,
				crate::Binary::IPC::HealthCommand::cocoon_search_service_health,
				crate::Binary::IPC::HealthCommand::cocoon_debug_service_health,
				crate::Binary::IPC::HealthCommand::shared_process_service_health,
			])
			.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 { .. } => {},
						_ => dev_log!("lifecycle", "[Lifecycle] [RunEvent] {:?}", event),
					}
				}

				if let RunEvent::ExitRequested { api, .. } = event {
					dev_log!(
						"lifecycle",
						"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 {
						dev_log!("lifecycle", "[Lifecycle] [Shutdown] Shutting down ApplicationRunTime...");
						let _ = RuntimeShutdownFn(&app_handle_clone).await;

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

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

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