Task Allocation and Planning

class RoundRobinAllocator {
    constructor(agents) {
        this.agents = agents;
        this.currentIndex = 0;
    }

    allocate(task) {
        const agent = this.agents[this.currentIndex];
        this.currentIndex = (this.currentIndex + 1) % this.agents.length;

        return {
            task: task,
            assignedAgent: agent.id,
            timestamp: Date.now()
        };
    }

    allocateBatch(tasks) {
        return tasks.map(task => this.allocate(task));
    }
}

// Simple but may not balance workload effectively
// 弘益人間: Equal distribution for fairness

class CapabilityBasedAllocator {
    constructor(agents) {
        this.agents = agents;
        this.capabilityMatrix = this.buildCapabilityMatrix();
    }

    buildCapabilityMatrix() {
        const matrix = new Map();

        for (const agent of this.agents) {
            matrix.set(agent.id, {
                skills: agent.getSkills(),
                performance: agent.getPerformanceMetrics(),
                availability: agent.isAvailable()
            });
        }

        return matrix;
    }

    allocate(task) {
        let bestAgent = null;
        let bestScore = -Infinity;

        for (const agent of this.agents) {
            const capabilities = this.capabilityMatrix.get(agent.id);

            if (!capabilities.availability) continue;

            const score = this.calculateMatchScore(task, capabilities);

            if (score > bestScore) {
                bestScore = score;
                bestAgent = agent;
            }
        }

        return {
            task: task,
            assignedAgent: bestAgent?.id || null,
            matchScore: bestScore,
            timestamp: Date.now()
        };
    }

    calculateMatchScore(task, capabilities) {
        const requiredSkills = task.requiredSkills || [];
        const agentSkills = capabilities.skills;

        // Calculate skill match percentage
        const matchedSkills = requiredSkills.filter(
            skill => agentSkills.includes(skill)
        ).length;

        const skillScore = matchedSkills / requiredSkills.length;

        // Factor in agent performance
        const performanceScore = capabilities.performance.averageQuality;

        // Weighted combination
        return skillScore * 0.7 + performanceScore * 0.3;
    }
}

// 弘益人間: Matching tasks to expertise for optimal outcomes

class LoadBalancedAllocator {
    constructor(agents) {
        this.agents = agents;
        this.workload = new Map();

        // Initialize workload tracking
        agents.forEach(agent => this.workload.set(agent.id, 0));
    }

    allocate(task) {
        // Find agent with least current workload
        let minWorkload = Infinity;
        let leastLoadedAgent = null;

        for (const agent of this.agents) {
            const currentLoad = this.workload.get(agent.id);

            if (agent.canPerform(task) && currentLoad < minWorkload) {
                minWorkload = currentLoad;
                leastLoadedAgent = agent;
            }
        }

        if (leastLoadedAgent) {
            // Update workload
            const estimatedEffort = task.estimatedDuration || 1;
            this.workload.set(
                leastLoadedAgent.id,
                this.workload.get(leastLoadedAgent.id) + estimatedEffort
            );
        }

        return {
            task: task,
            assignedAgent: leastLoadedAgent?.id || null,
            currentWorkload: minWorkload,
            timestamp: Date.now()
        };
    }

    // Called when agent completes a task
    taskCompleted(agentId, task) {
        const currentLoad = this.workload.get(agentId);
        const effort = task.actualDuration || task.estimatedDuration || 1;
        this.workload.set(agentId, Math.max(0, currentLoad - effort));
    }

    getWorkloadBalance() {
        const loads = Array.from(this.workload.values());
        const avg = loads.reduce((sum, load) => sum + load, 0) / loads.length;
        const variance = loads.reduce(
            (sum, load) => sum + Math.pow(load - avg, 2),
            0
        ) / loads.length;

        return {
            average: avg,
            variance: variance,
            standardDeviation: Math.sqrt(variance)
        };
    }
}

// 弘益人間: Fair workload distribution benefiting all agents

class CoalitionFormation {
    constructor(agents, tasks) {
        this.agents = agents;
        this.tasks = tasks;
    }

    // Form coalitions for tasks requiring multiple agents
    formCoalitions() {
        const coalitions = [];

        for (const task of this.tasks) {
            if (task.requiredAgents > 1) {
                const coalition = this.findBestCoalition(task);
                if (coalition) {
                    coalitions.push({
                        task: task,
                        members: coalition.members,
                        value: coalition.value
                    });
                }
            } else {
                // Single agent task
                const agent = this.findBestAgent(task);
                if (agent) {
                    coalitions.push({
                        task: task,
                        members: [agent],
                        value: this.calculateValue(task, [agent])
                    });
                }
            }
        }

        return coalitions;
    }

