import { HyphaCore } from 'hypha-core';

const hyphaCore = new HyphaCore();
window.hyphaCore = hyphaCore; // Expose globally if needed

const api = await hyphaCore.start();

#!/usr/bin/env -S deno run --allow-net --allow-env
import { HyphaCore } from '../src/hypha-core.js';
import { DenoWebSocketServer, DenoWebSocketClient } from '../src/deno-websocket-server.js';

const hyphaCore = new HyphaCore({
    url: "http://localhost:9527",
    ServerClass: DenoWebSocketServer,      // Use real WebSocket server
    WebSocketClass: DenoWebSocketClient,   // Use real WebSocket client
    jwtSecret: "deno-hypha-secret-key",
    defaultService: {
        // Services with context for authentication and workspace info
        hello: (name, context) => {
            name = name || "World";
            const greeting = `Hello, ${name}! Greetings from Deno Hypha Server 🦕`;
            console.log(`Hello service called: ${greeting}`, context ? `from ${context.from}` : '');
            return greeting;
        },
        
        get_time: (context) => {
            const now = new Date().toISOString();
            console.log(`Time service called: ${now}`, context ? `from ${context.from}` : '');
            return now;
        }
    }
});

// Start the server with proper connection handling
const api = await hyphaCore.start();
console.log(`🚀 Hypha Core server started at ${hyphaCore.url}`);
console.log(`🔌 WebSocket URL: ${hyphaCore.wsUrl}`);

import { hyphaWebsocketClient } from 'hypha-rpc';

const server = await hyphaWebsocketClient.connectToServer({
    server_url: "ws://localhost:9527/ws"
});

const greeting = await server.hello("JavaScript Client");
console.log(greeting);

const serverInfo = await server.get_server_info();
console.log("Server info:", serverInfo);

// Handles SIGINT and SIGTERM for clean shutdown
Deno.addSignalListener("SIGINT", () => {
    console.log('🛑 Shutting down server...');
    hyphaCore.close();
    Deno.exit(0);
});

// Built-in services are registered with :built-in suffix
// This bypasses workspace security for system services
await hyphaCore.workspaceManager.setup({
    client_id: hyphaCore.workspaceManagerId,
    defaultService: {
        // These become accessible as server.hello(), server.get_time(), etc.
        hello: (name, context) => `Hello, ${name || "World"}!`,
        get_time: (context) => new Date().toISOString(),
        get_server_info: (context) => ({
            platform: "Deno",
            version: Deno.version.deno,
            server: "hypha-core-deno"
        })
    }
});

import { HyphaCore } from 'hypha-core';

const hyphaCore = new HyphaCore({
    port: 9527,
    jwtSecret: process.env.HYPHA_JWT_SECRET,
    baseUrl: 'http://localhost:9527/',
});

// Environment detection
console.log(`Running in: ${hyphaCore.environment}`); // 'node'

const api = await hyphaCore.start();
console.log('🚀 HyphaCore server running on Node.js!');

// Connect clients with JWT authentication
const clientApi = await hyphaCore.connect({
    token: await api.generateToken({ user_id: 'node-client' }),
    workspace: 'data-processing'
});

import { HyphaCore } from 'hypha-core';

const hyphaCore = new HyphaCore();
const api = await hyphaCore.start();

try {
    // This will work in all environments
    await api.registerService({
        id: 'data-processor',
        process: (data) => data.map(x => x * 2)
    });
    
    // This will throw clear error in server environments
    await api.createWindow({ src: 'https://example.com' });
} catch (error) {
    if (error.message.includes('requires browser environment')) {
        console.log('🔍 Browser-only feature attempted in server environment');
        console.log('💡 Use only core HyphaCore features in Deno/Node.js');
    }
}

const hyphaCore = new HyphaCore({
    port: 8080,                    // Server port (default: 8080)
    baseUrl: "https://myapp.com/", // Base URL for serving template files (must end with /)
    url: "wss://myserver.com/ws",  // Direct WebSocket URL (alternative to port)
    defaultService: {             // Default services to register
        myService: async () => { /* implementation */ }
    }
});

