import { AugmentationType } from '../types/augmentations.js';
import { v4 as uuidv4 } from '../universal/uuid.js';
/**
 * Base class for conduit augmentations that provide data synchronization between Brainy instances
 */
class BaseConduitAugmentation {
    constructor(name) {
        this.description = 'Base conduit augmentation';
        this.enabled = true;
        this.isInitialized = false;
        this.connections = new Map();
        this.name = name;
    }
    async initialize() {
        if (this.isInitialized) {
            return;
        }
        try {
            this.isInitialized = true;
        }
        catch (error) {
            console.error(`Failed to initialize ${this.name}:`, error);
            throw new Error(`Failed to initialize ${this.name}: ${error}`);
        }
    }
    async shutDown() {
        // Close all connections
        for (const [connectionId, connection] of this.connections.entries()) {
            try {
                if (connection.close) {
                    await connection.close();
                }
            }
            catch (error) {
                console.error(`Failed to close connection ${connectionId}:`, error);
            }
        }
        this.connections.clear();
        this.isInitialized = false;
    }
    async getStatus() {
        return this.isInitialized ? 'active' : 'inactive';
    }
    async ensureInitialized() {
        if (!this.isInitialized) {
            await this.initialize();
        }
    }
}
/**
 * WebSocket conduit augmentation for syncing Brainy instances using WebSockets
 *
 * This conduit is for syncing between browsers and servers, or between servers.
 * WebSockets cannot be used for direct browser-to-browser communication without a server in the middle.
 */