    findBestCoalition(task) {
        const requiredSize = task.requiredAgents;
        const candidates = this.generateCombinations(this.agents, requiredSize);

        let bestCoalition = null;
        let bestValue = -Infinity;

        for (const coalition of candidates) {
            // Check if coalition can perform task
            if (!this.canPerformTask(coalition, task)) continue;

            const value = this.calculateCoalitionValue(coalition, task);

            if (value > bestValue) {
                bestValue = value;
                bestCoalition = coalition;
            }
        }

        return bestCoalition ? {
            members: bestCoalition,
            value: bestValue
        } : null;
    }

    canPerformTask(coalition, task) {
        const combinedSkills = new Set();
        coalition.forEach(agent => {
            agent.getSkills().forEach(skill => combinedSkills.add(skill));
        });

        return task.requiredSkills.every(skill => combinedSkills.has(skill));
    }

    calculateCoalitionValue(coalition, task) {
        // Value = task reward - coalition cost
        const reward = task.reward || 100;
        const cost = coalition.reduce(
            (sum, agent) => sum + agent.getCost(task),
            0
        );

        // Bonus for complementary skills
        const synergyBonus = this.calculateSynergy(coalition, task);

        return reward - cost + synergyBonus;
    }

    calculateSynergy(coalition, task) {
        // Agents with complementary skills work better together
        const skillCoverage = new Set();
        coalition.forEach(agent => {
            agent.getSkills().forEach(skill => skillCoverage.add(skill));
        });

        const coverageRatio = skillCoverage.size / coalition.length;
        return coverageRatio * 20; // Synergy bonus
    }
}

// 弘益人間: Collaborative teams for complex challenges

class DynamicTaskAllocator {
    constructor(agents) {
        this.agents = agents;
        this.taskQueue = [];
        this.allocations = new Map();
        this.running = false;
    }

    start() {
        this.running = true;
        this.allocationLoop();
    }

    stop() {
        this.running = false;
    }

    addTask(task) {
        task.arrivalTime = Date.now();
        task.priority = task.priority || 0;

        // Insert in priority order
        const index = this.taskQueue.findIndex(t => t.priority < task.priority);
        if (index === -1) {
            this.taskQueue.push(task);
        } else {
            this.taskQueue.splice(index, 0, task);
        }
    }

    async allocationLoop() {
        while (this.running) {
            if (this.taskQueue.length > 0) {
                const task = this.taskQueue.shift();
                await this.allocateTask(task);
            }

            // Check for task completions and reallocation needs
            await this.checkCompletions();
            await this.considerReallocation();

            await this.sleep(100); // Check every 100ms
        }
    }

    async allocateTask(task) {
        // Find best available agent
        const availableAgents = this.agents.filter(a => a.isIdle());

        if (availableAgents.length === 0) {
            // No agents available, put back in queue
            this.taskQueue.unshift(task);
            return;
        }

        const bestAgent = this.selectBestAgent(availableAgents, task);

        // Assign task
        this.allocations.set(task.id, {
            task: task,
            agent: bestAgent,
            startTime: Date.now(),
            status: 'in-progress'
        });

        await bestAgent.executeTask(task);
    }

    async considerReallocation() {
        // Consider reallocating tasks if better options become available
        for (const [taskId, allocation] of this.allocations) {
            if (allocation.status !== 'in-progress') continue;

            const currentAgent = allocation.agent;
            const idleAgents = this.agents.filter(
                a => a.isIdle() && a.id !== currentAgent.id
            );

            for (const agent of idleAgents) {
                if (this.shouldReallocate(allocation, agent)) {
                    await this.reallocate(allocation, agent);
                    break;
                }
            }
        }
    }

    shouldReallocate(allocation, newAgent) {
        const task = allocation.task;
        const currentAgent = allocation.agent;

        // Only reallocate if significant benefit
        const currentScore = this.scoreAssignment(currentAgent, task);
        const newScore = this.scoreAssignment(newAgent, task);

        return newScore > currentScore * 1.5; // 50% improvement threshold
    }

    async reallocate(allocation, newAgent) {
        const task = allocation.task;
        const oldAgent = allocation.agent;

        // Preempt current execution
        await oldAgent.cancelTask(task);

        // Reassign to new agent
        allocation.agent = newAgent;
        allocation.startTime = Date.now();

        await newAgent.executeTask(task);
    }
}

// 弘益人間: Adaptive allocation for changing conditions

class CentralizedPlanner {
    constructor(agents, goals) {
        this.agents = agents;
        this.goals = goals;
    }

    createPlan() {
        // Generate global plan for all agents
        const plan = {
            agents: new Map(),
            schedule: [],
            dependencies: []
        };

        // Decompose goals into tasks
        const tasks = this.decomposeGoals(this.goals);

        // Allocate tasks to agents
        for (const task of tasks) {
            const agent = this.selectAgent(task);
            if (!plan.agents.has(agent.id)) {
                plan.agents.set(agent.id, []);
            }
            plan.agents.get(agent.id).push(task);
        }

        // Create schedule respecting dependencies
        plan.schedule = this.createSchedule(tasks);

        return plan;
    }

