Mountain/Environment/

WorkspaceProvider.rs

//! # WorkspaceProvider (Environment)
//!
//! RESPONSIBILITIES:
//! - Implements
//!   [`WorkspaceProvider`](CommonLibrary::Workspace::WorkspaceProvider) and
//!   [`WorkspaceEditApplier`](CommonLibrary::Workspace::WorkspaceEditApplier)
//!   traits for [`MountainEnvironment`]
//! - Manages multi-root workspace folder operations and configuration
//! - Provides workspace trust management and file discovery capabilities
//! - Handles workspace edit application and custom editor routing
//!
//! ARCHITECTURAL ROLE:
//! - Core provider in the Environment system, exposing workspace-level
//!   functionality to frontend via gRPC through the
//!   [`AirService`](crate::Air::AirServiceProvider)
//! - Workspace provider is one of the foundational services alongside Document,
//!   Configuration, and Diagnostic providers
//! - Integrates with
//!   [`ApplicationState`](crate::ApplicationState::ApplicationState) for
//!   persistent workspace folder storage
//!
//! ERROR HANDLING:
//! - Uses [`CommonError`](CommonLibrary::Error::CommonError) for all operations
//! - Application state lock errors are mapped using
//!   [`Utility::MapApplicationStateLockErrorToCommonError`]
//! - Some operations are stubbed with logging (FindFilesInWorkspace, OpenFile,
//!   ApplyWorkspaceEdit)
//!
//! PERFORMANCE:
//! - Workspace folder lookup uses O(n) linear search through folder list
//! - Lock contention on `ApplicationState.Workspace.WorkspaceFolders` should be
//!   minimized
//! - File discovery and workspace edit application are not yet optimized
//!
//! VS CODE REFERENCE:
//! - `vs/workbench/services/workspace/browser/workspaceService.ts` - workspace
//!   service implementation
//! - `vs/workbench/contrib/files/common/editors/textFileEditor.ts` - file
//!   editor integration
//! - `vs/platform/workspace/common/workspace.ts` - workspace types and
//!   interfaces
//!
//! TODO:
//! - Implement actual file search with glob pattern matching
//! - Implement file opening with workspace-relative paths
//! - Complete workspace edit application logic
//! - Add workspace event propagation to subscribers
//! - Implement custom editor routing by view type
//!
//! MODULE CONTENTS:
//! - [`WorkspaceProvider`](CommonLibrary::Workspace::WorkspaceProvider)
//!   implementation:
//! - `GetWorkspaceFoldersInfo` - enumerate all workspace folders
//! - `GetWorkspaceFolderInfo` - find folder containing a URI
//! - `GetWorkspaceName` - workspace identifier from state
//! - `GetWorkspaceConfigurationPath` - .code-workspace path
//! - `IsWorkspaceTrusted` - trust status check
//! - `RequestWorkspaceTrust` - trust acquisition (stub)
//! - `FindFilesInWorkspace` - file discovery (stub)
//! - `OpenFile` - file opening (stub)
//! - [`WorkspaceEditApplier`](CommonLibrary::Workspace::WorkspaceEditApplier)
//!   implementation:
//! - `ApplyWorkspaceEdit` - edit application (stub)
//! - Data types: [`(Url, String, usize)`] tuple for folder info (URI, name,
//!   index)

use std::{path::PathBuf, sync::Arc};

use CommonLibrary::{
	DTO::WorkspaceEditDTO::WorkspaceEditDTO,
	Error::CommonError::CommonError,
	Workspace::{WorkspaceEditApplier::WorkspaceEditApplier, WorkspaceProvider::WorkspaceProvider},
};
use async_trait::async_trait;
use log::{info, warn};
use serde_json::Value;
use url::Url;

use super::{MountainEnvironment::MountainEnvironment, Utility};

#[async_trait]
impl WorkspaceProvider for MountainEnvironment {
	/// Retrieves information about all currently open workspace folders.
	async fn GetWorkspaceFoldersInfo(&self) -> Result<Vec<(Url, String, usize)>, CommonError> {
		info!("[WorkspaceProvider] Getting workspace folders info.");
		let FoldersGuard = self
			.ApplicationState
			.Workspace
			.WorkspaceFolders
			.lock()
			.map_err(Utility::MapApplicationStateLockErrorToCommonError)?;
		Ok(FoldersGuard.iter().map(|f| (f.URI.clone(), f.Name.clone(), f.Index)).collect())
	}

