Scalability and Performance

class LoadBalancer {
    constructor(agents) {
        this.agents = agents;
        this.metrics = new Map();
        this.initializeMetrics();
    }

    initializeMetrics() {
        for (const agent of this.agents) {
            this.metrics.set(agent.id, {
                currentLoad: 0,
                capacity: agent.capacity || 100,
                avgResponseTime: 0,
                tasksCompleted: 0,
                failureRate: 0
            });
        }
    }

    // Dynamic load balancing
    assignTask(task) {
        const agent = this.selectAgent(task);

        if (!agent) {
            throw new Error('No available agents');
        }

        // Update metrics
        const metrics = this.metrics.get(agent.id);
        metrics.currentLoad += task.estimatedLoad || 1;

        return {
            agent: agent,
            assignmentTime: Date.now(),
            estimatedCompletion: this.estimateCompletion(agent, task)
        };
    }

    selectAgent(task) {
        const candidates = this.agents.filter(a =>
            a.canHandle(task) &&
            this.isAvailable(a.id)
        );

        if (candidates.length === 0) return null;

        // Score each candidate
        const scored = candidates.map(agent => ({
            agent: agent,
            score: this.scoreAgent(agent, task)
        }));

        // Select highest scoring agent
        scored.sort((a, b) => b.score - a.score);
        return scored[0].agent;
    }

    scoreAgent(agent, task) {
        const metrics = this.metrics.get(agent.id);

        // Load factor (lower is better)
        const loadFactor = 1 - (metrics.currentLoad / metrics.capacity);

        // Performance factor
        const perfFactor = metrics.avgResponseTime > 0 ?
            1000 / metrics.avgResponseTime : 1;

        // Reliability factor
        const reliabilityFactor = 1 - metrics.failureRate;

        // Capability match
        const capabilityMatch = this.matchCapability(agent, task);

        // Weighted combination
        return loadFactor * 0.4 +
               perfFactor * 0.3 +
               reliabilityFactor * 0.2 +
               capabilityMatch * 0.1;
    }

    matchCapability(agent, task) {
        const required = task.requiredSkills || [];
        const available = agent.skills || [];

        if (required.length === 0) return 1.0;

        const matched = required.filter(s => available.includes(s)).length;
        return matched / required.length;
    }

    isAvailable(agentId) {
        const metrics = this.metrics.get(agentId);
        return metrics.currentLoad < metrics.capacity;
    }

    estimateCompletion(agent, task) {
        const metrics = this.metrics.get(agent.id);
        const avgTime = metrics.avgResponseTime || 1000;
        return Date.now() + avgTime + metrics.currentLoad * 100;
    }

    // Called when task completes
    taskCompleted(agentId, task, duration, success) {
        const metrics = this.metrics.get(agentId);

        metrics.currentLoad = Math.max(0,
            metrics.currentLoad - (task.estimatedLoad || 1)
        );

        metrics.tasksCompleted++;

        // Update average response time
        const alpha = 0.2; // Smoothing factor
        metrics.avgResponseTime =
            alpha * duration +
            (1 - alpha) * metrics.avgResponseTime;

        // Update failure rate
        if (!success) {
            metrics.failureRate =
                alpha * 1.0 +
                (1 - alpha) * metrics.failureRate;
        } else {
            metrics.failureRate *= (1 - alpha);
        }
    }

    getSystemMetrics() {
        let totalLoad = 0;
        let totalCapacity = 0;
        let avgResponseTime = 0;
        let totalTasks = 0;

        for (const metrics of this.metrics.values()) {
            totalLoad += metrics.currentLoad;
            totalCapacity += metrics.capacity;
            avgResponseTime += metrics.avgResponseTime * metrics.tasksCompleted;
            totalTasks += metrics.tasksCompleted;
        }

        return {
            utilization: (totalLoad / totalCapacity) * 100,
            avgResponseTime: totalTasks > 0 ? avgResponseTime / totalTasks : 0,
            totalTasksCompleted: totalTasks,
            activeAgents: this.agents.length
        };
    }
}

// 弘益人間: Balanced load distribution for optimal collective performance

