instance-manager.js

// Instance Manager - handles multiple Spacebar backends
const fs = require('fs');
const path = require('path');
const http = require('http');
const config = require('./config');

class InstanceManager {
    constructor(configPath = './instances.json') {
        this.configPath = configPath;
        this.instances = new Map();
        this.routingConfig = {};
        this.currentIndex = 0;
        this.healthStatus = new Map();

        this.loadConfig();
        this.startHealthChecks();
    }

    loadConfig() {
        try {
            const data = JSON.parse(fs.readFileSync(this.configPath, 'utf8'));
            
            this.instances.clear();
            for (const inst of data.instances) {
                this.instances.set(inst.id, {
                    ...inst,
                    lastUsed: null,
                    requestCount: 0
                });
                this.healthStatus.set(inst.id, { healthy: true, lastCheck: null, latency: null });
            }

            this.routingConfig = data.routing || {};
            this.selectionConfig = data.selection || {};

            console.log(`[InstanceManager] Loaded ${this.instances.size} instance(s)`);
            this.listEnabled().forEach(i => console.log(`   • ${i.id}: ${i.url}`));
        } catch (err) {
            console.error('[InstanceManager] Failed to load config:', err.message);
            // Fallback to .env configured default
            this.instances.set('default', {
                id: 'default',
                name: 'Default',
                url: config.SPACEBAR,
                enabled: true,
                region: 'default',
                features: ['api', 'gateway', 'cdn']
            });
        }
    }

    // Reload config without restart
    reload() {
        this.loadConfig();
        return this.list();
    }

    // Get all instances
    list() {
        return Array.from(this.instances.values());
    }

    // Get enabled instances only
    listEnabled() {
        return this.list().filter(i => i.enabled);
    }

    // Get instance by ID (including custom instances from cookies)
    get(id, req = null) {
        // Check predefined instances first
        if (this.instances.has(id)) {
            return this.instances.get(id);
        }

        // Check for custom instance from cookie
        if (id === 'custom' && req?.headers?.cookie) {
            const match = req.headers.cookie.match(/spacebar_custom_instance=([^;]+)/);
            if (match) {
                try {
                    const custom = JSON.parse(decodeURIComponent(match[1]));
                    return { ...custom, id: 'custom' };
                } catch {
                    return null;
                }
            }
        }

        return null;
    }

    // Get default instance
    getDefault() {
        const fallback = this.routingConfig.fallback || 'default';
        return this.get(fallback) || this.listEnabled()[0];
    }

    // Select instance based on strategy
    select(req) {
        const enabled = this.listEnabled();
        if (enabled.length === 0) return this.getDefault();
        if (enabled.length === 1) return enabled[0];

        // Check for forced selection via header, cookie, or query param
        const forcedId = this.getForcedSelection(req);
        if (forcedId) {
            const forced = this.get(forcedId, req);
            if (forced && forced.enabled) {
                return forced;
            }
        }

        // Check for custom instance in cookie (auto-select if present and healthy)
        if (req?.headers?.cookie) {
            const customMatch = req.headers.cookie.match(/spacebar_custom_instance=([^;]+)/);
            if (customMatch) {
                try {
                    const custom = JSON.parse(decodeURIComponent(customMatch[1]));
                    if (custom.enabled) {
                        // Verify custom instance is reachable (async check not awaited for performance)
                        this.checkHealth('custom').catch(() => {});
                        return { ...custom, id: 'custom' };
                    }
                } catch {
                    // Invalid custom cookie, fall through
                }
            }
        }

        // Apply routing strategy
        const strategy = this.routingConfig.strategy || 'round-robin';
        
        switch (strategy) {
            case 'round-robin':
                return this.roundRobin(enabled);
            case 'random':
                return enabled[Math.floor(Math.random() * enabled.length)];
            case 'least-connections':
                return this.leastConnections(enabled);
            case 'health-based':
                return this.healthBased(enabled);
            default:
                return enabled[0];
        }
    }

    getForcedSelection(req) {
        // Check header
        const header = this.selectionConfig.header;
        if (header && req.headers[header.toLowerCase()]) {
            return req.headers[header.toLowerCase()];
        }

        // Check query param
        const queryParam = this.selectionConfig.queryParam;
        if (queryParam && req.url) {
            const match = req.url.match(new RegExp(`[?&]${queryParam}=([^&]+)`));
            if (match) return match[1];
        }

        // Check cookie
        const cookie = this.selectionConfig.cookie;
        if (cookie && req.headers.cookie) {
            const match = req.headers.cookie.match(new RegExp(`${cookie}=([^;]+)`));
            if (match) return match[1];
        }

        return null;
    }

    roundRobin(enabled) {
        const instance = enabled[this.currentIndex % enabled.length];
        this.currentIndex++;
        instance.lastUsed = Date.now();
        instance.requestCount++;
        return instance;
    }

    leastConnections(enabled) {
        return enabled.reduce((min, inst) => 
            inst.requestCount < min.requestCount ? inst : min
        );
    }

    healthBased(enabled) {
        // Filter to healthy instances only
        const healthy = enabled.filter(i => this.healthStatus.get(i.id)?.healthy);
        if (healthy.length === 0) return this.getDefault();
        return healthy[0];
    }