const api = await hyphaCore.start({
    workspace: "my-workspace",     // Workspace identifier (default: "default")
    client_id: "my-client",        // Client identifier (default: auto-generated)
    server: hyphaCore             // Reference to the server instance
});

// cluster-config.js
export const clusterConfig = {
    redis: {
        url: process.env.REDIS_URL || 'redis://localhost:6379',
        channel: 'hypha-cluster',
        connectionTimeout: 5000
    },
    servers: [
        { id: 'server-1', port: 8080, weight: 1 },
        { id: 'server-2', port: 8081, weight: 1 },
        { id: 'server-3', port: 8082, weight: 1 }
    ],
    loadBalancer: {
        strategy: 'round-robin', // 'round-robin', 'least-connections', 'weighted'
        healthCheck: {
            interval: 10000,
            timeout: 3000,
            retries: 3
        }
    }
};

// Connect to any server in the cluster
const ws1 = new WebSocket('ws://localhost:8080/ws');
const ws2 = new WebSocket('ws://localhost:8081/ws');
const ws3 = new WebSocket('ws://localhost:8082/ws');

// Or through load balancer
const ws = new WebSocket('ws://localhost/ws');

// Create and start the core server
const hyphaCore = new HyphaCore();
await hyphaCore.start();

// Connect to different workspaces
const workspace1 = await hyphaCore.connect({
    workspace: "analysis-workspace",
    client_id: "analysis-client"
});

const workspace2 = await hyphaCore.connect({
    workspace: "visualization-workspace", 
    client_id: "viz-client"
});

// Each workspace operates independently
await workspace1.registerService({
    name: "data-processor",
    config: {
        require_context: true,
        visibility: "public",
    },
    process: async (data, context) => {
        // context.ws === "analysis-workspace"
        console.log(`Processing data in workspace: ${context.ws}`);
        return data.map(x => x * 2);
    }
});

await workspace2.registerService({
    name: "chart-renderer",
    config: {
        require_context: true,
        visibility: "public",
    },
    render: async (data, context) => {
        // context.ws === "visualization-workspace"
        console.log(`Rendering chart in workspace: ${context.ws}`);
        return { chart: "rendered", workspace: context.ws };
    }
});

// Load app from URL (e.g., GitHub raw URL)
const app = await api.loadApp({
    src: "https://raw.githubusercontent.com/myuser/myrepo/main/my-app.imjoy.html"
});

// Run and interact with the app
await app.run();
const result = await app.processData([1, 2, 3, 4]);
console.log(result); // [2, 4, 6, 8]

// Create a window with your standalone app
const appWindow = await api.createWindow({
    src: "/path/to/my-standalone-app.html",  // or full URL
    name: "My Standalone App",
    pos: "main"  // or "side"
});

// Wait a moment for the app to initialize
await new Promise(resolve => setTimeout(resolve, 1000));

// Interact with the app's exported services
const result = await appWindow.processData([1, 2, 3, 4, 5]);
console.log("App result:", result); // [1, 4, 9, 16, 25]

await appWindow.updateUI({
    title: "Updated App Title",
    message: "Hello from parent!"
});

const appState = await appWindow.getAppState();
console.log("App state:", appState);

// Load worker with ImJoy plugin format (.imjoy.html files)
const worker = await api.loadApp({
    src: "https://example.com/my-plugin.imjoy.html"
});

// Load custom worker script directly
const customWorker = await api.loadApp({
    type: 'web-worker',                    // Specify worker type
    src: 'https://example.com/my-custom-worker.js',  // Direct script URL
    name: 'My Custom Worker',
    description: 'Custom computational worker'
});

// Works with different URL types:
// HTTP/HTTPS URLs
const httpWorker = await api.loadApp({
    type: 'web-worker',
    src: 'https://cdn.example.com/workers/math-worker.js'
});

// Blob URLs (for dynamically generated scripts)
const blob = new Blob([workerCode], { type: 'application/javascript' });
const blobUrl = URL.createObjectURL(blob);
const blobWorker = await api.loadApp({
    type: 'web-worker', 
    src: blobUrl
});

// Local file URLs
const fileWorker = await api.loadApp({
    type: 'web-worker',
    src: '/static/workers/data-processor.js'
});