class AgentCache {
    constructor(maxSize = 1000, ttl = 3600000) {
        this.cache = new Map();
        this.maxSize = maxSize;
        this.ttl = ttl; // Time to live in milliseconds
        this.hits = 0;
        this.misses = 0;
    }

    get(key) {
        const entry = this.cache.get(key);

        if (!entry) {
            this.misses++;
            return null;
        }

        // Check expiration
        if (Date.now() - entry.timestamp > this.ttl) {
            this.cache.delete(key);
            this.misses++;
            return null;
        }

        // Update access time and frequency
        entry.lastAccess = Date.now();
        entry.accessCount++;
        this.hits++;

        return entry.value;
    }

    set(key, value) {
        // Evict if at capacity
        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
            this.evict();
        }

        this.cache.set(key, {
            value: value,
            timestamp: Date.now(),
            lastAccess: Date.now(),
            accessCount: 0
        });
    }

    // LRU eviction strategy
    evict() {
        let oldestKey = null;
        let oldestTime = Infinity;

        for (const [key, entry] of this.cache) {
            if (entry.lastAccess < oldestTime) {
                oldestTime = entry.lastAccess;
                oldestKey = key;
            }
        }

        if (oldestKey) {
            this.cache.delete(oldestKey);
        }
    }

    // LFU eviction (alternative)
    evictLFU() {
        let leastUsedKey = null;
        let leastCount = Infinity;

        for (const [key, entry] of this.cache) {
            if (entry.accessCount < leastCount) {
                leastCount = entry.accessCount;
                leastUsedKey = key;
            }
        }

        if (leastUsedKey) {
            this.cache.delete(leastUsedKey);
        }
    }

    clear() {
        this.cache.clear();
        this.hits = 0;
        this.misses = 0;
    }

    getStats() {
        const total = this.hits + this.misses;
        return {
            size: this.cache.size,
            hits: this.hits,
            misses: this.misses,
            hitRate: total > 0 ? (this.hits / total) * 100 : 0
        };
    }
}

// Distributed cache for agent coordination
class DistributedCache {
    constructor(nodes) {
        this.nodes = nodes;
        this.partitions = nodes.length;
    }

    getPartition(key) {
        // Consistent hashing
        const hash = this.hash(key);
        return hash % this.partitions;
    }

    async get(key) {
        const partition = this.getPartition(key);
        const node = this.nodes[partition];
        return await node.get(key);
    }

    async set(key, value) {
        const partition = this.getPartition(key);
        const node = this.nodes[partition];
        return await node.set(key, value);
    }

    hash(str) {
        let hash = 0;
        for (let i = 0; i < str.length; i++) {
            const char = str.charCodeAt(i);
            hash = ((hash << 5) - hash) + char;
            hash = hash & hash; // Convert to 32-bit integer
        }
        return Math.abs(hash);
    }
}

// 弘益人間: Efficient caching reducing resource consumption for all

class MessageBatcher {
    constructor(maxBatchSize = 10, maxDelay = 100) {
        this.maxBatchSize = maxBatchSize;
        this.maxDelay = maxDelay;
        this.batches = new Map(); // recipient -> messages[]
        this.timers = new Map();
    }

    sendMessage(recipient, message) {
        if (!this.batches.has(recipient)) {
            this.batches.set(recipient, []);
        }

        const batch = this.batches.get(recipient);
        batch.push(message);

        // Send immediately if batch is full
        if (batch.length >= this.maxBatchSize) {
            this.flush(recipient);
        } else if (!this.timers.has(recipient)) {
            // Schedule flush after delay
            const timer = setTimeout(() => {
                this.flush(recipient);
            }, this.maxDelay);

            this.timers.set(recipient, timer);
        }
    }

    flush(recipient) {
        const batch = this.batches.get(recipient);

        if (batch && batch.length > 0) {
            // Send batched messages
            this.sendBatch(recipient, batch);

            // Clear batch
            this.batches.set(recipient, []);

            // Clear timer
            const timer = this.timers.get(recipient);
            if (timer) {
                clearTimeout(timer);
                this.timers.delete(recipient);
            }
        }
    }

