// src/swarm/memory-manager-sdk.ts
export class MemoryManagerSDK {
  private sessions: Map<string, SDKMessage[]> = new Map();

  async saveSwarmState(swarmId: string, state: SwarmState): Promise<void> {
    // Convert swarm state to SDKMessage format
    const messages: SDKMessage[] = [
      {
        type: 'system',
        subtype: 'init',
        uuid: randomUUID(),
        session_id: swarmId,
        tools: state.activeTools,
        model: state.model,
        // ... swarm metadata
      },
      ...this.convertStateToMessages(state)
    ];

    // Store as session history
    this.sessions.set(swarmId, messages);
  }

  async restoreSwarmState(
    swarmId: string,
    messageId?: string
  ): Promise<SwarmState> {
    // Use SDK's resumeSessionAt for point-in-time recovery
    const stream = query({
      prompt: 'Restore swarm state from session history',
      options: {
        resume: swarmId,
        resumeSessionAt: messageId  // Optional: specific message
      }
    });

    // Extract swarm state from resumed session
    return this.extractSwarmState(stream);
  }

  private convertStateToMessages(state: SwarmState): SDKMessage[] {
    // Convert agents, tasks, results to SDKMessage format
    return state.agents.map(agent => ({
      type: 'assistant',
      uuid: randomUUID(),
      session_id: state.swarmId,
      message: {
        id: agent.id,
        role: 'assistant',
        content: JSON.stringify(agent.state)
      },
      parent_tool_use_id: null
    }));
  }
}

// src/swarm/parallel-executor-sdk.ts
export class ParallelSwarmExecutor {
  async spawnParallelAgents(task: Task, count: number): Promise<Agent[]> {
    // Create base session with shared context
    const baseSession = await this.createBaseSession(task);

    // Fork N sessions for parallel execution
    const agents = await Promise.all(
      Array.from({ length: count }, async (_, index) => {
        const stream = query({
          prompt: this.getAgentPrompt(task, index),
          options: {
            resume: baseSession.id,
            forkSession: true,  // Key: instant fork!
            mcpServers: {
              'claude-flow-swarm': claudeFlowSwarmServer
            }
          }
        });

        return this.monitorAgentStream(stream, index);
      })
    );

    return agents;
  }
}

// src/verification/checkpoint-manager-sdk.ts
export class CheckpointManagerSDK {
  async monitorForCheckpoints(swarmId: string): Promise<void> {
    const stream = this.getSwarmStream(swarmId);

    for await (const message of stream) {
      if (message.type === 'system' && message.subtype === 'compact_boundary') {
        // SDK automatically compacts context - use as checkpoint!
        await this.createSwarmCheckpoint(swarmId, {
          trigger: message.compact_metadata.trigger,  // 'auto' | 'manual'
          tokensBeforeCompact: message.compact_metadata.pre_tokens,
          messageId: message.uuid,
          timestamp: Date.now()
        });
      }
    }
  }

  async restoreFromCompactBoundary(
    swarmId: string,
    checkpointId: string
  ): Promise<SwarmState> {
    // Use resumeSessionAt to restore from compact boundary
    const stream = query({
      prompt: 'Restore swarm state',
      options: {
        resume: swarmId,
        resumeSessionAt: checkpointId  // Point to compact boundary message
      }
    });

    // Swarm state automatically restored to that point!
    return this.extractSwarmState(stream);
  }
}

// src/swarm/dynamic-agent-controller.ts
export class DynamicAgentController {
  private activeStreams: Map<string, Query> = new Map();

  async killRunawayAgent(agentId: string): Promise<void> {
    const stream = this.activeStreams.get(agentId);
    if (stream) {
      // Interrupt execution immediately
      await stream.interrupt();
      console.log(`⚠️  Agent ${agentId} interrupted`);
    }
  }

  async switchAgentModel(agentId: string, model: string): Promise<void> {
    const stream = this.activeStreams.get(agentId);
    if (stream) {
      // Switch model on-the-fly (no restart!)
      await stream.setModel(model);
      console.log(`🔄 Agent ${agentId} now using ${model}`);
    }
  }

  async relaxPermissions(agentId: string): Promise<void> {
    const stream = this.activeStreams.get(agentId);
    if (stream) {
      // Switch to auto-accept mode
      await stream.setPermissionMode('acceptEdits');
      console.log(`🔓 Agent ${agentId} permissions relaxed`);
    }
  }

  async tightenPermissions(agentId: string): Promise<void> {
    const stream = this.activeStreams.get(agentId);
    if (stream) {
      // Switch to manual approval
      await stream.setPermissionMode('default');
      console.log(`🔒 Agent ${agentId} permissions tightened`);
    }
  }
}