// Import Hypha RPC client in the worker
importScripts('https://cdn.jsdelivr.net/npm/[email protected]/dist/hypha-rpc-websocket.min.js');

console.log('🔧 Custom Computational Worker: Starting...');

// Connect to Hypha Core from the worker
hyphaWebsocketClient.setupLocalClient({
    enable_execution: true,
    workspace: "worker-workspace",
    client_id: "computational-worker-001"
}).then(async (api) => {
    console.log('✅ Worker connected to Hypha Core');
    
    // Export comprehensive worker services
    const exportedServices = await api.export({
        id: 'computational-services',
        name: 'Computational Services',
        description: 'CPU-intensive computations optimized for WebWorker environment',
        
        // Mathematical computations
        fibonacci: function(n) {
            console.log(`🔢 Worker: Computing fibonacci(${n})`);
            if (n <= 1) return n;
            let a = 0, b = 1;
            for (let i = 2; i <= n; i++) {
                [a, b] = [b, a + b];
            }
            return b;
        },
        
        factorial: function(n) {
            console.log(`🔢 Worker: Computing factorial(${n})`);
            if (n <= 1) return 1;
            let result = 1;
            for (let i = 2; i <= n; i++) {
                result *= i;
            }
            return result;
        },
        
        // Prime number operations
        isPrime: function(n) {
            if (n <= 1) return false;
            if (n <= 3) return true;
            if (n % 2 === 0 || n % 3 === 0) return false;
            for (let i = 5; i * i <= n; i += 6) {
                if (n % i === 0 || n % (i + 2) === 0) return false;
            }
            return true;
        },
        
        // Array processing operations
        processArray: function(arr, operation) {
            const operations = {
                sum: () => arr.reduce((a, b) => a + b, 0),
                product: () => arr.reduce((a, b) => a * b, 1),
                average: () => arr.reduce((a, b) => a + b, 0) / arr.length,
                max: () => Math.max(...arr),
                min: () => Math.min(...arr),
                sort: () => [...arr].sort((a, b) => a - b),
                reverse: () => [...arr].reverse()
            };
            
            if (!operations[operation]) {
                throw new Error(`Unknown operation: ${operation}`);
            }
            
            return operations[operation]();
        },
        
        // Heavy computation simulation
        heavyComputation: function(iterations = 1000000) {
            console.log(`⚡ Worker: Running heavy computation with ${iterations} iterations`);
            const startTime = Date.now();
            let result = 0;
            
            for (let i = 0; i < iterations; i++) {
                result += Math.sin(i) * Math.cos(i) * Math.tan(i / 1000);
            }
            
            const endTime = Date.now();
            const duration = endTime - startTime;
            
            return {
                result: result,
                iterations: iterations,
                duration: duration,
                performance: `${iterations / duration} ops/ms`
            };
        },
        
        // Worker info and capabilities
        getWorkerInfo: function() {
            return {
                type: 'webworker',
                environment: 'dedicated-worker',
                timestamp: new Date().toISOString(),
                capabilities: [
                    'fibonacci', 'factorial', 'isPrime', 
                    'processArray', 'heavyComputation'
                ],
                userAgent: navigator.userAgent,
                hardwareConcurrency: navigator.hardwareConcurrency
            };
        }
    });
    
    console.log('✅ Custom Worker: All services registered successfully');
    
    // Notify main thread that worker is ready
    self.postMessage({ 
        type: 'worker_ready', 
        message: 'Custom worker services registered successfully',
        services: Object.keys(exportedServices).filter(key => typeof exportedServices[key] === 'function')
    });
    
}).catch(error => {
    console.error('❌ Custom Worker: Failed to setup Hypha client:', error);
    self.postMessage({ 
        type: 'worker_error', 
        error: error.message 
    });
});

// Handle messages from main thread
self.onmessage = function(event) {
    const { type, data } = event.data;
    
    switch (type) {
        case 'ping':
            self.postMessage({ 
                type: 'pong', 
                message: 'Custom worker is operational',
                timestamp: new Date().toISOString()
            });
            break;
            
        case 'shutdown':
            console.log('🛑 Custom Worker: Shutdown requested');
            self.postMessage({ type: 'shutdown_acknowledged' });
            self.close();
            break;
            
        default:
            console.warn('⚠️ Custom Worker: Unknown message type:', type);
    }
};

