IPCService.ts

/**
 * @module IPCService
 * @description
 * Advanced IPC service implementation following VS Code's IPC patterns.
 * Based on VS Code's IPCServer/IPCClient architecture with channels.
 *
 * Architecture Specification: VS Code IPC Pattern Implementation
 * Implementation: Channel-based RPC with cancellation support
 * Validation: Test with high-concurrency message handling (>1000 req/sec)
 */

import { Effect, Layer } from "effect";

import {
	IChannel,
	IIPCService,
	IMessagePassingProtocol,
	IServerChannel,
	VSBuffer,
} from "../Interfaces/IIPCService";

/**
 * VS Buffer implementation for binary-safe IPC
 * Specification: src/vs/base/common/buffer.ts (VSBuffer)
 * Implementation: Binary serialization wrapper
 */
class CocoonVSBuffer implements VSBuffer {
	constructor(private readonly _buffer: Uint8Array) {}

	get buffer(): Uint8Array {
		return this._buffer;
	}

	get byteLength(): number {
		return this._buffer.byteLength;
	}

	toString(): string {
		return new TextDecoder().decode(this._buffer);
	}

	slice(start?: number, end?: number): VSBuffer {
		return new CocoonVSBuffer(this._buffer.slice(start, end));
	}

	static fromString(data: string): VSBuffer {
		return new CocoonVSBuffer(new TextEncoder().encode(data));
	}

	static wrap(buffer: Uint8Array): VSBuffer {
		return new CocoonVSBuffer(buffer);
	}
}

/**
 * Message passing protocol implementation
 * Specification: src/vs/base/parts/ipc/common/ipc.ts (IMessagePassingProtocol)
 * Implementation: Binary-safe message serialization
 */
class CocoonMessagePassingProtocol implements IMessagePassingProtocol {
	private readonly _onMessage = new Emitter<VSBuffer>();
	readonly onMessage = this._onMessage.event;

	constructor(private _sendCallback?: (buffer: VSBuffer) => void) {}

	send(buffer: VSBuffer): void {
		if (this._sendCallback) {
			this._sendCallback(buffer);
		}
	}

	// Internal method for simulating message reception
	simulateMessage(buffer: VSBuffer): void {
		this._onMessage.fire(buffer);
	}
}

/**
 * Advanced IPC service implementation
 * Specification: src/vs/base/parts/ipc/common/ipc.ts (IPCServer/IPCClient)
 * Implementation: Multi-channel RPC system with cancellation
 */
export class IPCService implements IIPCService {
	readonly _serviceBrand: undefined;

	private _protocol: IMessagePassingProtocol | null = null;
	private _channels = new Map<string, IServerChannel<any>>();
	private _isConnected = false;
	private _connectionStartTime = 0;
	private _messageCount = 0;
	private _errorCount = 0;
	private _lastPing = 0;
	private _latencySamples: number[] = [];

	// Channel client for making requests
	private _channelClient: IChannel | null = null;

	constructor() {
		this._serviceBrand = undefined;
		console.log("[IPCService] Initializing advanced IPC service");
	}

	/**
	 * Initialize IPC service with protocol
	 */
	async initialize(protocol: IMessagePassingProtocol): Promise<void> {
		console.log("[IPCService] Initializing with protocol");

		this._protocol = protocol;

		// Setup message handler
		protocol.onMessage((buffer) => {
			this._handleMessage(buffer);
		});

		// Establish connection
		await this._establishConnection();

		this._isConnected = true;
		this._connectionStartTime = Date.now();
		this._lastPing = Date.now();

		console.log("[IPCService] Advanced IPC service initialized");
	}

	/**
	 * Establish connection with Mountain
	 */
	private async _establishConnection(): Promise<void> {
		console.log("[IPCService] Establishing connection with Mountain");

		// Send handshake
		const handshakeBuffer = CocoonVSBuffer.fromString(
			JSON.stringify({
				type: "handshake",
				timestamp: Date.now(),
				version: "1.0.0",
			}),
		);

		this._protocol!.send(handshakeBuffer);

		// Wait for handshake response
		const response = await new Promise<VSBuffer>((resolve, reject) => {
			const timeout = setTimeout(() => {
				reject(new Error("Handshake timeout"));
			}, 5000);

			const handler = this._protocol!.onMessage((buffer) => {
				try {
					const data = JSON.parse(buffer.toString());
					if (data.type === "handshake-response") {
						clearTimeout(timeout);
						resolve(buffer);
					}
				} catch (error) {
					// Continue waiting
				}
			});
		});

		console.log("[IPCService] Connection established with Mountain");
	}