export class WebSocketConduitAugmentation extends BaseConduitAugmentation {
    constructor(name = 'websocket-conduit') {
        super(name);
        this.description = 'Conduit augmentation that syncs Brainy instances using WebSockets';
        this.webSocketConnections = new Map();
        this.messageCallbacks = new Map();
    }
    getType() {
        return AugmentationType.CONDUIT;
    }
    /**
     * Establishes a connection to another Brainy instance
     * @param targetSystemId The URL or identifier of the target system
     * @param config Configuration options for the connection
     */
    async establishConnection(targetSystemId, config) {
        await this.ensureInitialized();
        try {
            // For WebSocket connections, targetSystemId should be a WebSocket URL
            const url = targetSystemId;
            const protocols = config.protocols;
            // Create a WebSocket connection
            const connection = await this.connectWebSocket(url, protocols);
            // Store the connection
            this.connections.set(connection.connectionId, connection);
            return {
                success: true,
                data: connection
            };
        }
        catch (error) {
            console.error(`Failed to establish connection to ${targetSystemId}:`, error);
            return {
                success: false,
                data: null,
                error: `Failed to establish connection: ${error}`
            };
        }
    }
    /**
     * Reads data from a connected Brainy instance
     * @param query Query parameters for reading data
     * @param options Additional options
     */
    async readData(query, options) {
        await this.ensureInitialized();
        try {
            const connectionId = query.connectionId;
            if (!connectionId) {
                throw new Error('connectionId is required for reading data');
            }
            const connection = this.webSocketConnections.get(connectionId);
            if (!connection) {
                throw new Error(`Connection ${connectionId} not found`);
            }
            // Create a request message
            const requestMessage = {
                type: 'read',
                query: query.query || {},
                requestId: uuidv4(),
                options
            };
            // Send the request
            await this.sendWebSocketMessage(connectionId, requestMessage);
            // Return a promise that will be resolved when the response is received
            return new Promise((resolve) => {
                const responseHandler = (data) => {
                    // Check if this is the response to our request
                    const response = data;
                    if (response && response.type === 'readResponse' && response.requestId === requestMessage.requestId) {
                        // Remove the handler
                        this.offWebSocketMessage(connectionId, responseHandler);
                        // Resolve with the response data
                        resolve({
                            success: response.success,
                            data: response.data,
                            error: response.error
                        });
                    }
                };
                // Register the response handler
                this.onWebSocketMessage(connectionId, responseHandler);
                // Set a timeout to prevent hanging
                setTimeout(() => {
                    this.offWebSocketMessage(connectionId, responseHandler);
                    resolve({
                        success: false,
                        data: null,
                        error: 'Timeout waiting for read response'
                    });
                }, 30000); // 30 second timeout
            });
        }
        catch (error) {
            console.error(`Failed to read data:`, error);
            return {
                success: false,
                data: null,
                error: `Failed to read data: ${error}`
            };
        }
    }
    /**
     * Writes data to a connected Brainy instance
     * @param data The data to write
     * @param options Additional options
     */
    async writeData(data, options) {
        await this.ensureInitialized();
        try {
            const connectionId = data.connectionId;
            if (!connectionId) {
                throw new Error('connectionId is required for writing data');
            }
            const connection = this.webSocketConnections.get(connectionId);
            if (!connection) {
                throw new Error(`Connection ${connectionId} not found`);
            }
            // Create a write message
            const writeMessage = {
                type: 'write',
                data: data.data || {},
                requestId: uuidv4(),
                options
            };
            // Send the write message
            await this.sendWebSocketMessage(connectionId, writeMessage);
            // Return a promise that will be resolved when the response is received
            return new Promise((resolve) => {
                const responseHandler = (data) => {
                    // Check if this is the response to our request
                    const response = data;
                    if (response && response.type === 'writeResponse' && response.requestId === writeMessage.requestId) {
                        // Remove the handler
                        this.offWebSocketMessage(connectionId, responseHandler);
                        // Resolve with the response data
                        resolve({
                            success: response.success,
                            data: response.data,
                            error: response.error
                        });
                    }
                };
                // Register the response handler
                this.onWebSocketMessage(connectionId, responseHandler);
                // Set a timeout to prevent hanging
                setTimeout(() => {
                    this.offWebSocketMessage(connectionId, responseHandler);
                    resolve({
                        success: false,
                        data: null,
                        error: 'Timeout waiting for write response'
                    });
                }, 30000); // 30 second timeout
            });
        }
        catch (error) {
            console.error(`Failed to write data:`, error);
            return {
                success: false,
                data: null,
                error: `Failed to write data: ${error}`
            };
        }
    }
    /**
     * Monitors a data stream from a connected Brainy instance
     * @param streamId The ID of the stream to monitor (usually a connection ID)
     * @param callback Function to call when new data is received
     */
    async monitorStream(streamId, callback) {
        await this.ensureInitialized();
        try {
            const connection = this.webSocketConnections.get(streamId);
            if (!connection) {
                throw new Error(`Connection ${streamId} not found`);
            }
            // Register the callback for all messages on this connection
            await this.onWebSocketMessage(streamId, callback);
        }
        catch (error) {
            console.error(`Failed to monitor stream ${streamId}:`, error);
            throw new Error(`Failed to monitor stream: ${error}`);
        }
    }
    /**
     * Establishes a WebSocket connection
     * @param url The WebSocket server URL to connect to
     * @param protocols Optional subprotocols
     */
    async connectWebSocket(url, protocols) {
        await this.ensureInitialized();
        return new Promise((resolve, reject) => {
            try {
                // Check if WebSocket is available
                if (typeof WebSocket === 'undefined') {
                    throw new Error('WebSocket is not available in this environment');
                }
                // Create a new WebSocket connection
                const ws = new WebSocket(url, protocols);
                const connectionId = uuidv4();
                // Create a connection object
                const connection = {
                    connectionId,
                    url,
                    status: 'disconnected',
                    send: async (data) => {
                        if (ws.readyState !== WebSocket.OPEN) {
                            throw new Error('WebSocket is not open');
                        }
                        ws.send(data);
                    },
                    close: async () => {
                        ws.close();
                    }
                };
                // Set up event handlers
                ws.onopen = () => {
                    connection.status = 'connected';
                    resolve(connection);
                };
                ws.onerror = (error) => {
                    connection.status = 'error';
                    console.error(`WebSocket error for ${url}:`, error);
                    if (ws.readyState !== WebSocket.OPEN) {
                        reject(new Error(`WebSocket connection failed: ${error}`));
                    }
                };
                ws.onclose = () => {
                    connection.status = 'disconnected';
                    // Remove from connections map
                    this.webSocketConnections.delete(connectionId);
                    // Remove all callbacks
                    this.messageCallbacks.delete(connectionId);
                };
                // Create a message handler wrapper that will call all registered callbacks
                const messageHandlerWrapper = (data) => {
                    const callbacks = this.messageCallbacks.get(connectionId);
                    if (callbacks) {
                        for (const callback of callbacks) {
                            try {
                                callback(data);
                            }
                            catch (error) {
                                console.error(`Error in WebSocket message callback:`, error);
                            }
                        }
                    }
                };
                // Store the message handler wrapper
                connection._messageHandlerWrapper = messageHandlerWrapper;
                // Set up the message handler
                ws.onmessage = (event) => {
                    try {
                        // Parse the message if it's a string
                        let data = event.data;
                        if (typeof data === 'string') {
                            try {
                                data = JSON.parse(data);
                            }
                            catch {
                                // If parsing fails, use the raw string
                            }
                        }
                        // Call the message handler wrapper
                        messageHandlerWrapper(data);
                    }
                    catch (error) {
                        console.error(`Error handling WebSocket message:`, error);
                    }
                };
                // Store the stream message handler
                connection._streamMessageHandler = (event) => ws.onmessage && ws.onmessage(event);
                // Store the connection
                this.webSocketConnections.set(connectionId, connection);
                // Initialize the callbacks set
                this.messageCallbacks.set(connectionId, new Set());
            }
            catch (error) {
                reject(error);
            }
        });
    }
    /**
     * Sends data through an established WebSocket connection
     * @param connectionId The identifier of the established connection
     * @param data The data to send (will be serialized if not a string)
     */
    async sendWebSocketMessage(connectionId, data) {
        await this.ensureInitialized();
        const connection = this.webSocketConnections.get(connectionId);
        if (!connection) {
            throw new Error(`WebSocket connection ${connectionId} not found`);
        }
        if (!connection.send) {
            throw new Error(`WebSocket connection ${connectionId} does not support sending messages`);
        }
        // Serialize the data if it's not already a string or binary
        let serializedData;
        if (typeof data === 'string' ||
            data instanceof ArrayBuffer ||
            data instanceof Blob ||
            ArrayBuffer.isView(data)) {
            serializedData = data;
        }
        else {
            // Convert to JSON string
            serializedData = JSON.stringify(data);
        }
        // Send the data
        await connection.send(serializedData);
    }
    /**
     * Registers a callback for incoming WebSocket messages
     * @param connectionId The identifier of the established connection
     * @param callback The function to call when a message is received
     */
    async onWebSocketMessage(connectionId, callback) {
        await this.ensureInitialized();
        const connection = this.webSocketConnections.get(connectionId);
        if (!connection) {
            throw new Error(`WebSocket connection ${connectionId} not found`);
        }
        // Get or create the callbacks set for this connection
        let callbacks = this.messageCallbacks.get(connectionId);
        if (!callbacks) {
            callbacks = new Set();
            this.messageCallbacks.set(connectionId, callbacks);
        }
        // Add the callback
        callbacks.add(callback);
    }
    /**
     * Removes a callback for incoming WebSocket messages
     * @param connectionId The identifier of the established connection
     * @param callback The function to remove from the callbacks
     */
    async offWebSocketMessage(connectionId, callback) {
        await this.ensureInitialized();
        const callbacks = this.messageCallbacks.get(connectionId);
        if (callbacks) {
            callbacks.delete(callback);
        }
    }
    /**
     * Closes an established WebSocket connection
     * @param connectionId The identifier of the established connection
     * @param code Optional close code
     * @param reason Optional close reason
     */
    async closeWebSocket(connectionId, code, reason) {
        await this.ensureInitialized();
        const connection = this.webSocketConnections.get(connectionId);
        if (!connection) {
            throw new Error(`WebSocket connection ${connectionId} not found`);
        }
        if (!connection.close) {
            throw new Error(`WebSocket connection ${connectionId} does not support closing`);
        }
        // Close the connection
        await connection.close();
        // Remove from connections map
        this.webSocketConnections.delete(connectionId);
        // Remove all callbacks
        this.messageCallbacks.delete(connectionId);
    }
}
/**
 * WebRTC conduit augmentation for syncing Brainy instances using WebRTC
 *
 * This conduit is for direct peer-to-peer syncing between browsers.
 * It is the recommended approach for browser-to-browser communication.
 */