    decomposeGoals(goals) {
        const tasks = [];

        for (const goal of goals) {
            const subtasks = this.decomposeGoal(goal);
            tasks.push(...subtasks);
        }

        return tasks;
    }

    decomposeGoal(goal) {
        // Hierarchical task decomposition
        if (goal.isPrimitive) {
            return [goal];
        }

        const subtasks = [];
        for (const method of goal.methods) {
            if (this.isApplicable(method, goal)) {
                subtasks.push(...method.subtasks);
                break;
            }
        }

        // Recursively decompose
        return subtasks.flatMap(task =>
            task.isPrimitive ? [task] : this.decomposeGoal(task)
        );
    }

    createSchedule(tasks) {
        // Topological sort respecting dependencies
        const schedule = [];
        const completed = new Set();
        const remaining = [...tasks];

        while (remaining.length > 0) {
            const ready = remaining.filter(task =>
                task.dependencies.every(dep => completed.has(dep))
            );

            if (ready.length === 0) {
                throw new Error('Circular dependencies detected');
            }

            // Schedule ready tasks
            for (const task of ready) {
                schedule.push({
                    task: task,
                    earliestStart: this.calculateEarliestStart(task, schedule)
                });
                completed.add(task.id);
            }

            // Remove from remaining
            remaining.splice(0, remaining.length,
                ...remaining.filter(t => !completed.has(t.id))
            );
        }

        return schedule;
    }
}

// 弘益人間: Coordinated planning for shared goals

class DistributedPlanningAgent {
    constructor(id, goals) {
        this.id = id;
        this.goals = goals;
        this.plan = [];
        this.commitments = [];
    }

    async createPlan() {
        // Each agent plans independently
        this.plan = this.generateLocalPlan(this.goals);

        // Share plan with neighbors
        await this.sharePlan();

        // Coordinate and resolve conflicts
        await this.coordinatePlans();

        return this.plan;
    }

    generateLocalPlan(goals) {
        // Use A* or similar planner
        const plan = [];

        for (const goal of goals) {
            const actions = this.planForGoal(goal);
            plan.push(...actions);
        }

        return this.optimizePlan(plan);
    }

    async sharePlan() {
        for (const neighbor of this.neighbors) {
            await neighbor.receivePlan({
                agentId: this.id,
                plan: this.plan,
                resources: this.getRequiredResources()
            });
        }
    }

    async coordinatePlans() {
        // Iteratively refine plan through negotiation
        let conflicts = await this.detectConflicts();

        while (conflicts.length > 0) {
            for (const conflict of conflicts) {
                await this.resolveConflict(conflict);
            }

            conflicts = await this.detectConflicts();
        }
    }

    async resolveConflict(conflict) {
        if (conflict.type === 'resource') {
            // Negotiate resource usage time
            await this.negotiateResourceSchedule(conflict);
        } else if (conflict.type === 'ordering') {
            // Determine action ordering
            await this.negotiateOrdering(conflict);
        }
    }
}

// 弘益人間: Distributed planning empowering autonomous agents

class TaskScheduler {
    constructor() {
        this.schedule = [];
        this.resources = new Map();
    }

    // Earliest Deadline First (EDF) scheduling
    scheduleEDF(tasks) {
        const sorted = tasks.sort((a, b) => a.deadline - b.deadline);

        for (const task of sorted) {
            const slot = this.findEarliestSlot(task);
            if (slot) {
                this.schedule.push({
                    task: task,
                    startTime: slot.start,
                    endTime: slot.end
                });
            }
        }

        return this.schedule;
    }

    // Priority-based scheduling
    schedulePriority(tasks) {
        const sorted = tasks.sort((a, b) => b.priority - a.priority);

        for (const task of sorted) {
            const slot = this.findEarliestSlot(task);
            if (slot) {
                this.schedule.push({
                    task: task,
                    startTime: slot.start,
                    endTime: slot.end
                });
            }
        }

        return this.schedule;
    }

    findEarliestSlot(task) {
        const duration = task.duration;
        let currentTime = Date.now();

        while (currentTime < task.deadline) {
            if (this.isSlotAvailable(currentTime, duration, task.resources)) {
                return {
                    start: currentTime,
                    end: currentTime + duration
                };
            }
            currentTime += 1000; // Check every second
        }

        return null; // No slot found before deadline
    }

    isSlotAvailable(startTime, duration, requiredResources) {
        const endTime = startTime + duration;

        // Check if required resources are available
        for (const [resource, amount] of Object.entries(requiredResources)) {
            if (!this.checkResourceAvailability(resource, amount, startTime, endTime)) {
                return false;
            }
        }

        return true;
    }
}

// 弘益人間: Efficient scheduling maximizing collective productivity