Mountain/Environment/

CustomEditorProvider.rs

//! # CustomEditorProvider (Environment)
//!
//! RESPONSIBILITIES:
//! - Implements
//!   [`CustomEditorProvider`](CommonLibrary::CustomEditor::CustomEditorProvider)
//!   for [`MountainEnvironment`]
//! - Manages registration and lifecycle of custom non-text editors
//! - Coordinates Webview-based editing experiences (SVG editors, diff viewers,
//!   etc.)
//! - Handles editor resolution, save operations, and provider unregistration
//!
//! ARCHITECTURAL ROLE:
//! - Environment provider that enables extension-contributed custom editors
//! - Uses [`IPCProvider`](CommonLibrary::IPC::IPCProvider) for RPC
//!   communication with Cocoon
//! - Integrates with `ApplicationState` for provider registration persistence
//!
//! ERROR HANDLING:
//! - Uses [`CommonError`](CommonLibrary::Error::CommonError) for all operations
//! - ViewType validation: rejects empty view types with InvalidArgument error
//! - Some operations are stubbed with logging/warning (OnSaveCustomDocument)
//!
//! PERFORMANCE:
//! - Provider registration lookup should be O(1) via hash map in
//!   ApplicationState (TODO)
//! - ResolveCustomEditor uses fire-and-forget RPC pattern to avoid waiting
//!
//! VS CODE REFERENCE:
//! - `vs/workbench/contrib/customEditor/browser/customEditorService.ts` -
//!   custom editor service
//! - `vs/workbench/contrib/customEditor/common/customEditor.ts` - custom editor
//!   interfaces
//! - `vs/platform/workspace/common/workspace.ts` - resource URI handling
//!
//! TODO:
//! - Store provider registrations in ApplicationState with capability metadata
//! - Implement custom editor backup/restore mechanism
//! - Add support for multiple active instances of the same viewType
//! - Implement custom editor move and rename handling
//! - Add proper validation of viewType and resource URI
//! - Implement editor-specific command registration
//! - Add support for custom editor dispose/cleanup
//! - Consider adding editor state persistence across reloads
//! - Implement proper error recovery for Webview crashes
//! - Add telemetry for custom editor usage metrics
//!
//! MODULE CONTENTS:
//! - [`CustomEditorProvider`](CommonLibrary::CustomEditor::CustomEditorProvider) implementation:
//! - `RegisterCustomEditorProvider` - register extension provider
//! - `UnregisterCustomEditorProvider` - unregister provider
//! - `OnSaveCustomDocument` - save handler (stub)
//! - `ResolveCustomEditor` - resolve editor content via RPC

use std::sync::Arc;

use CommonLibrary::{
	CustomEditor::CustomEditorProvider::CustomEditorProvider,
	Environment::Requires::Requires,
	Error::CommonError::CommonError,
	IPC::{DTO::ProxyTarget::ProxyTarget, IPCProvider::IPCProvider},
};
use async_trait::async_trait;
use serde_json::{Value, json};
use url::Url;

use super::MountainEnvironment::MountainEnvironment;
use crate::dev_log;

#[async_trait]
impl CustomEditorProvider for MountainEnvironment {
	async fn RegisterCustomEditorProvider(&self, ViewType:String, _Options:Value) -> Result<(), CommonError> {
		dev_log!(
			"extensions",
			"[CustomEditorProvider] Registering provider for view type: {}",
			ViewType
		);

		// Validate ViewType is non-empty
		if ViewType.is_empty() {
			return Err(CommonError::InvalidArgument {
				ArgumentName:"ViewType".to_string(),
				Reason:"ViewType cannot be empty".to_string(),
			});
		}

		// Register custom editor provider in ApplicationState for lifecycle management
		// and resolution. Should associate ViewType with the sidecar identifier for
		// RPC routing, store provider capabilities (supportsMultipleEditors,
		// serialization support), store custom options (mime types, file extensions),
		// validate that the ViewType is not already registered to prevent conflicts,
		// and track registration timestamp and extension origin for debugging.

		Ok(())
	}

	async fn UnregisterCustomEditorProvider(&self, ViewType:String) -> Result<(), CommonError> {
		dev_log!(
			"extensions",
			"[CustomEditorProvider] Unregistering provider for view type: {}",
			ViewType
		);

		// Remove custom editor provider registration from ApplicationState. Should
		// check if any active editors are currently using this ViewType and either
		// force close with unsaved changes warning or prevent unregistration, remove
		// all stored configuration, capabilities, and sidecar association, notify the
		// sidecar extension to clean up its internal state, and remove any cached
		// resolution entries for this ViewType.

		Ok(())
	}

	async fn OnSaveCustomDocument(&self, ViewType:String, ResourceURI:Url) -> Result<(), CommonError> {
		dev_log!(
			"extensions",
			"[CustomEditorProvider] OnSaveCustomDocument called for '{}' at '{}'",
			ViewType,
			ResourceURI
		);

		// Implement the complete custom document save workflow. Send RPC request
		// ($customDocument/save) to the extension sidecar responsible for this
		// ViewType, including the ResourceURI. The extension retrieves edited content
		// from its Webview via postMessage and returns the updated data (string or
		// bytes). Mountain receives the content and writes it to the file system using
		// FileSystemWriter with appropriate encoding and atomic write pattern. Emit
		// a document saved notification to refresh UI and trigger post-save hooks
		// (formatters, linters, extension notifications). This enables custom editors
		// to participate in the standard save lifecycle.

		dev_log!(
			"extensions",
			"warn: [CustomEditorProvider] OnSaveCustomDocument is not fully implemented."
		);
		Ok(())
	}

	async fn ResolveCustomEditor(
		&self,
		ViewType:String,
		ResourceURI:Url,
		WebviewPanelHandle:String,
	) -> Result<(), CommonError> {
		dev_log!(
			"extensions",
			"[CustomEditorProvider] Resolving custom editor for '{}' on resource '{}'",
			ViewType,
			ResourceURI
		);

		// This is the core logic:
		// 1. Find the sidecar that registered this ViewType. For now, assume
		//    "cocoon-main".
		// 2. Make an RPC call to that sidecar's implementation of
		//    `$resolveCustomEditor`.
		// 3. The sidecar will then call back to the host with `setHtml`, `postMessage`,
		//    etc. to populate the webview associated with the `WebviewPanelHandle`.

		let IPCProvider:Arc<dyn IPCProvider> = self.Require();
		let ResourceURIComponents = json!({ "external": ResourceURI.to_string() });
		let RPCMethod = format!("{}$resolveCustomEditor", ProxyTarget::ExtHostCustomEditors.GetTargetPrefix());
		let RPCParameters = json!([ResourceURIComponents, ViewType, WebviewPanelHandle]);

		// This is a fire-and-forget notification. The sidecar is expected to
		// call back to the host to populate the webview.
		IPCProvider
			.SendNotificationToSideCar("cocoon-main".to_string(), RPCMethod, RPCParameters)
			.await
	}
}