export class WebRTCConduitAugmentation extends BaseConduitAugmentation {
    constructor(name = 'webrtc-conduit') {
        super(name);
        this.description = 'Conduit augmentation that syncs Brainy instances using WebRTC';
        this.peerConnections = new Map();
        this.dataChannels = new Map();
        this.webSocketConnections = new Map();
        this.messageCallbacks = new Map();
        this.signalServer = null;
    }
    getType() {
        return AugmentationType.CONDUIT;
    }
    async initialize() {
        if (this.isInitialized) {
            return;
        }
        try {
            // Check if WebRTC is available
            if (typeof RTCPeerConnection === 'undefined') {
                throw new Error('WebRTC is not available in this environment');
            }
            this.isInitialized = true;
        }
        catch (error) {
            console.error(`Failed to initialize ${this.name}:`, error);
            throw new Error(`Failed to initialize ${this.name}: ${error}`);
        }
    }
    /**
     * Establishes a connection to another Brainy instance using WebRTC
     * @param targetSystemId The peer ID or signal server URL
     * @param config Configuration options for the connection
     */
    async establishConnection(targetSystemId, config) {
        await this.ensureInitialized();
        try {
            // For WebRTC, we need to:
            // 1. Connect to a signaling server (if not already connected)
            // 2. Create a peer connection
            // 3. Create a data channel
            // 4. Exchange ICE candidates and SDP offers/answers
            // Check if we need to connect to a signaling server
            if (!this.signalServer && config.signalServerUrl) {
                // Connect to the signaling server
                this.signalServer = await this.connectWebSocket(config.signalServerUrl);
                // Set up message handling for the signaling server
                await this.onWebSocketMessage(this.signalServer.connectionId, async (data) => {
                    // Handle signaling messages
                    const message = data;
                    if (message.type === 'ice-candidate' && message.targetPeerId === config.localPeerId) {
                        // Add ICE candidate to the appropriate peer connection
                        const peerConnection = this.peerConnections.get(message.sourcePeerId);
                        if (peerConnection) {
                            try {
                                await peerConnection.addIceCandidate(new RTCIceCandidate(message.candidate));
                            }
                            catch (error) {
                                console.error(`Failed to add ICE candidate:`, error);
                            }
                        }
                    }
                    else if (message.type === 'offer' && message.targetPeerId === config.localPeerId) {
                        // Handle incoming offer
                        await this.handleOffer(message.sourcePeerId, message.offer, config);
                    }
                    else if (message.type === 'answer' && message.targetPeerId === config.localPeerId) {
                        // Handle incoming answer
                        const peerConnection = this.peerConnections.get(message.sourcePeerId);
                        if (peerConnection) {
                            try {
                                await peerConnection.setRemoteDescription(new RTCSessionDescription(message.answer));
                            }
                            catch (error) {
                                console.error(`Failed to set remote description:`, error);
                            }
                        }
                    }
                });
            }
            // Create a peer connection
            const peerConnection = new RTCPeerConnection({
                iceServers: config.iceServers || [
                    { urls: 'stun:stun.l.google.com:19302' }
                ]
            });
            // Generate a connection ID
            const connectionId = uuidv4();
            // Store the peer connection
            this.peerConnections.set(targetSystemId, peerConnection);
            // Create a data channel
            const dataChannel = peerConnection.createDataChannel('brainy-sync', {
                ordered: true
            });
            // Set up data channel event handlers
            dataChannel.onopen = () => {
                console.log(`Data channel to ${targetSystemId} opened`);
            };
            dataChannel.onclose = () => {
                console.log(`Data channel to ${targetSystemId} closed`);
                // Clean up
                this.dataChannels.delete(targetSystemId);
                this.peerConnections.delete(targetSystemId);
                this.webSocketConnections.delete(connectionId);
                this.messageCallbacks.delete(connectionId);
            };
            dataChannel.onerror = (error) => {
                console.error(`Data channel error:`, error);
            };
            // Create a message handler wrapper that will call all registered callbacks
            const messageHandlerWrapper = (data) => {
                const callbacks = this.messageCallbacks.get(connectionId);
                if (callbacks) {
                    for (const callback of callbacks) {
                        try {
                            callback(data);
                        }
                        catch (error) {
                            console.error(`Error in WebRTC message callback:`, error);
                        }
                    }
                }
            };
            dataChannel.onmessage = (event) => {
                try {
                    // Parse the message if it's a string
                    let data = event.data;
                    if (typeof data === 'string') {
                        try {
                            data = JSON.parse(data);
                        }
                        catch {
                            // If parsing fails, use the raw string
                        }
                    }
                    // Call the message handler wrapper
                    messageHandlerWrapper(data);
                }
                catch (error) {
                    console.error(`Error handling WebRTC message:`, error);
                }
            };
            // Store the data channel
            this.dataChannels.set(targetSystemId, dataChannel);
            // Set up ICE candidate handling
            peerConnection.onicecandidate = (event) => {
                if (event.candidate && this.signalServer) {
                    // Send the ICE candidate to the peer via the signaling server
                    this.sendWebSocketMessage(this.signalServer.connectionId, {
                        type: 'ice-candidate',
                        sourcePeerId: config.localPeerId,
                        targetPeerId: targetSystemId,
                        candidate: event.candidate
                    });
                }
            };
            // Create a WebSocket-like connection object for the WebRTC connection
            const connection = {
                connectionId,
                url: `webrtc://${targetSystemId}`,
                status: 'disconnected',
                send: async (data) => {
                    const dc = this.dataChannels.get(targetSystemId);
                    if (!dc || dc.readyState !== 'open') {
                        throw new Error('WebRTC data channel is not open');
                    }
                    // Send the data
                    if (typeof data === 'string') {
                        dc.send(data);
                    }
                    else if (data instanceof Blob) {
                        dc.send(data);
                    }
                    else if (data instanceof ArrayBuffer) {
                        dc.send(new Uint8Array(data));
                    }
                    else if (ArrayBuffer.isView(data)) {
                        dc.send(data);
                    }
                    else {
                        // Convert to JSON string
                        dc.send(JSON.stringify(data));
                    }
                },
                close: async () => {
                    const dc = this.dataChannels.get(targetSystemId);
                    if (dc) {
                        dc.close();
                    }
                    const pc = this.peerConnections.get(targetSystemId);
                    if (pc) {
                        pc.close();
                    }
                    // Clean up
                    this.dataChannels.delete(targetSystemId);
                    this.peerConnections.delete(targetSystemId);
                    this.webSocketConnections.delete(connectionId);
                    this.messageCallbacks.delete(connectionId);
                },
                _messageHandlerWrapper: messageHandlerWrapper
            };
            // Store the connection
            this.webSocketConnections.set(connectionId, connection);
            // Initialize the callbacks set
            this.messageCallbacks.set(connectionId, new Set());
            // Create and send an offer
            const offer = await peerConnection.createOffer();
            await peerConnection.setLocalDescription(offer);
            // Send the offer to the peer via the signaling server
            if (this.signalServer) {
                await this.sendWebSocketMessage(this.signalServer.connectionId, {
                    type: 'offer',
                    sourcePeerId: config.localPeerId,
                    targetPeerId: targetSystemId,
                    offer
                });
            }
            // Return the connection
            return {
                success: true,
                data: connection
            };
        }
        catch (error) {
            console.error(`Failed to establish WebRTC connection to ${targetSystemId}:`, error);
            return {
                success: false,
                data: null,
                error: `Failed to establish WebRTC connection: ${error}`
            };
        }
    }
    /**
     * Handles an incoming WebRTC offer
     * @param peerId The ID of the peer sending the offer
     * @param offer The SDP offer
     * @param config Configuration options
     */
    async handleOffer(peerId, offer, config) {
        try {
            // Create a peer connection if it doesn't exist
            let peerConnection = this.peerConnections.get(peerId);
            if (!peerConnection) {
                peerConnection = new RTCPeerConnection({
                    iceServers: config.iceServers || [
                        { urls: 'stun:stun.l.google.com:19302' }
                    ]
                });
                // Store the peer connection
                this.peerConnections.set(peerId, peerConnection);
                // Set up ICE candidate handling
                peerConnection.onicecandidate = (event) => {
                    if (event.candidate && this.signalServer) {
                        // Send the ICE candidate to the peer via the signaling server
                        this.sendWebSocketMessage(this.signalServer.connectionId, {
                            type: 'ice-candidate',
                            sourcePeerId: config.localPeerId,
                            targetPeerId: peerId,
                            candidate: event.candidate
                        });
                    }
                };
                // Handle data channel creation by the remote peer
                peerConnection.ondatachannel = (event) => {
                    const dataChannel = event.channel;
                    // Generate a connection ID
                    const connectionId = uuidv4();
                    // Store the data channel
                    this.dataChannels.set(peerId, dataChannel);
                    // Set up data channel event handlers
                    dataChannel.onopen = () => {
                        console.log(`Data channel from ${peerId} opened`);
                    };
                    dataChannel.onclose = () => {
                        console.log(`Data channel from ${peerId} closed`);
                        // Clean up
                        this.dataChannels.delete(peerId);
                        this.peerConnections.delete(peerId);
                        this.webSocketConnections.delete(connectionId);
                        this.messageCallbacks.delete(connectionId);
                    };
                    dataChannel.onerror = (error) => {
                        console.error(`Data channel error:`, error);
                    };
                    // Create a message handler wrapper that will call all registered callbacks
                    const messageHandlerWrapper = (data) => {
                        const callbacks = this.messageCallbacks.get(connectionId);
                        if (callbacks) {
                            for (const callback of callbacks) {
                                try {
                                    callback(data);
                                }
                                catch (error) {
                                    console.error(`Error in WebRTC message callback:`, error);
                                }
                            }
                        }
                    };
                    dataChannel.onmessage = (event) => {
                        try {
                            // Parse the message if it's a string
                            let data = event.data;
                            if (typeof data === 'string') {
                                try {
                                    data = JSON.parse(data);
                                }
                                catch {
                                    // If parsing fails, use the raw string
                                }
                            }
                            // Call the message handler wrapper
                            messageHandlerWrapper(data);
                        }
                        catch (error) {
                            console.error(`Error handling WebRTC message:`, error);
                        }
                    };
                    // Create a WebSocket-like connection object for the WebRTC connection
                    const connection = {
                        connectionId,
                        url: `webrtc://${peerId}`,
                        status: 'disconnected',
                        send: async (data) => {
                            if (dataChannel.readyState !== 'open') {
                                throw new Error('WebRTC data channel is not open');
                            }
                            // Send the data
                            if (typeof data === 'string') {
                                dataChannel.send(data);
                            }
                            else if (data instanceof Blob) {
                                dataChannel.send(data);
                            }
                            else if (data instanceof ArrayBuffer) {
                                dataChannel.send(new Uint8Array(data));
                            }
                            else if (ArrayBuffer.isView(data)) {
                                dataChannel.send(data);
                            }
                            else {
                                // Convert to JSON string
                                dataChannel.send(JSON.stringify(data));
                            }
                        },
                        close: async () => {
                            dataChannel.close();
                            const pc = this.peerConnections.get(peerId);
                            if (pc) {
                                pc.close();
                            }
                            // Clean up
                            this.dataChannels.delete(peerId);
                            this.peerConnections.delete(peerId);
                            this.webSocketConnections.delete(connectionId);
                            this.messageCallbacks.delete(connectionId);
                        },
                        _messageHandlerWrapper: messageHandlerWrapper
                    };
                    // Store the connection
                    this.webSocketConnections.set(connectionId, connection);
                    // Initialize the callbacks set
                    this.messageCallbacks.set(connectionId, new Set());
                };
            }
            // Set the remote description (the offer)
            await peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
            // Create an answer
            const answer = await peerConnection.createAnswer();
            await peerConnection.setLocalDescription(answer);
            // Send the answer to the peer via the signaling server
            if (this.signalServer) {
                await this.sendWebSocketMessage(this.signalServer.connectionId, {
                    type: 'answer',
                    sourcePeerId: config.localPeerId,
                    targetPeerId: peerId,
                    answer
                });
            }
        }
        catch (error) {
            console.error(`Failed to handle WebRTC offer:`, error);
            throw new Error(`Failed to handle WebRTC offer: ${error}`);
        }
    }
    /**
     * Reads data from a connected Brainy instance
     * @param query Query parameters for reading data
     * @param options Additional options
     */
    async readData(query, options) {
        await this.ensureInitialized();
        try {
            const connectionId = query.connectionId;
            if (!connectionId) {
                throw new Error('connectionId is required for reading data');
            }
            const connection = this.webSocketConnections.get(connectionId);
            if (!connection) {
                throw new Error(`Connection ${connectionId} not found`);
            }
            // Create a request message
            const requestMessage = {
                type: 'read',
                query: query.query || {},
                requestId: uuidv4(),
                options
            };
            // Send the request
            await this.sendWebSocketMessage(connectionId, requestMessage);
            // Return a promise that will be resolved when the response is received
            return new Promise((resolve) => {
                const responseHandler = (data) => {
                    // Check if this is the response to our request
                    const response = data;
                    if (response && response.type === 'readResponse' && response.requestId === requestMessage.requestId) {
                        // Remove the handler
                        this.offWebSocketMessage(connectionId, responseHandler);
                        // Resolve with the response data
                        resolve({
                            success: response.success,
                            data: response.data,
                            error: response.error
                        });
                    }
                };
                // Register the response handler
                this.onWebSocketMessage(connectionId, responseHandler);
                // Set a timeout to prevent hanging
                setTimeout(() => {
                    this.offWebSocketMessage(connectionId, responseHandler);
                    resolve({
                        success: false,
                        data: null,
                        error: 'Timeout waiting for read response'
                    });
                }, 30000); // 30 second timeout
            });
        }
        catch (error) {
            console.error(`Failed to read data:`, error);
            return {
                success: false,
                data: null,
                error: `Failed to read data: ${error}`
            };
        }
    }
    /**
     * Writes data to a connected Brainy instance
     * @param data The data to write
     * @param options Additional options
     */
    async writeData(data, options) {
        await this.ensureInitialized();
        try {
            const connectionId = data.connectionId;
            if (!connectionId) {
                throw new Error('connectionId is required for writing data');
            }
            const connection = this.webSocketConnections.get(connectionId);
            if (!connection) {
                throw new Error(`Connection ${connectionId} not found`);
            }
            // Create a write message
            const writeMessage = {
                type: 'write',
                data: data.data || {},
                requestId: uuidv4(),
                options
            };
            // Send the write message
            await this.sendWebSocketMessage(connectionId, writeMessage);
            // Return a promise that will be resolved when the response is received
            return new Promise((resolve) => {
                const responseHandler = (data) => {
                    // Check if this is the response to our request
                    const response = data;
                    if (response && response.type === 'writeResponse' && response.requestId === writeMessage.requestId) {
                        // Remove the handler
                        this.offWebSocketMessage(connectionId, responseHandler);
                        // Resolve with the response data
                        resolve({
                            success: response.success,
                            data: response.data,
                            error: response.error
                        });
                    }
                };
                // Register the response handler
                this.onWebSocketMessage(connectionId, responseHandler);
                // Set a timeout to prevent hanging
                setTimeout(() => {
                    this.offWebSocketMessage(connectionId, responseHandler);
                    resolve({
                        success: false,
                        data: null,
                        error: 'Timeout waiting for write response'
                    });
                }, 30000); // 30 second timeout
            });
        }
        catch (error) {
            console.error(`Failed to write data:`, error);
            return {
                success: false,
                data: null,
                error: `Failed to write data: ${error}`
            };
        }
    }
    /**
     * Monitors a data stream from a connected Brainy instance
     * @param streamId The ID of the stream to monitor (usually a connection ID)
     * @param callback Function to call when new data is received
     */
    async monitorStream(streamId, callback) {
        await this.ensureInitialized();
        try {
            const connection = this.webSocketConnections.get(streamId);
            if (!connection) {
                throw new Error(`Connection ${streamId} not found`);
            }
            // Register the callback for all messages on this connection
            await this.onWebSocketMessage(streamId, callback);
        }
        catch (error) {
            console.error(`Failed to monitor stream ${streamId}:`, error);
            throw new Error(`Failed to monitor stream: ${error}`);
        }
    }
    /**
     * Establishes a WebSocket connection (used for signaling in WebRTC)
     * @param url The WebSocket server URL to connect to
     * @param protocols Optional subprotocols
     */
    async connectWebSocket(url, protocols) {
        await this.ensureInitialized();
        return new Promise((resolve, reject) => {
            try {
                // Check if WebSocket is available
                if (typeof WebSocket === 'undefined') {
                    throw new Error('WebSocket is not available in this environment');
                }
                // Create a new WebSocket connection
                const ws = new WebSocket(url, protocols);
                const connectionId = uuidv4();
                // Create a connection object
                const connection = {
                    connectionId,
                    url,
                    status: 'disconnected',
                    send: async (data) => {
                        if (ws.readyState !== WebSocket.OPEN) {
                            throw new Error('WebSocket is not open');
                        }
                        ws.send(data);
                    },
                    close: async () => {
                        ws.close();
                    }
                };
                // Set up event handlers
                ws.onopen = () => {
                    connection.status = 'connected';
                    resolve(connection);
                };
                ws.onerror = (error) => {
                    connection.status = 'error';
                    console.error(`WebSocket error for ${url}:`, error);
                    if (ws.readyState !== WebSocket.OPEN) {
                        reject(new Error(`WebSocket connection failed: ${error}`));
                    }
                };
                ws.onclose = () => {
                    connection.status = 'disconnected';
                    // Remove from connections map
                    this.webSocketConnections.delete(connectionId);
                    // Remove all callbacks
                    this.messageCallbacks.delete(connectionId);
                };
                // Create a message handler wrapper that will call all registered callbacks
                const messageHandlerWrapper = (data) => {
                    const callbacks = this.messageCallbacks.get(connectionId);
                    if (callbacks) {
                        for (const callback of callbacks) {
                            try {
                                callback(data);
                            }
                            catch (error) {
                                console.error(`Error in WebSocket message callback:`, error);
                            }
                        }
                    }
                };
                // Store the message handler wrapper
                connection._messageHandlerWrapper = messageHandlerWrapper;
                // Set up the message handler
                ws.onmessage = (event) => {
                    try {
                        // Parse the message if it's a string
                        let data = event.data;
                        if (typeof data === 'string') {
                            try {
                                data = JSON.parse(data);
                            }
                            catch {
                                // If parsing fails, use the raw string
                            }
                        }
                        // Call the message handler wrapper
                        messageHandlerWrapper(data);
                    }
                    catch (error) {
                        console.error(`Error handling WebSocket message:`, error);
                    }
                };
                // Store the stream message handler
                connection._streamMessageHandler = (event) => ws.onmessage && ws.onmessage(event);
                // Store the connection
                this.webSocketConnections.set(connectionId, connection);
                // Initialize the callbacks set
                this.messageCallbacks.set(connectionId, new Set());
            }
            catch (error) {
                reject(error);
            }
        });
    }
    /**
     * Sends data through an established WebSocket or WebRTC connection
     * @param connectionId The identifier of the established connection
     * @param data The data to send (will be serialized if not a string)
     */
    async sendWebSocketMessage(connectionId, data) {
        await this.ensureInitialized();
        const connection = this.webSocketConnections.get(connectionId);
        if (!connection) {
            throw new Error(`Connection ${connectionId} not found`);
        }
        if (!connection.send) {
            throw new Error(`Connection ${connectionId} does not support sending messages`);
        }
        // Serialize the data if it's not already a string or binary
        let serializedData;
        if (typeof data === 'string' ||
            data instanceof ArrayBuffer ||
            data instanceof Blob ||
            ArrayBuffer.isView(data)) {
            serializedData = data;
        }
        else {
            // Convert to JSON string
            serializedData = JSON.stringify(data);
        }
        // Send the data
        await connection.send(serializedData);
    }
    /**
     * Registers a callback for incoming WebSocket or WebRTC messages
     * @param connectionId The identifier of the established connection
     * @param callback The function to call when a message is received
     */
    async onWebSocketMessage(connectionId, callback) {
        await this.ensureInitialized();
        const connection = this.webSocketConnections.get(connectionId);
        if (!connection) {
            throw new Error(`Connection ${connectionId} not found`);
        }
        // Get or create the callbacks set for this connection
        let callbacks = this.messageCallbacks.get(connectionId);
        if (!callbacks) {
            callbacks = new Set();
            this.messageCallbacks.set(connectionId, callbacks);
        }
        // Add the callback
        callbacks.add(callback);
    }
    /**
     * Removes a callback for incoming WebSocket or WebRTC messages
     * @param connectionId The identifier of the established connection
     * @param callback The function to remove from the callbacks
     */
    async offWebSocketMessage(connectionId, callback) {
        await this.ensureInitialized();
        const callbacks = this.messageCallbacks.get(connectionId);
        if (callbacks) {
            callbacks.delete(callback);
        }
    }
    /**
     * Closes an established WebSocket or WebRTC connection
     * @param connectionId The identifier of the established connection
     * @param code Optional close code
     * @param reason Optional close reason
     */
    async closeWebSocket(connectionId, code, reason) {
        await this.ensureInitialized();
        const connection = this.webSocketConnections.get(connectionId);
        if (!connection) {
            throw new Error(`Connection ${connectionId} not found`);
        }
        if (!connection.close) {
            throw new Error(`Connection ${connectionId} does not support closing`);
        }
        // Close the connection
        await connection.close();
        // Remove from connections map
        this.webSocketConnections.delete(connectionId);
        // Remove all callbacks
        this.messageCallbacks.delete(connectionId);
    }
}
/**
 * Factory function to create the appropriate conduit augmentation based on the type
 */
export async function createConduitAugmentation(type, name, options = {}) {
    switch (type) {
        case 'websocket':
            const wsAugmentation = new WebSocketConduitAugmentation(name || 'websocket-conduit');
            await wsAugmentation.initialize();
            return wsAugmentation;
        case 'webrtc':
            const webrtcAugmentation = new WebRTCConduitAugmentation(name || 'webrtc-conduit');
            await webrtcAugmentation.initialize();
            return webrtcAugmentation;
        default:
            throw new Error(`Unknown conduit augmentation type: ${type}`);
    }
}
//# sourceMappingURL=conduitAugmentations.js.map