// src/services/hook-manager-sdk.ts
const hooks: Partial<Record<HookEvent, HookCallbackMatcher[]>> = {
  PreToolUse: [
    {
      matcher: 'Bash\\(.*\\)',  // Regex: only Bash commands
      hooks: [async (input, toolUseID, { signal }) => {
        // Swarm-level governance for Bash
        const allowed = await this.validateBashCommand(
          input.tool_input.command
        );

        return {
          decision: allowed ? 'approve' : 'block',
          hookSpecificOutput: {
            hookEventName: 'PreToolUse',
            permissionDecision: allowed ? 'allow' : 'deny',
            permissionDecisionReason: allowed
              ? 'Command approved by swarm policy'
              : 'Dangerous command blocked'
          }
        };
      }]
    },
    {
      matcher: 'agent_spawn',  // Only for agent spawning
      hooks: [async (input, toolUseID, { signal }) => {
        // Track agent spawning for swarm coordination
        await this.recordAgentSpawn(input.tool_input);
        return { continue: true };
      }]
    },
    {
      matcher: 'FileWrite\\(.*\\.env.*\\)',  // Block .env writes
      hooks: [async (input) => {
        return {
          decision: 'block',
          reason: 'Writing to .env files is not allowed'
        };
      }]
    }
  ],

  PostToolUse: [
    {
      matcher: 'memory_.*',  // All memory operations
      hooks: [async (input, toolUseID, { signal }) => {
        // Replicate memory operations across swarm
        await this.replicateMemoryOperation(input);
        return { continue: true };
      }]
    },
    {
      matcher: '.*',  // All operations (audit logging)
      hooks: [async (input) => {
        await this.logToolExecution(input);
        return { continue: true };
      }]
    }
  ],

  SessionEnd: [
    {
      hooks: [async (input, toolUseID, { signal }) => {
        // Aggregate swarm metrics on session end
        await this.aggregateSwarmMetrics(input.session_id);
        return { continue: true };
      }]
    }
  ]
};

// src/security/swarm-permission-manager.ts
export class SwarmPermissionManager {
  async configurePermissionHierarchy() {
    // Level 1: User-level (~/.claude/settings.json)
    // Most restrictive - applies to all projects
    await this.updatePermissions({
      type: 'addRules',
      rules: [
        { toolName: 'Bash', ruleContent: 'rm -rf *' },
        { toolName: 'Bash', ruleContent: 'sudo *' },
        { toolName: 'FileWrite', ruleContent: '/etc/*' }
      ],
      behavior: 'deny',
      destination: 'userSettings'
    });

    // Level 2: Project-level (.claude/settings.json)
    // Project-specific policies (checked into git)
    await this.updatePermissions({
      type: 'addRules',
      rules: [
        { toolName: 'FileWrite', ruleContent: './src/*' },
        { toolName: 'FileRead', ruleContent: './src/*' },
        { toolName: 'Bash', ruleContent: 'npm *' }
      ],
      behavior: 'allow',
      destination: 'projectSettings'
    });

    // Level 3: Local-level (.claude-local.json)
    // Developer-specific overrides (gitignored)
    await this.updatePermissions({
      type: 'addRules',
      rules: [
        { toolName: 'Bash', ruleContent: 'npm install *' },
        { toolName: 'FileWrite', ruleContent: './.env.local' }
      ],
      behavior: 'allow',
      destination: 'localSettings'
    });

    // Level 4: Session-level
    // Current session only (most permissive for swarm)
    await this.updatePermissions({
      type: 'addRules',
      rules: [
        { toolName: 'agent_spawn' },
        { toolName: 'swarm_init' },
        { toolName: 'task_orchestrate' }
      ],
      behavior: 'allow',
      destination: 'session'
    });
  }

  async getEffectivePermission(toolName: string, input: any): Promise<PermissionBehavior> {
    // Check hierarchy: user → project → local → session
    // First "deny" wins, last "allow" wins if no deny

    const userPerm = await this.checkLevel('userSettings', toolName, input);
    if (userPerm === 'deny') return 'deny';

    const projectPerm = await this.checkLevel('projectSettings', toolName, input);
    if (projectPerm === 'deny') return 'deny';

    const localPerm = await this.checkLevel('localSettings', toolName, input);
    if (localPerm === 'deny') return 'deny';

    const sessionPerm = await this.checkLevel('session', toolName, input);
    if (sessionPerm === 'allow') return 'allow';

    // Default to ask
    return 'ask';
  }
}