    sendBatch(recipient, messages) {
        // Compress batch
        const compressed = this.compress(messages);

        // Send as single message
        this.transport.send(recipient, {
            type: 'batch',
            count: messages.length,
            data: compressed
        });
    }

    compress(messages) {
        const json = JSON.stringify(messages);

        // Simple compression (use zlib in production)
        return Buffer.from(json).toString('base64');
    }

    decompress(compressed) {
        const json = Buffer.from(compressed, 'base64').toString();
        return JSON.parse(json);
    }

    flushAll() {
        for (const recipient of this.batches.keys()) {
            this.flush(recipient);
        }
    }
}

// 弘益人間: Efficient communication reducing network load for all

class HierarchicalAgentSystem {
    constructor() {
        this.layers = [];
        this.agents = new Map();
    }

    addLayer(layerIndex) {
        if (!this.layers[layerIndex]) {
            this.layers[layerIndex] = {
                agents: [],
                coordinators: []
            };
        }
    }

    addAgent(agent, layerIndex) {
        this.addLayer(layerIndex);
        this.layers[layerIndex].agents.push(agent);
        this.agents.set(agent.id, {
            agent: agent,
            layer: layerIndex,
            supervisor: null
        });
    }

    addCoordinator(coordinator, layerIndex) {
        this.addLayer(layerIndex);
        this.layers[layerIndex].coordinators.push(coordinator);

        // Assign agents to coordinator
        const span = 5; // Span of control
        const agentsInLayer = this.layers[layerIndex + 1]?.agents || [];
        const start = this.layers[layerIndex].coordinators.length * span;
        const subordinates = agentsInLayer.slice(start, start + span);

        subordinates.forEach(agent => {
            const agentInfo = this.agents.get(agent.id);
            agentInfo.supervisor = coordinator;
        });
    }

    propagateTask(task) {
        // Top layer coordinates
        const topLayer = this.layers[0];

        if (topLayer.coordinators.length > 0) {
            const coordinator = this.selectCoordinator(topLayer.coordinators, task);
            return coordinator.delegate(task, this);
        } else {
            // Direct allocation
            return this.allocateDirectly(task);
        }
    }

    selectCoordinator(coordinators, task) {
        // Select based on load and capability
        return coordinators.reduce((best, current) => {
            return current.getLoad() < best.getLoad() ? current : best;
        });
    }

    // Aggregate information up the hierarchy
    aggregateMetrics() {
        const metrics = {};

        // Bottom-up aggregation
        for (let i = this.layers.length - 1; i >= 0; i--) {
            const layer = this.layers[i];

            metrics[i] = {
                agents: layer.agents.length,
                coordinators: layer.coordinators.length,
                avgLoad: this.calculateAvgLoad(layer.agents),
                throughput: this.calculateThroughput(layer.agents)
            };
        }

        return metrics;
    }

    calculateAvgLoad(agents) {
        if (agents.length === 0) return 0;
        const totalLoad = agents.reduce((sum, a) => sum + a.getCurrentLoad(), 0);
        return totalLoad / agents.length;
    }

    calculateThroughput(agents) {
        return agents.reduce((sum, a) => sum + a.getTasksCompleted(), 0);
    }
}

// 弘益人間: Hierarchical organization for large-scale coordination

class ShardedAgentSystem {
    constructor(numShards) {
        this.numShards = numShards;
        this.shards = Array(numShards).fill(null).map((_, i) => ({
            id: i,
            agents: [],
            tasks: [],
            coordinator: null
        }));
    }

    getShard(key) {
        const hash = this.hash(key);
        return this.shards[hash % this.numShards];
    }

    addAgent(agent, partitionKey) {
        const shard = this.getShard(partitionKey || agent.id);
        shard.agents.push(agent);
        agent.shardId = shard.id;
    }

    assignTask(task, partitionKey) {
        const shard = this.getShard(partitionKey || task.id);
        shard.tasks.push(task);

        // Allocate within shard
        return this.allocateInShard(shard, task);
    }

