// Agent initialization with Claude Code and MCP
export class ClaudeCodeAgent {
  private agentType: string;
  private workingDir: string;
  private mcpClient: MCPClient;
  private mcpServer: MCPServer;
  private process: ChildProcess;
  
  constructor(config: AgentConfig) {
    this.agentType = config.agentType;
    this.workingDir = config.workingDir;
  }
  
  async start(): Promise<void> {
    // Start Claude Code in headless mode
    this.process = spawn('cc', ['-p', this.workingDir], {
      detached: true,
      stdio: ['pipe', 'pipe', 'pipe']
    });
    
    // Initialize MCP client
    this.mcpClient = new MCPClient({
      serverUrl: process.env.MCP_SERVER_URL,
      agentId: `${this.agentType}-agent`
    });
    
    // Initialize MCP server for this agent
    this.mcpServer = new MCPServer({
      port: this.getAgentPort(),
      capabilities: this.getAgentCapabilities()
    });
    
    // Start both MCP components
    await Promise.all([
      this.mcpClient.connect(),
      this.mcpServer.start()
    ]);
    
    // Monitor Claude Code output
    this.monitorProcess();
    
    // Monitor Agent_Output.md
    this.monitorAgentOutput();
  }
  
  private monitorAgentOutput(): void {
    const outputPath = path.join(this.workingDir, 'Agent_Output.md');
    
    fs.watch(outputPath, async (eventType) => {
      if (eventType === 'change') {
        const content = await fs.readFile(outputPath, 'utf-8');
        
        // Broadcast status update via MCP
        await this.mcpClient.broadcast({
          type: 'STATUS_UPDATE',
          agentType: this.agentType,
          content: content,
          timestamp: new Date()
        });
        
        // Sync to shared directory
        await this.syncToShared(content);
      }
    });
  }
}

export class ClaudeCodeManager {
  private agents: Map<string, ClaudeCodeProcess>;
  
  async startAgent(agentType: string): Promise<void> {
    const config = this.loadAgentConfig(agentType);
    const workingDir = `./agents/${agentType}-agent`;
    
    // Ensure CLAUDE.md exists
    if (!fs.existsSync(path.join(workingDir, 'CLAUDE.md'))) {
      throw new Error(`CLAUDE.md not found for ${agentType} agent`);
    }
    
    // Start Claude Code process
    const process = spawn('cc', [
      '-p', workingDir,
      '--headless',
      '--max-tokens', config.maxTokens.toString(),
      '--timeout', config.timeout.toString()
    ], {
      detached: true,
      env: {
        ...process.env,
        AGENT_TYPE: agentType,
        MCP_SERVER_URL: process.env.MCP_SERVER_URL
      }
    });
    
    // Store process reference
    this.agents.set(agentType, {
      process,
      startTime: new Date(),
      config,
      status: 'running'
    });
    
    // Set up monitoring
    this.monitorAgent(agentType, process);
  }
  
  async stopAgent(agentType: string): Promise<void> {
    const agent = this.agents.get(agentType);
    if (!agent) {
      throw new Error(`Agent ${agentType} not found`);
    }
    
    // Graceful shutdown
    agent.process.kill('SIGTERM');
    
    // Wait for process to exit
    await new Promise<void>((resolve) => {
      agent.process.on('exit', () => {
        this.agents.delete(agentType);
        resolve();
      });
      
      // Force kill after timeout
      setTimeout(() => {
        agent.process.kill('SIGKILL');
        resolve();
      }, 30000);
    });
  }
  
  async restartAgent(agentType: string): Promise<void> {
    await this.stopAgent(agentType);
    await this.startAgent(agentType);
  }
}

interface AgentHealth {
  agentType: string;
  status: 'healthy' | 'degraded' | 'unhealthy';
  uptime: number;
  lastUpdate: Date;
  metrics: {
    cpuUsage: number;
    memoryUsage: number;
    taskCompletionRate: number;
    errorRate: number;
  };
}

export class HealthMonitor {
  async checkAgentHealth(agentType: string): Promise<AgentHealth> {
    const agent = this.agents.get(agentType);
    if (!agent) {
      return {
        agentType,
        status: 'unhealthy',
        uptime: 0,
        lastUpdate: new Date(),
        metrics: null
      };
    }
    
    // Check process health
    const processHealth = await this.checkProcessHealth(agent.process.pid);
    
    // Check Agent_Output.md freshness
    const outputPath = `./agents/${agentType}-agent/Agent_Output.md`;
    const stats = await fs.stat(outputPath);
    const lastUpdateAge = Date.now() - stats.mtime.getTime();
    
    // Determine health status
    let status: 'healthy' | 'degraded' | 'unhealthy';
    if (processHealth.running && lastUpdateAge < 120000) { // 2 minutes
      status = 'healthy';
    } else if (processHealth.running) {
      status = 'degraded';
    } else {
      status = 'unhealthy';
    }
    
    return {
      agentType,
      status,
      uptime: Date.now() - agent.startTime.getTime(),
      lastUpdate: stats.mtime,
      metrics: {
        cpuUsage: processHealth.cpu,
        memoryUsage: processHealth.memory,
        taskCompletionRate: await this.getTaskCompletionRate(agentType),
        errorRate: await this.getErrorRate(agentType)
      }
    };
  }
}