// src/mcp/claude-flow-swarm-server.ts
import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code/sdk';
import { z } from 'zod';
import { SwarmCoordinator } from '../swarm/coordinator';
import { SwarmMemory } from '../swarm/memory';

export const claudeFlowSwarmServer = createSdkMcpServer({
  name: 'claude-flow-swarm',
  version: '2.5.0-alpha.130',
  tools: [
    // Swarm Initialization
    tool('swarm_init', 'Initialize multi-agent swarm', {
      topology: z.enum(['mesh', 'hierarchical', 'ring', 'star']),
      maxAgents: z.number().min(1).max(100),
      strategy: z.enum(['balanced', 'specialized', 'adaptive']).optional()
    }, async (args) => {
      // Direct function call - ZERO IPC overhead!
      const swarm = await SwarmCoordinator.initialize(args);
      return {
        content: [{
          type: 'text',
          text: JSON.stringify(swarm.status)
        }]
      };
    }),

    // Agent Spawning - <0.1ms latency
    tool('agent_spawn', 'Spawn specialized agent', {
      type: z.enum(['researcher', 'coder', 'analyst', 'optimizer', 'coordinator']),
      capabilities: z.array(z.string()).optional(),
      swarmId: z.string().optional()
    }, async (args) => {
      // <0.1ms vs 2-5ms with stdio!
      const agent = await SwarmCoordinator.spawnAgent(args);
      return {
        content: [{
          type: 'text',
          text: JSON.stringify(agent)
        }]
      };
    }),

    // Task Orchestration - in-process
    tool('task_orchestrate', 'Orchestrate task across swarm', {
      task: z.string(),
      strategy: z.enum(['parallel', 'sequential', 'adaptive']).optional(),
      priority: z.enum(['low', 'medium', 'high', 'critical']).optional()
    }, async (args) => {
      const result = await SwarmCoordinator.orchestrateTask(args);
      return {
        content: [{
          type: 'text',
          text: JSON.stringify(result)
        }]
      };
    }),

    // Memory Operations - <1ms latency
    tool('memory_store', 'Store data in swarm memory', {
      key: z.string(),
      value: z.any(),
      namespace: z.string().optional(),
      ttl: z.number().optional()
    }, async (args) => {
      await SwarmMemory.store(args.key, args.value, {
        namespace: args.namespace,
        ttl: args.ttl
      });
      return {
        content: [{ type: 'text', text: 'Stored successfully' }]
      };
    }),

    tool('memory_retrieve', 'Retrieve data from swarm memory', {
      key: z.string(),
      namespace: z.string().optional()
    }, async (args) => {
      const value = await SwarmMemory.retrieve(args.key, args.namespace);
      return {
        content: [{
          type: 'text',
          text: JSON.stringify(value)
        }]
      };
    }),

    // ... 40+ more tools with ZERO IPC overhead
  ]
});

// Usage in swarm coordinator
export class SwarmCoordinator {
  async initialize() {
    const response = await query({
      prompt: 'Initialize swarm with mesh topology and 5 agents',
      options: {
        mcpServers: {
          'claude-flow-swarm': {
            type: 'sdk',  // In-process!
            name: 'claude-flow-swarm',
            instance: claudeFlowSwarmServer.instance
          }
        }
      }
    });

    // Parse response and configure swarm
    return this.parseSwarmInitResponse(response);
  }
}

// src/monitoring/mcp-health-monitor.ts
export class McpHealthMonitor {
  async monitorSwarmServers(swarmId: string): Promise<void> {
    const stream = this.activeStreams.get(swarmId);
    if (!stream) return;

    setInterval(async () => {
      const status = await stream.mcpServerStatus();

      for (const server of status) {
        if (server.status === 'failed') {
          console.error(`❌ MCP server ${server.name} failed`);
          await this.handleServerFailure(swarmId, server);
        } else if (server.status === 'needs-auth') {
          console.warn(`⚠️  MCP server ${server.name} needs auth`);
          await this.handleAuthRequired(swarmId, server);
        } else if (server.status === 'connected') {
          console.log(`✅ MCP server ${server.name} healthy`);
        }
      }
    }, 5000);  // Check every 5s
  }

  private async handleServerFailure(
    swarmId: string,
    server: McpServerStatus
  ): Promise<void> {
    // Attempt recovery
    console.log(`🔄 Attempting to restart ${server.name}...`);
    await this.restartMcpServer(server.name);

    // Notify swarm coordinator
    await SwarmCoordinator.notifyServerFailure(swarmId, server);
  }
}