    allocateInShard(shard, task) {
        const availableAgents = shard.agents.filter(a => a.isAvailable());

        if (availableAgents.length === 0) {
            // Cross-shard allocation if needed
            return this.crossShardAllocation(task);
        }

        const agent = this.selectBestAgent(availableAgents, task);
        return { shard: shard.id, agent: agent };
    }

    crossShardAllocation(task) {
        // Find shard with available agents
        for (const shard of this.shards) {
            const available = shard.agents.filter(a => a.isAvailable());
            if (available.length > 0) {
                return this.allocateInShard(shard, task);
            }
        }

        return null; // No available agents
    }

    rebalance() {
        // Rebalance agents across shards
        const avgAgentsPerShard = this.getTotalAgents() / this.numShards;

        for (const shard of this.shards) {
            if (shard.agents.length > avgAgentsPerShard * 1.5) {
                this.moveAgentsToUnderloadedShard(shard);
            }
        }
    }

    moveAgentsToUnderloadedShard(overloadedShard) {
        const avgAgentsPerShard = this.getTotalAgents() / this.numShards;

        for (const shard of this.shards) {
            if (shard.agents.length < avgAgentsPerShard * 0.5) {
                // Move agent
                const agent = overloadedShard.agents.pop();
                shard.agents.push(agent);
                agent.shardId = shard.id;
                break;
            }
        }
    }

    getTotalAgents() {
        return this.shards.reduce((sum, shard) => sum + shard.agents.length, 0);
    }

    hash(str) {
        let hash = 0;
        for (let i = 0; i < str.length; i++) {
            hash = ((hash << 5) - hash) + str.charCodeAt(i);
            hash = hash & hash;
        }
        return Math.abs(hash);
    }
}

// 弘益人間: Partitioned systems scaling to serve vast populations

class PerformanceMonitor {
    constructor() {
        this.metrics = {
            throughput: [],
            latency: [],
            messageRate: [],
            errorRate: []
        };
        this.alerts = [];
    }

    recordMetric(type, value) {
        if (this.metrics[type]) {
            this.metrics[type].push({
                value: value,
                timestamp: Date.now()
            });

            // Keep only recent data
            const maxHistory = 1000;
            if (this.metrics[type].length > maxHistory) {
                this.metrics[type].shift();
            }

            // Check for anomalies
            this.checkAnomaly(type, value);
        }
    }

    checkAnomaly(type, value) {
        const recent = this.metrics[type].slice(-100);
        if (recent.length < 10) return;

        const avg = this.average(recent.map(m => m.value));
        const std = this.stdDev(recent.map(m => m.value));

        if (Math.abs(value - avg) > 3 * std) {
            this.raiseAlert({
                type: 'anomaly',
                metric: type,
                value: value,
                expected: avg,
                timestamp: Date.now()
            });
        }
    }

    getStatistics(type, duration = 60000) {
        const cutoff = Date.now() - duration;
        const recent = this.metrics[type].filter(m => m.timestamp > cutoff);

        if (recent.length === 0) return null;

        const values = recent.map(m => m.value);

        return {
            count: values.length,
            mean: this.average(values),
            median: this.median(values),
            min: Math.min(...values),
            max: Math.max(...values),
            stdDev: this.stdDev(values),
            p95: this.percentile(values, 95),
            p99: this.percentile(values, 99)
        };
    }

    average(arr) {
        return arr.reduce((sum, v) => sum + v, 0) / arr.length;
    }

    median(arr) {
        const sorted = [...arr].sort((a, b) => a - b);
        const mid = Math.floor(sorted.length / 2);
        return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
    }

    stdDev(arr) {
        const avg = this.average(arr);
        const squareDiffs = arr.map(v => Math.pow(v - avg, 2));
        return Math.sqrt(this.average(squareDiffs));
    }

    percentile(arr, p) {
        const sorted = [...arr].sort((a, b) => a - b);
        const index = Math.ceil((p / 100) * sorted.length) - 1;
        return sorted[Math.max(0, index)];
    }

    raiseAlert(alert) {
        this.alerts.push(alert);
        console.warn(`ALERT: ${alert.type} - ${alert.metric}: ${alert.value}`);
    }
}

// 弘益人間: Monitoring ensuring reliable service for all