// Error handling
self.onerror = function(error) {
    console.error('💥 Custom Worker: Unhandled error:', error);
    self.postMessage({ 
        type: 'worker_error', 
        error: error.message 
    });
};

console.log('🚀 Custom Worker: Initialization complete');

// Load the custom computational worker
const computeWorker = await api.loadApp({
    type: 'web-worker',
    src: '/workers/computational-worker.js',
    name: 'Computational Worker',
    description: 'High-performance mathematical computations'
});

console.log('Worker loaded:', computeWorker.id);

// Use computational services
const fibResult = await computeWorker.fibonacci(20);
console.log('Fibonacci(20):', fibResult);  // 6765

const factResult = await computeWorker.factorial(5);
console.log('Factorial(5):', factResult);  // 120

const primeCheck = await computeWorker.isPrime(97);
console.log('Is 97 prime?:', primeCheck);  // true

const arraySum = await computeWorker.processArray([1, 2, 3, 4, 5], 'sum');
console.log('Array sum:', arraySum);  // 15

// Heavy computation in background
const heavyResult = await computeWorker.heavyComputation(500000);
console.log('Heavy computation result:', heavyResult);
// { result: 1234.567, iterations: 500000, duration: 89, performance: "5617 ops/ms" }

// Get worker capabilities
const workerInfo = await computeWorker.getWorkerInfo();
console.log('Worker info:', workerInfo);

hyphaWebsocketClient.setupLocalClient({enable_execution: true}).then(async (api) => {
    // Your app code here
    await api.export({
        // Your exported services
    });
}).catch(console.error);

import { HyphaCore } from 'hypha-core';

// Start Hypha Core
const server = new HyphaCore({ port: 9527 });
await server.start();

// Create a web worker
const worker = new Worker('my-worker.js');

// Mount it to Hypha Core
await server.mountWorker(worker, {
    workspace: 'default',           // Optional: defaults to 'default'
    client_id: 'my-worker',         // Optional: auto-generated if not provided
    timeout: 60000                  // Optional: connection timeout (default: 60s)
});

// Worker is now connected and ready for RPC communication!

// Mount a Pyodide worker with Python code to execute
const worker = new Worker('pyodide-worker.js');

await server.mountWorker(worker, {
    workspace: 'default',
    client_id: 'python-notebook',
    config: {
        name: 'My Notebook',
        scripts: [{
            lang: 'python',
            content: `
print("Hello from Python!")

# Access Hypha services from Python
services = await api.list_services({})
print(f"Found {len(services)} services")

# Get a JavaScript service and call it
demo = await api.get_service("demo-service")
result = await demo.greet("Python")
print(f"Response: {result}")
`
        }]
    }
});

// my-worker.js
importScripts("https://cdn.jsdelivr.net/npm/[email protected]/dist/hypha-rpc-websocket.min.js");

// Start Pyodide or other environment
loadPyodide().then(async (pyodide) => {
    // Install hypha-rpc
    await pyodide.loadPackage("micropip");
    const micropip = pyodide.pyimport("micropip");
    await micropip.install('hypha-rpc==0.20.84');

    // Signal ready to receive initialization
    self.postMessage({ type: "hyphaClientReady" });

    // Set up the local client (will block until initializeHyphaClient arrives)
    await pyodide.runPythonAsync(`
from hypha_rpc import setup_local_client

async def execute(server, config):
    # Your Python code execution logic
    print('Executing:', config["name"])
    for script in config["scripts"]:
        exec(script["content"], {'api': server})

server = await setup_local_client(enable_execution=False, on_ready=execute)
    `);
});

// Create an iframe element
const iframe = document.createElement('iframe');
iframe.src = 'my-app.html';
document.body.appendChild(iframe);

// Wait for iframe to load
await new Promise(resolve => iframe.onload = resolve);

// Mount it to Hypha Core
await server.mountIframe(iframe, {
    workspace: 'default',
    client_id: 'my-iframe-app'
});

// Iframe is now connected!