    // Health check
    async checkHealth(instanceId, req = null) {
        const instance = this.get(instanceId, req);
        if (!instance) return false;

        const url = new URL(instance.url);
        const startTime = Date.now();

        return new Promise((resolve) => {
            const req = http.get({
                hostname: url.hostname,
                port: url.port || 80,
                path: '/api/v9/ping',
                timeout: this.routingConfig.healthCheck?.timeout || 5000
            }, (res) => {
                const latency = Date.now() - startTime;
                const healthy = res.statusCode === 200;
                
                this.healthStatus.set(instanceId, {
                    healthy,
                    lastCheck: Date.now(),
                    latency,
                    statusCode: res.statusCode
                });

                resolve(healthy);
            });

            req.on('error', () => {
                this.healthStatus.set(instanceId, {
                    healthy: false,
                    lastCheck: Date.now(),
                    latency: null,
                    error: true
                });
                resolve(false);
            });

            req.on('timeout', () => {
                req.destroy();
                this.healthStatus.set(instanceId, {
                    healthy: false,
                    lastCheck: Date.now(),
                    latency: null,
                    timeout: true
                });
                resolve(false);
            });
        });
    }

    // Start periodic health checks
    startHealthChecks() {
        if (!this.routingConfig.healthCheck?.enabled) return;

        const interval = this.routingConfig.healthCheck?.interval || 30000;
        
        setInterval(() => {
            for (const [id, instance] of this.instances) {
                if (instance.enabled) {
                    this.checkHealth(id).catch(() => {});
                }
            }
        }, interval);

        console.log(`[InstanceManager] Health checks enabled (${interval}ms interval)`);
    }

    // Get health status for all instances
    getHealth() {
        const status = {};
        for (const [id, health] of this.healthStatus) {
            const instance = this.get(id);
            status[id] = {
                ...health,
                enabled: instance?.enabled,
                url: instance?.url
            };
        }
        return status;
    }

    // Middleware for instance selection info
    middleware() {
        return (req, res, next) => {
            req.selectInstance = () => this.select(req);
            req.getInstance = (id) => this.get(id);
            next();
        };
    }

    // Express routes for management
    setupRoutes(app) {
        // List all instances
        app.get('/_instances', (req, res) => {
            res.json({
                instances: this.list(),
                health: this.getHealth(),
                routing: this.routingConfig
            });
        });

        // Get specific instance
        app.get('/_instances/:id', (req, res) => {
            const instance = this.get(req.params.id);
            if (!instance) {
                return res.status(404).json({ error: 'Instance not found' });
            }
            res.json({
                instance,
                health: this.healthStatus.get(req.params.id)
            });
        });

        // Force select instance (sets cookie)
        app.post('/_instances/:id/select', (req, res) => {
            const id = req.params.id;
            // Check predefined instances first
            let instance = this.instances.get(id);
            // Then check custom
            if (!instance && id === 'custom') {
                instance = this.get(id, req);
            }

            if (!instance) {
                return res.status(404).json({ error: 'Instance not found' });
            }
            if (!instance.enabled) {
                return res.status(400).json({ error: 'Instance is disabled' });
            }

            res.cookie(this.selectionConfig.cookie, id, {
                maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
                httpOnly: false,
                sameSite: 'lax'
            });

            res.json({ 
                success: true, 
                selected: id,
                instance: instance
            });
        });

        // Reload config
        app.post('/_instances/reload', (req, res) => {
            const result = this.reload();
            res.json({ success: true, instances: result });
        });

        // Health check all
        app.get('/_instances/health', async (req, res) => {
            const checks = [];
            for (const id of this.instances.keys()) {
                checks.push(this.checkHealth(id));
            }
            await Promise.all(checks);
            res.json({ health: this.getHealth() });
        });

        // Get current selected instance
        app.get('/_instances/current', (req, res) => {
            const instance = this.select(req);
            res.json({
                instance,
                available: this.listEnabled(),
                selection: this.getForcedSelection(req)
            });
        });

        // Set custom instance URL (user-defined)
        app.post('/_instances/custom', (req, res) => {
            const { url, name } = req.body;
            if (!url) {
                return res.status(400).json({ error: 'URL is required' });
            }

            // Validate URL format
            try {
                new URL(url);
            } catch {
                return res.status(400).json({ error: 'Invalid URL format' });
            }

            // Store custom instance in cookie
            const customInstance = {
                id: 'custom',
                name: name || 'Custom Instance',
                url: url,
                enabled: true,
                region: 'custom',
                features: ['api', 'gateway', 'cdn']
            };

            res.cookie('spacebar_custom_instance', JSON.stringify(customInstance), {
                maxAge: 30 * 24 * 60 * 60 * 1000, // 30 days
                httpOnly: false,
                sameSite: 'lax'
            });

            // Also select it as current
            res.cookie(this.selectionConfig.cookie, 'custom', {
                maxAge: 7 * 24 * 60 * 60 * 1000,
                httpOnly: false,
                sameSite: 'lax'
            });

            res.json({ success: true, instance: customInstance });
        });

        // Clear custom instance
        app.post('/_instances/custom/clear', (req, res) => {
            res.clearCookie('spacebar_custom_instance');
            res.clearCookie(this.selectionConfig.cookie);
            res.json({ success: true });
        });
    }
}

module.exports = InstanceManager;