	/**
	 * Get channel for specific service
	 */
	getChannel<T extends IChannel>(channelName: string): T {
		// TODO: Implement proper channel routing
		// Specification: src/vs/base/parts/ipc/common/ipc.ts (getChannel)
		// Implementation: Channel factory with routing logic

		return {
			call: async <T>(
				command: string,
				arg?: any,
				cancellationToken?: CancellationToken,
			): Promise<T> => {
				if (!this._isConnected) {
					throw new Error("Not connected to Mountain");
				}

				const startTime = Date.now();

				try {
					const message = {
						type: "call",
						channel: channelName,
						command,
						arg,
						timestamp: startTime,
						messageId: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
					};

					const buffer = CocoonVSBuffer.fromString(
						JSON.stringify(message),
					);
					this._protocol!.send(buffer);

					this._messageCount++;

					// Wait for response
					const response = await this._waitForResponse(
						message.messageId,
						cancellationToken,
					);

					const latency = Date.now() - startTime;
					this._latencySamples.push(latency);

					return response as T;
				} catch (error) {
					this._errorCount++;
					throw error;
				}
			},

			listen: <T>(event: string, arg?: any): Event<T> => {
				// TODO: Implement event listening
				// Specification: src/vs/base/parts/ipc/common/ipc.ts (listen)
				// Implementation: Event emitter with filtering

				const emitter = new Emitter<T>();

				// Simulate event listening for now
				return emitter.event;
			},
		} as T;
	}

	/**
	 * Register server channel for handling requests
	 */
	registerChannel(channelName: string, channel: IServerChannel<any>): void {
		console.log(`[IPCService] Registering channel: ${channelName}`);
		this._channels.set(channelName, channel);
	}

	/**
	 * Wait for response with cancellation support
	 */
	private async _waitForResponse(
		messageId: string,
		cancellationToken?: CancellationToken,
	): Promise<any> {
		return new Promise((resolve, reject) => {
			if (cancellationToken?.isCancellationRequested) {
				reject(new Error("Request cancelled"));
				return;
			}

			const timeout = setTimeout(() => {
				reject(new Error("Response timeout"));
			}, 30000);

			const handler = this._protocol!.onMessage((buffer) => {
				try {
					const data = JSON.parse(buffer.toString());
					if (data.messageId === messageId) {
						clearTimeout(timeout);

						if (data.success) {
							resolve(data.result);
						} else {
							reject(new Error(data.error || "Request failed"));
						}
					}
				} catch (error) {
					// Continue waiting
				}
			});

			if (cancellationToken) {
				cancellationToken.onCancellationRequested(() => {
					clearTimeout(timeout);
					reject(new Error("Request cancelled"));
				});
			}
		});
	}

	/**
	 * Handle incoming messages
	 */
	private _handleMessage(buffer: VSBuffer): void {
		try {
			const data = JSON.parse(buffer.toString());

			if (data.type === "handshake-response") {
				console.log("[IPCService] Received handshake response");
				return;
			}

			if (data.type === "call" && data.channel) {
				this._handleCall(data);
				return;
			}

			console.log("[IPCService] Unhandled message type:", data.type);
		} catch (error) {
			console.error("[IPCService] Failed to handle message:", error);
		}
	}

	/**
	 * Handle incoming call requests
	 */
	private async _handleCall(data: any): Promise<void> {
		const channel = this._channels.get(data.channel);
		if (!channel) {
			console.error(`[IPCService] Channel not found: ${data.channel}`);
			return;
		}

		try {
			const result = await channel.call(data.command, data.arg);

			const response = {
				type: "response",
				messageId: data.messageId,
				success: true,
				result,
				timestamp: Date.now(),
			};

			const buffer = CocoonVSBuffer.fromString(JSON.stringify(response));
			this._protocol!.send(buffer);
		} catch (error) {
			const response = {
				type: "response",
				messageId: data.messageId,
				success: false,
				error: error.message,
				timestamp: Date.now(),
			};

			const buffer = CocoonVSBuffer.fromString(JSON.stringify(response));
			this._protocol!.send(buffer);
		}
	}

	/**
	 * Get connection status
	 */
	getConnectionStatus(): any {
		const now = Date.now();
		const connectionUptime = this._isConnected
			? now - this._connectionStartTime
			: 0;

		// Calculate average latency
		const averageLatency =
			this._latencySamples.length > 0
				? this._latencySamples.reduce((a, b) => a + b, 0) /
					this._latencySamples.length
				: undefined;

		return {
			connected: this._isConnected,
			lastPing: this._lastPing,
			errorCount: this._errorCount,
			connectionUptime,
			messageCount: this._messageCount,
			averageLatency,
		};
	}

	/**
	 * Reconnect to Mountain
	 */
	async reconnect(): Promise<void> {
		console.log("[IPCService] Reconnecting to Mountain");

		await this.dispose();

		if (this._protocol) {
			await this.initialize(this._protocol);
		}

		console.log("[IPCService] Reconnected to Mountain");
	}

	/**
	 * Cleanup IPC service
	 */
	dispose(): void {
		console.log("[IPCService] Disposing IPC service");

		this._isConnected = false;
		this._channels.clear();
		this._protocol = null;
		this._channelClient = null;

		console.log("[IPCService] IPC service disposed");
	}
}

/**
 * Service layer for IPCService
 */
export const IPCServiceLayer = Layer.effect(
	IIPCService,
	Effect.sync(() => new IPCService()),
);

/**
 * Live implementation
 */
export { CocoonMessagePassingProtocol };

export const IPCServiceLive = Layer.effect(
	IIPCService,
	Effect.sync(() => new IPCService()),
);