// Mount an iframe inside an existing div
const container = document.getElementById('app-container');

// Create iframe programmatically
const iframe = document.createElement('iframe');
iframe.src = '/apps/data-viewer.html';
iframe.style.width = '100%';
iframe.style.height = '600px';
container.appendChild(iframe);

// Mount to Hypha Core
const result = await server.mountIframe(iframe, {
    workspace: 'visualization',
    client_id: 'data-viewer'
});

console.log('Iframe mounted:', result.client_id);

// Get the iframe's service and interact with it
const viewerService = await server.api.getService('data-viewer:default');
await viewerService.loadData({ dataset: 'my-data.csv' });

{
    workspace: 'workspace-name',    // Workspace to connect to (default: 'default')
    client_id: 'unique-client-id',  // Client identifier (default: auto-generated)
    user_info: {                    // User information (default: anonymous)
        id: 'user-123',
        email: '[email protected]',
        roles: ['user'],
        scopes: []
    },
    config: {},                     // Configuration passed to the worker/iframe
    timeout: 60000,                 // Connection timeout in ms (default: 60000)
    passive: false                  // Skip waiting for service registration (default: false)
}

// Mount worker in passive mode
const result = await server.mountWorker(worker, {
    workspace: 'default',
    passive: true  // Returns immediately, service will be null
});

console.log(result.service);  // null - no service yet

// Later, get the service when needed
const service = await server.api.getService(`${result.client_id}:default`);

{
    workspace: 'workspace-name',
    client_id: 'client-id',
    connection: { /* connection object */ },
    service: { /* registered service object */ }  // null if passive: true
}

// Complete context object structure
const context = {
    ws: "workspace-name",           // Current workspace ID
    from: "workspace/client-id",    // Source client identifier  
    to: "workspace/service-id",     // Target service identifier
    user: {                         // User information (if authenticated)
        id: "user-id",
        email: "[email protected]",
        is_anonymous: false,
        roles: ["admin", "user"],
        expires_at: 1234567890
    }
};

await api.registerService({
    name: "secure-data-service",
    config: {
        require_context: true,
        visibility: "protected",  // Only accessible within workspace
    },
    
    async getData(query, context) {
        // Validate workspace access
        if (context.ws !== "authorized-workspace") {
            throw new Error("Access denied: Invalid workspace");
        }
        
        // Log access for auditing
        console.log(`Data access by ${context.from} in workspace ${context.ws}`);
        
        // Return workspace-specific data
        return {
            data: getWorkspaceData(context.ws),
            workspace: context.ws,
            requestedBy: context.from
        };
    },
    
    async saveData(data, context) {
        // Ensure data is saved to correct workspace
        const workspaceKey = `data:${context.ws}:${Date.now()}`;
        
        // Workspace-isolated storage
        return await saveToWorkspaceStorage(workspaceKey, {
            ...data,
            workspace: context.ws,
            savedBy: context.from,
            timestamp: new Date().toISOString()
        });
    }
});

await api.registerService({
    name: "workspace-bridge",
    config: {
        require_context: true,
        visibility: "public",
    },
    
    async sendToWorkspace(targetWorkspace, message, context) {
        // Validate source workspace permissions
        const allowedSources = ["admin-workspace", "bridge-workspace"];
        if (!allowedSources.includes(context.ws)) {
            throw new Error(`Workspace ${context.ws} not authorized for cross-workspace communication`);
        }
        
        // Log cross-workspace communication
        console.log(`Bridge: ${context.ws} → ${targetWorkspace}`, message);
        
        // Send message to target workspace
        return await api.emit(`${targetWorkspace}:message`, {
            from: context.ws,
            fromClient: context.from,
            message: message,
            timestamp: Date.now()
        });
    },
    
    async listAuthorizedWorkspaces(context) {
        // Return workspaces this client can access
        const userWorkspaces = getUserWorkspaces(context.user?.id);
        const currentWorkspace = context.ws;
        
        return {
            current: currentWorkspace,
            accessible: userWorkspaces,
            requestedBy: context.from
        };
    }
});