	/// Retrieves information for the specific workspace folder that contains a
	/// given URI.
	async fn GetWorkspaceFolderInfo(&self, URIToMatch:Url) -> Result<Option<(Url, String, usize)>, CommonError> {
		let FoldersGuard = self
			.ApplicationState
			.Workspace
			.WorkspaceFolders
			.lock()
			.map_err(Utility::MapApplicationStateLockErrorToCommonError)?;
		for Folder in FoldersGuard.iter() {
			if URIToMatch.as_str().starts_with(Folder.URI.as_str()) {
				return Ok(Some((Folder.URI.clone(), Folder.Name.clone(), Folder.Index)));
			}
		}

		Ok(None)
	}

	/// Gets the name of the current workspace.
	async fn GetWorkspaceName(&self) -> Result<Option<String>, CommonError> {
		self.ApplicationState.GetWorkspaceIdentifier().map(Some)
	}

	/// Gets the path to the workspace configuration file (`.code-workspace`).
	async fn GetWorkspaceConfigurationPath(&self) -> Result<Option<PathBuf>, CommonError> {
		Ok(self
			.ApplicationState
			.Workspace
			.WorkspaceConfigurationPath
			.lock()
			.map_err(Utility::MapApplicationStateLockErrorToCommonError)?
			.clone())
	}

	/// Checks if the current workspace is trusted.
	async fn IsWorkspaceTrusted(&self) -> Result<bool, CommonError> {
		Ok(self
			.ApplicationState
			.Workspace
			.IsTrusted
			.load(std::sync::atomic::Ordering::Relaxed))
	}

	/// Requests workspace trust from the user.
	async fn RequestWorkspaceTrust(&self, _Options:Option<Value>) -> Result<bool, CommonError> {
		warn!("[WorkspaceProvider] RequestWorkspaceTrust is not implemented; defaulting to trusted.");
		Ok(true)
	}

	/// Finds files in the workspace matching the specified query.
	async fn FindFilesInWorkspace(
		&self,
		_query:Value,
		_:Option<Value>,
		_:Option<usize>,
		_:bool,
		_:bool,
	) -> Result<Vec<Url>, CommonError> {
		info!("[WorkspaceProvider] FindFilesInWorkspace called");
		// Scan all workspace folders to find files matching the query pattern. This
		// integrates with FileSystemReader to traverse directories, apply glob and
		// exclude patterns, and return matching file URIs. Respect query parameters
		// including maxResults, excludePatterns, and .gitignore rules. The result
		// set supports fuzzy search, symbol search, and quick file open features.
		// Currently returns an empty result set.
		Ok(Vec::new())
	}

	/// Opens a file in the workspace.
	async fn OpenFile(&self, path:PathBuf) -> Result<(), CommonError> {
		info!("[WorkspaceProvider] OpenFile called for: {:?}", path);
		// Open a file in the editor by delegating to the Workbench or command system.
		// Resolves the path relative to workspace roots, handles URI schemes (file://,
		// untitled:), and triggers the 'workbench.action.files.open' command or
		// equivalent. Creates a new document tab with the file contents, activating
		// the editor and adding the file to the recently opened list. Currently a
		// no-op.
		Ok(())
	}
}

#[async_trait]
impl WorkspaceEditApplier for MountainEnvironment {
	/// Applies a workspace edit to the workspace.
	async fn ApplyWorkspaceEdit(&self, Edit:WorkspaceEditDTO) -> Result<bool, CommonError> {
		info!("[WorkspaceEditApplier] Applying workspace edit");

		// For now, just log the edit details
		match Edit {
			WorkspaceEditDTO { Edits } => {
				for (DocumentURI, TextEdits) in Edits {
					info!(
						"[WorkspaceEditApplier] Would apply {} edits to document: {}",
						TextEdits.len(),
						DocumentURI
					);
				}
			},
		}

		// Apply a collection of document edits and file operations to the workspace.
		// Parses the WorkspaceEditDTO and performs text edits on documents, creates
		// and deletes files, and handles renames with proper validation. Key aspects:
		// validate document URIs and workspace trust, apply text edits with coordinate
		// conversion (line/column), handle all operations atomically with rollback on
		// failure, emit before/after events for extension observability, and return
		// false if any edit fails with detailed error information. This enables
		// multi-file refactorings, code actions, and automated fixes.
		warn!("[WorkspaceEditApplier] ApplyWorkspaceEdit is not fully implemented");

		Ok(true)
	}
}