await api.registerService({
    name: "user-workspace-manager",
    config: {
        require_context: true,
        visibility: "public",
    },
    
    async createUserWorkspace(workspaceName, context) {
        // Only authenticated users can create workspaces
        if (context.user?.is_anonymous) {
            throw new Error("Anonymous users cannot create workspaces");
        }
        
        // Prefix with user ID for isolation
        const fullWorkspaceName = `user-${context.user.id}-${workspaceName}`;
        
        // Validate user permissions
        if (!context.user.roles?.includes("workspace-creator")) {
            throw new Error("Insufficient permissions to create workspace");
        }
        
        console.log(`Creating workspace ${fullWorkspaceName} for user ${context.user.email}`);
        
        return {
            workspace: fullWorkspaceName,
            owner: context.user.id,
            createdIn: context.ws,
            permissions: ["read", "write", "admin"]
        };
    },
    
    async switchWorkspace(targetWorkspace, context) {
        // Validate user can access target workspace
        const userWorkspaces = await getUserAccessibleWorkspaces(context.user?.id);
        
        if (!userWorkspaces.includes(targetWorkspace)) {
            throw new Error(`Access denied to workspace: ${targetWorkspace}`);
        }
        
        // Log workspace switch for auditing
        console.log(`User ${context.user?.email} switching: ${context.ws} → ${targetWorkspace}`);
        
        // Return connection config for new workspace
        return {
            workspace: targetWorkspace,
            client_id: `${context.user?.id}-${Date.now()}`,
            message: `Switched to workspace: ${targetWorkspace}`
        };
    }
});

// Public service - accessible from any workspace
await api.registerService({
    name: "public-utility",
    config: {
        require_context: true,
        visibility: "public",  // Accessible across workspaces
    },
    
    async getSystemInfo(context) {
        return {
            timestamp: Date.now(),
            requestedFrom: context.ws,
            client: context.from,
            // Public information only
            system: "Hypha Core v0.20.55"
        };
    }
});

// Protected service - only within same workspace
await api.registerService({
    name: "sensitive-operations",
    config: {
        require_context: true,
        visibility: "protected",  // Same workspace only
    },
    
    async processSecureData(data, context) {
        // This service is only accessible from the same workspace
        console.log(`Secure processing in workspace: ${context.ws}`);
        
        return {
            processed: encryptData(data, context.ws),
            workspace: context.ws,
            security_level: "protected"
        };
    }
});

// Private service - only for specific clients
await api.registerService({
    name: "admin-only-service",
    config: {
        require_context: true,
        visibility: "private",
    },
    
    async adminOperation(params, context) {
        // Check if user has admin role
        if (!context.user?.roles?.includes("admin")) {
            throw new Error("Admin access required");
        }
        
        // Check if request comes from admin workspace
        if (!context.ws.startsWith("admin-")) {
            throw new Error("Must be called from admin workspace");
        }
        
        console.log(`Admin operation by ${context.user.email} in ${context.ws}`);
        
        return {
            operation: "completed",
            admin: context.user.email,
            workspace: context.ws
        };
    }
});

async function secureServiceMethod(data, context) {
    // Validate required context properties
    if (!context || !context.ws || !context.from) {
        throw new Error("Invalid context: missing required properties");
    }
    
    // Validate workspace format
    if (!/^[a-zA-Z0-9-_]+$/.test(context.ws)) {
        throw new Error("Invalid workspace identifier");
    }
    
    // Continue with business logic...
}

function logServiceAccess(serviceName, method, context, result) {
    const logEntry = {
        timestamp: new Date().toISOString(),
        service: serviceName,
        method: method,
        workspace: context.ws,
        client: context.from,
        user: context.user?.id || "anonymous",
        success: !result.error,
        error: result.error?.message
    };
    
    // Store audit log in workspace-specific location
    storeAuditLog(`${context.ws}/audit.log`, logEntry);
}

await api.registerService({
    name: "audited-service",
    config: { require_context: true },
    
    async sensitiveOperation(data, context) {
        try {
            const result = await performOperation(data, context);
            logServiceAccess("audited-service", "sensitiveOperation", context, result);
            return result;
        } catch (error) {
            logServiceAccess("audited-service", "sensitiveOperation", context, { error });
            throw error;
        }
    }
});