/**
 * Loop V2 Routes Module
 * CCW Loop System - Simplified HTTP API endpoints for Dashboard
 * Provides simplified loop CRUD operations independent of task files
 *
 * Loop Endpoints:
 * - GET    /api/loops/v2                   - List all loops with pagination
 * - POST   /api/loops/v2                   - Create loop with {title, description, max_iterations}
 * - GET    /api/loops/v2/:loopId           - Get loop details
 * - PUT    /api/loops/v2/:loopId           - Update loop metadata (title, description, max_iterations, tags, priority, notes)
 * - PATCH  /api/loops/v2/:loopId/status    - Quick status update with {status}
 * - DELETE /api/loops/v2/:loopId           - Delete loop
 * - POST   /api/loops/v2/:loopId/start     - Start loop execution
 * - POST   /api/loops/v2/:loopId/pause     - Pause loop
 * - POST   /api/loops/v2/:loopId/resume    - Resume loop
 * - POST   /api/loops/v2/:loopId/stop      - Stop loop
 *
 * Task Management Endpoints:
 * - POST   /api/loops/v2/:loopId/tasks           - Add task to loop
 * - GET    /api/loops/v2/:loopId/tasks           - List all tasks for loop
 * - PUT    /api/loops/v2/tasks/:taskId           - Update task (requires loop_id in body)
 * - DELETE /api/loops/v2/tasks/:taskId           - Delete task (requires loop_id query param)
 * - PUT    /api/loops/v2/:loopId/tasks/reorder   - Reorder tasks with {ordered_task_ids: string[]}
 *
 * Advanced Task Features:
 * - POST   /api/loops/v2/:loopId/import   - Import tasks from issue with {issue_id}
 * - POST   /api/loops/v2/:loopId/generate - Generate tasks via Gemini with {tool?, count?}
 */

import { join } from 'path';
import { randomBytes } from 'crypto';
import * as os from 'os';
import type { RouteContext } from './types.js';
import { LoopStatus } from '../../types/loop.js';
import type { LoopState } from '../../types/loop.js';
import { TaskStorageManager, type TaskCreateRequest, type TaskUpdateRequest, type TaskReorderRequest } from '../../tools/loop-task-manager.js';
import { executeCliTool } from '../../tools/cli-executor.js';
import { loadClaudeCliTools } from '../../tools/claude-cli-tools.js';

/**
 * Module-level cache for CLI tools configuration
 * Loaded once at server startup to avoid repeated file I/O
 */
let cachedEnabledTools: string[] | null = null;

/**
 * Initialize CLI tools cache at server startup
 * Should be called once when the server starts
 */
export function initializeCliToolsCache(): void {
  try {
    const cliToolsConfig = loadClaudeCliTools(os.homedir());
    const enabledTools = Object.entries(cliToolsConfig.tools || {})
      .filter(([_, config]) => config.enabled === true)
      .map(([name]) => name);
    cachedEnabledTools = ['bash', ...enabledTools];
    console.log('[Loop V2] CLI tools cache initialized:', cachedEnabledTools);
  } catch (err) {
    console.error('[Loop V2] Failed to initialize CLI tools cache:', err);
    // Fallback to basic tools if config loading fails
    cachedEnabledTools = ['bash', 'gemini', 'qwen', 'codex', 'claude'];
  }
}

/**
 * Clear CLI tools cache (for testing or config reload)
 */
export function clearCliToolsCache(): void {
  cachedEnabledTools = null;
}

/**
 * V2 Loop Create Request
 */
interface V2LoopCreateRequest {
  title: string;
  description?: string;
  max_iterations?: number;
}

/**
 * V2 Loop Update Request (extended)
 */
interface V2LoopUpdateRequest {
  // Basic fields
  title?: string;
  description?: string;
  max_iterations?: number;

  // Extended metadata fields
  tags?: string[];
  priority?: 'low' | 'medium' | 'high';
  notes?: string;
}

/**
 * V2 Loop Storage Format (simplified, independent of task files)
 */
interface V2LoopStorage {
  loop_id: string;
  title: string;
  description: string;
  max_iterations: number;
  status: LoopStatus;
  current_iteration: number;
  created_at: string;
  updated_at: string;
  completed_at?: string;
  failure_reason?: string;

  // Extended metadata fields
  tags?: string[];
  priority?: 'low' | 'medium' | 'high';
  notes?: string;

  // Tasks stored in separate tasks.jsonl file
}

/**
 * Handle V2 loop routes
 * @returns true if route was handled, false otherwise
 */
export async function handleLoopV2Routes(ctx: RouteContext): Promise<boolean> {
  const { pathname, req, res, initialPath, handlePostRequest, url, broadcastToClients } = ctx;

  // Get workflow directory from initialPath
  const workflowDir = initialPath || process.cwd();
  const loopDir = join(workflowDir, '.workflow', '.loop');

  // Helper to broadcast loop state updates
  const broadcastStateUpdate = (loopId: string, status: LoopStatus): void => {
    try {
      broadcastToClients({
        type: 'LOOP_STATE_UPDATE',
        loop_id: loopId,
        status: status as 'created' | 'running' | 'paused' | 'completed' | 'failed',
        updated_at: new Date().toISOString()
      });
    } catch (error) {
      // Silently ignore broadcast errors
    }
  };

  // Helper to generate loop ID
  const generateLoopId = (): string => {
    const timestamp = new Date().toISOString().replace(/[-:]/g, '').split('.')[0];
    const random = randomBytes(4).toString('hex');
    return `loop-v2-${timestamp}-${random}`;
  };

  // Helper to read loop storage
  const readLoopStorage = async (loopId: string): Promise<V2LoopStorage | null> => {
    const { readFile } = await import('fs/promises');
    const { existsSync } = await import('fs');
    const filePath = join(loopDir, `${loopId}.json`);

    if (!existsSync(filePath)) {
      return null;
    }

    try {
      const content = await readFile(filePath, 'utf-8');
      return JSON.parse(content) as V2LoopStorage;
    } catch {
      return null;
    }
  };

  // Helper to write loop storage
  const writeLoopStorage = async (loop: V2LoopStorage): Promise<void> => {
    const { writeFile, mkdir } = await import('fs/promises');
    const { existsSync } = await import('fs');

    if (!existsSync(loopDir)) {
      await mkdir(loopDir, { recursive: true });
    }

    const filePath = join(loopDir, `${loop.loop_id}.json`);
    await writeFile(filePath, JSON.stringify(loop, null, 2), 'utf-8');
  };

  // Helper to delete loop storage
  const deleteLoopStorage = async (loopId: string): Promise<void> => {
    const { unlink } = await import('fs/promises');
    const { existsSync } = await import('fs');
    const filePath = join(loopDir, `${loopId}.json`);

    if (existsSync(filePath)) {
      await unlink(filePath);
    }

    // Also delete tasks.jsonl if exists
    const tasksPath = join(loopDir, `${loopId}.tasks.jsonl`);
    if (existsSync(tasksPath)) {
      await unlink(tasksPath).catch(() => {});
    }
  };

  // Helper to list all loops
  const listLoops = async (): Promise<V2LoopStorage[]> => {
    const { readdir } = await import('fs/promises');
    const { existsSync } = await import('fs');

    if (!existsSync(loopDir)) {
      return [];
    }

    const files = await readdir(loopDir);
    const loopFiles = files.filter(f => f.startsWith('loop-v2-') && f.endsWith('.json'));

    const loops: V2LoopStorage[] = [];
    for (const file of loopFiles) {
      const loopId = file.replace('.json', '');
      const loop = await readLoopStorage(loopId);
      if (loop) {
        loops.push(loop);
      }
    }

    return loops;
  };

  // ==== EXACT PATH ROUTES ====

  // POST /api/loops/v2 - Create loop with simplified fields
  if (pathname === '/api/loops/v2' && req.method === 'POST') {
    handlePostRequest(req, res, async (body) => {
      const { title, description, max_iterations } = body as V2LoopCreateRequest;

      // Validation
      if (!title || typeof title !== 'string' || title.trim().length === 0) {
        return { success: false, error: 'title is required and must be non-empty', status: 400 };
      }

      if (description !== undefined && typeof description !== 'string') {
        return { success: false, error: 'description must be a string', status: 400 };
      }

      if (max_iterations !== undefined && (typeof max_iterations !== 'number' || max_iterations < 1)) {
        return { success: false, error: 'max_iterations must be a positive number', status: 400 };
      }

      try {
        const loopId = generateLoopId();
        const now = new Date().toISOString();

        const loop: V2LoopStorage = {
          loop_id: loopId,
          title: title.trim(),
          description: description?.trim() || '',
          max_iterations: max_iterations || 10,
          status: LoopStatus.CREATED,
          current_iteration: 0,
          created_at: now,
          updated_at: now
        };

        await writeLoopStorage(loop);

        // Broadcast creation
        broadcastStateUpdate(loopId, LoopStatus.CREATED);

        return { success: true, data: loop };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  // GET /api/loops/v2 - List all loops with pagination
  if (pathname === '/api/loops/v2' && req.method === 'GET') {
    try {
      const loops = await listLoops();

      // Parse query params for pagination and filtering
      const searchParams = url?.searchParams;
      let filteredLoops = loops;

      // Filter by status
      const statusFilter = searchParams?.get('status');
      if (statusFilter && statusFilter !== 'all') {
        filteredLoops = filteredLoops.filter(l => l.status === statusFilter);
      }

      // Sort by updated_at (most recent first)
      filteredLoops.sort((a, b) =>
        new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime()
      );

      // Parse pagination params
      const limit = parseInt(searchParams?.get('limit') || '50', 10);
      const offset = parseInt(searchParams?.get('offset') || '0', 10);

      // Apply pagination
      const paginatedLoops = filteredLoops.slice(offset, offset + limit);

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        success: true,
        data: paginatedLoops,
        total: filteredLoops.length,
        limit,
        offset,
        hasMore: offset + limit < filteredLoops.length,
        timestamp: new Date().toISOString()
      }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // ==== NESTED PATH ROUTES (more specific patterns first) ====

  // POST /api/loops/v2/:loopId/start - Start loop execution
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/start$/) && req.method === 'POST') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    try {
      const loop = await readLoopStorage(loopId);
      if (!loop) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Loop not found' }));
        return true;
      }

      // Can only start created or paused loops
      if (!['created', 'paused'].includes(loop.status.toLowerCase())) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          success: false,
          error: `Cannot start loop with status: ${loop.status}`
        }));
        return true;
      }

      // Update loop status
      loop.status = LoopStatus.RUNNING;
      loop.updated_at = new Date().toISOString();
      await writeLoopStorage(loop);

      // Broadcast state update
      broadcastStateUpdate(loopId, LoopStatus.RUNNING);

      // Trigger ccw-loop skill execution (non-blocking)
      // The skill will check status before each action and exit gracefully on pause/stop
      executeCliTool({
        tool: 'claude',
        prompt: `/ccw-loop --loop-id ${loopId} --auto`,
        mode: 'write',
        workingDir: workflowDir
      }).catch((error) => {
        // Log error but don't fail the start request
        console.error(`Failed to trigger ccw-loop skill for ${loopId}:`, error);
        // Update loop status to failed
        readLoopStorage(loopId).then(async (failedLoop) => {
          if (failedLoop) {
            failedLoop.status = LoopStatus.FAILED;
            failedLoop.failure_reason = `Skill execution failed: ${error.message}`;
            failedLoop.completed_at = new Date().toISOString();
            await writeLoopStorage(failedLoop);
            broadcastStateUpdate(loopId, LoopStatus.FAILED);
          }
        });
      });

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: true, data: loop, message: 'Loop started' }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // POST /api/loops/v2/:loopId/pause - Pause loop
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/pause$/) && req.method === 'POST') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    try {
      const loop = await readLoopStorage(loopId);
      if (!loop) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Loop not found' }));
        return true;
      }

      // Can only pause running loops
      if (loop.status !== LoopStatus.RUNNING) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          success: false,
          error: `Cannot pause loop with status: ${loop.status}`
        }));
        return true;
      }

      loop.status = LoopStatus.PAUSED;
      loop.updated_at = new Date().toISOString();
      await writeLoopStorage(loop);

      broadcastStateUpdate(loopId, LoopStatus.PAUSED);

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: true, data: loop, message: 'Loop paused' }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // POST /api/loops/v2/:loopId/resume - Resume loop
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/resume$/) && req.method === 'POST') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    try {
      const loop = await readLoopStorage(loopId);
      if (!loop) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Loop not found' }));
        return true;
      }

      // Can only resume paused loops
      if (loop.status !== LoopStatus.PAUSED) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          success: false,
          error: `Cannot resume loop with status: ${loop.status}`
        }));
        return true;
      }

      loop.status = LoopStatus.RUNNING;
      loop.updated_at = new Date().toISOString();
      await writeLoopStorage(loop);

      broadcastStateUpdate(loopId, LoopStatus.RUNNING);

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: true, data: loop, message: 'Loop resumed' }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // POST /api/loops/v2/:loopId/stop - Stop loop
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/stop$/) && req.method === 'POST') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    try {
      const loop = await readLoopStorage(loopId);
      if (!loop) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Loop not found' }));
        return true;
      }

      // Can only stop running or paused loops
      if (![LoopStatus.RUNNING, LoopStatus.PAUSED, LoopStatus.CREATED].includes(loop.status)) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          success: false,
          error: `Cannot stop loop with status: ${loop.status}`
        }));
        return true;
      }

      loop.status = LoopStatus.FAILED;
      loop.failure_reason = 'Manually stopped by user';
      loop.completed_at = new Date().toISOString();
      loop.updated_at = loop.completed_at;
      await writeLoopStorage(loop);

      broadcastStateUpdate(loopId, LoopStatus.FAILED);

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: true, data: loop, message: 'Loop stopped' }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // ==== SINGLE PARAM ROUTES (must come after nested routes) ====

  // GET /api/loops/v2/:loopId - Get loop details
  if (pathname.match(/^\/api\/loops\/v2\/[^/]+$/) && req.method === 'GET') {
    const loopId = pathname.split('/').pop();
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    try {
      const loop = await readLoopStorage(loopId);
      if (!loop) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Loop not found' }));
        return true;
      }

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: true, data: loop }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // PUT /api/loops/v2/:loopId - Update loop metadata
  if (pathname.match(/^\/api\/loops\/v2\/[^/]+$/) && req.method === 'PUT') {
    const loopId = pathname.split('/').pop();
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    handlePostRequest(req, res, async (body) => {
      const { title, description, max_iterations, tags, priority, notes } = body as V2LoopUpdateRequest;

      try {
        const loop = await readLoopStorage(loopId);
        if (!loop) {
          return { success: false, error: 'Loop not found', status: 404 };
        }

        // Can only update created or paused loops
        if (![LoopStatus.CREATED, LoopStatus.PAUSED, LoopStatus.FAILED, LoopStatus.COMPLETED].includes(loop.status)) {
          return { success: false, error: `Cannot update loop with status: ${loop.status}`, status: 400 };
        }

        // Validate and apply updates
        if (title !== undefined) {
          if (typeof title !== 'string' || title.trim().length === 0) {
            return { success: false, error: 'title must be a non-empty string', status: 400 };
          }
          loop.title = title.trim();
        }

        if (description !== undefined) {
          if (typeof description !== 'string') {
            return { success: false, error: 'description must be a string', status: 400 };
          }
          loop.description = description.trim();
        }

        if (max_iterations !== undefined) {
          if (typeof max_iterations !== 'number' || max_iterations < 1) {
            return { success: false, error: 'max_iterations must be a positive number', status: 400 };
          }
          loop.max_iterations = max_iterations;
        }

        // Extended metadata fields
        if (tags !== undefined) {
          if (!Array.isArray(tags) || !tags.every(t => typeof t === 'string')) {
            return { success: false, error: 'tags must be an array of strings', status: 400 };
          }
          loop.tags = tags;
        }

        if (priority !== undefined) {
          if (!['low', 'medium', 'high'].includes(priority)) {
            return { success: false, error: 'priority must be one of: low, medium, high', status: 400 };
          }
          loop.priority = priority;
        }

        if (notes !== undefined) {
          if (typeof notes !== 'string') {
            return { success: false, error: 'notes must be a string', status: 400 };
          }
          loop.notes = notes.trim();
        }

        loop.updated_at = new Date().toISOString();
        await writeLoopStorage(loop);

        broadcastStateUpdate(loopId, loop.status);

        return { success: true, data: loop };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  // PATCH /api/loops/v2/:loopId/status - Quick status update
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/status$/) && req.method === 'PATCH') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    handlePostRequest(req, res, async (body) => {
      const { status } = body as { status?: string };

      if (!status || typeof status !== 'string') {
        return { success: false, error: 'status is required', status: 400 };
      }

      if (!Object.values(LoopStatus).includes(status as LoopStatus)) {
        return { success: false, error: `Invalid status: ${status}`, status: 400 };
      }

      try {
        const loop = await readLoopStorage(loopId);
        if (!loop) {
          return { success: false, error: 'Loop not found', status: 404 };
        }

        loop.status = status as LoopStatus;
        loop.updated_at = new Date().toISOString();

        if (status === LoopStatus.COMPLETED && !loop.completed_at) {
          loop.completed_at = new Date().toISOString();
        }

        await writeLoopStorage(loop);

        broadcastStateUpdate(loopId, loop.status);

        return { success: true, data: loop };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  // DELETE /api/loops/v2/:loopId - Delete loop
  if (pathname.match(/^\/api\/loops\/v2\/[^/]+$/) && req.method === 'DELETE') {
    const loopId = pathname.split('/').pop();
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    try {
      const loop = await readLoopStorage(loopId);
      if (!loop) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Loop not found' }));
        return true;
      }

      // Cannot delete running loops
      if (loop.status === LoopStatus.RUNNING) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          success: false,
          error: 'Cannot delete running loop. Stop it first.'
        }));
        return true;
      }

      await deleteLoopStorage(loopId);

      // Broadcast deletion
      try {
        broadcastToClients({
          type: 'LOOP_DELETED',
          loop_id: loopId
        });
      } catch {
        // Ignore broadcast errors
      }

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: true, message: 'Loop deleted' }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // ==== TASK MANAGEMENT ENDPOINTS ====

  // Helper to create TaskStorageManager instance
  const createTaskManager = (): TaskStorageManager => {
    return new TaskStorageManager(workflowDir);
  };

  // POST /api/loops/v2/:loopId/tasks - Add task to loop
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/tasks$/) && req.method === 'POST') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    handlePostRequest(req, res, async (body) => {
      const { description, tool, mode, prompt_template, command, on_error } = body as TaskCreateRequest;

      // Validation
      if (!description || typeof description !== 'string' || description.trim().length === 0) {
        return { success: false, error: 'description is required', status: 400 };
      }

      if (!tool || typeof tool !== 'string') {
        return { success: false, error: 'tool is required', status: 400 };
      }

      // Get enabled tools from cli-tools.json dynamically
      const cliToolsConfig = loadClaudeCliTools(os.homedir());
      const enabledTools = Object.entries(cliToolsConfig.tools || {})
        .filter(([_, config]) => config.enabled === true)
        .map(([name]) => name);

      // Also allow 'bash' as a special case (built-in tool)
      const validTools = ['bash', ...enabledTools];

      if (!validTools.includes(tool)) {
        return { success: false, error: `tool must be one of enabled tools: ${validTools.join(', ')}`, status: 400 };
      }

      if (!mode || typeof mode !== 'string') {
        return { success: false, error: 'mode is required', status: 400 };
      }

      const validModes = ['analysis', 'write', 'review'];
      if (!validModes.includes(mode)) {
        return { success: false, error: `mode must be one of: ${validModes.join(', ')}`, status: 400 };
      }

      if (!prompt_template || typeof prompt_template !== 'string' || prompt_template.trim().length === 0) {
        return { success: false, error: 'prompt_template is required', status: 400 };
      }

      try {
        const taskManager = createTaskManager();
        const task = await taskManager.addTask(loopId, {
          description: description.trim(),
          tool,
          mode,
          prompt_template: prompt_template.trim(),
          command,
          on_error
        });

        // Broadcast task added
        try {
          broadcastToClients({
            type: 'TASK_ADDED',
            loop_id: loopId,
            task_id: task.task_id,
            task: task
          });
        } catch {
          // Ignore broadcast errors
        }

        return { success: true, data: task };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  // GET /api/loops/v2/:loopId/tasks - List all tasks for loop
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/tasks$/) && req.method === 'GET') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    try {
      const taskManager = createTaskManager();
      const tasks = await taskManager.getTasks(loopId);

      // Sort by order
      tasks.sort((a, b) => a.order - b.order);

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        success: true,
        data: tasks,
        total: tasks.length,
        loop_id: loopId,
        timestamp: new Date().toISOString()
      }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // GET /api/loops/v2/tasks/:taskId - Get single task (taskId lookup)
  if (pathname.match(/^\/api\/loops\/v2\/tasks\/[^/]+$/) && req.method === 'GET') {
    const taskId = pathname.split('/').pop();
    if (!taskId || !isValidId(taskId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid task ID format' }));
      return true;
    }

    try {
      const taskManager = createTaskManager();
      // Get all loops and search for the task
      const loops = await listLoops();
      let foundTask = null;
      let foundLoopId = null;

      for (const loop of loops) {
        const loopId = loop.loop_id;
        try {
          const tasks = await taskManager.getTasks(loopId);
          const task = tasks.find(t => t.task_id === taskId);
          if (task) {
            foundTask = task;
            foundLoopId = loopId;
            break;
          }
        } catch {
          continue;
        }
      }

      if (!foundTask) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Task not found' }));
        return true;
      }

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        success: true,
        data: { ...foundTask, loop_id: foundLoopId },
        timestamp: new Date().toISOString()
      }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // PUT /api/loops/v2/tasks/:taskId - Update task (taskId lookup)
  if (pathname.match(/^\/api\/loops\/v2\/tasks\/[^/]+$/) && req.method === 'PUT') {
    const taskId = pathname.split('/').pop();
    if (!taskId || !isValidId(taskId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid task ID format' }));
      return true;
    }

    handlePostRequest(req, res, async (body) => {
      const { loop_id, description, tool, mode, prompt_template, command, on_error } = body as TaskUpdateRequest & { loop_id?: string };

      if (!loop_id || typeof loop_id !== 'string') {
        return { success: false, error: 'loop_id is required', status: 400 };
      }

      if (!isValidId(loop_id)) {
        return { success: false, error: 'Invalid loop_id format', status: 400 };
      }

      try {
        const taskManager = createTaskManager();
        const updatedTask = await taskManager.updateTask(loop_id, taskId, {
          description,
          tool,
          mode,
          prompt_template,
          command,
          on_error
        });

        if (!updatedTask) {
          return { success: false, error: 'Task not found', status: 404 };
        }

        // Broadcast task updated
        try {
          broadcastToClients({
            type: 'TASK_UPDATED',
            loop_id: loop_id,
            task_id: taskId,
            task: updatedTask
          });
        } catch {
          // Ignore broadcast errors
        }

        return { success: true, data: updatedTask };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  // DELETE /api/loops/v2/tasks/:taskId - Delete task (taskId lookup)
  if (pathname.match(/^\/api\/loops\/v2\/tasks\/[^/]+$/) && req.method === 'DELETE') {
    const taskId = pathname.split('/').pop();
    if (!taskId || !isValidId(taskId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid task ID format' }));
      return true;
    }

    // Get loop_id from query parameter
    const urlObj = new URL(req.url || '', `http://localhost`);
    const loopId = urlObj.searchParams.get('loop_id');

    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'loop_id query parameter is required' }));
      return true;
    }

    try {
      const taskManager = createTaskManager();
      const deleted = await taskManager.deleteTask(loopId, taskId);

      if (!deleted) {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: false, error: 'Task not found' }));
        return true;
      }

      // Broadcast task deleted
      try {
        broadcastToClients({
          type: 'TASK_DELETED',
          loop_id: loopId,
          task_id: taskId
        });
      } catch {
        // Ignore broadcast errors
      }

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: true, message: 'Task deleted' }));
      return true;
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: (error as Error).message }));
      return true;
    }
  }

  // PUT /api/loops/v2/:loopId/tasks/reorder - Reorder tasks
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/tasks\/reorder$/) && req.method === 'PUT') {
    const loopId = pathname.split('/').slice(-3)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    handlePostRequest(req, res, async (body) => {
      const { ordered_task_ids } = body as TaskReorderRequest;

      if (!ordered_task_ids || !Array.isArray(ordered_task_ids)) {
        return { success: false, error: 'ordered_task_ids must be an array', status: 400 };
      }

      if (ordered_task_ids.length === 0) {
        return { success: false, error: 'ordered_task_ids cannot be empty', status: 400 };
      }

      try {
        const taskManager = createTaskManager();
        const reorderedTasks = await taskManager.reorderTasks(loopId, { ordered_task_ids });

        // Broadcast tasks reordered
        try {
          broadcastToClients({
            type: 'TASK_REORDERED',
            loop_id: loopId,
            ordered_task_ids: ordered_task_ids,
            tasks: reorderedTasks
          });
        } catch {
          // Ignore broadcast errors
        }

        return { success: true, data: reorderedTasks };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  // ==== ADVANCED TASK FEATURES ====

  // POST /api/loops/v2/:loopId/import - Import tasks from issue
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/import$/) && req.method === 'POST') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    handlePostRequest(req, res, async (body) => {
      const { issue_id } = body as { issue_id?: string };

      if (!issue_id || typeof issue_id !== 'string') {
        return { success: false, error: 'issue_id is required', status: 400 };
      }

      try {
        // Fetch issue data from issue-manager
        const { readFile } = await import('fs/promises');
        const { existsSync } = await import('fs');
        const issuesDir = join(workflowDir, '.workflow', 'issues');
        const issuesPath = join(issuesDir, 'issues.jsonl');

        let issueData: any = null;

        // Try reading from active issues
        if (existsSync(issuesPath)) {
          const content = await readFile(issuesPath, 'utf-8');
          const issues = content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
          issueData = issues.find((i: any) => i.id === issue_id);
        }

        // Try reading from history if not found
        if (!issueData) {
          const historyPath = join(issuesDir, 'issue-history.jsonl');
          if (existsSync(historyPath)) {
            const content = await readFile(historyPath, 'utf-8');
            const historyIssues = content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
            issueData = historyIssues.find((i: any) => i.id === issue_id);
          }
        }

        if (!issueData) {
          return { success: false, error: `Issue ${issue_id} not found`, status: 404 };
        }

        // Load solutions to get bound solution tasks
        const solutionsPath = join(issuesDir, 'solutions', `${issue_id}.jsonl`);
        let tasksToImport: any[] = [];

        if (existsSync(solutionsPath)) {
          const solutionsContent = await readFile(solutionsPath, 'utf-8');
          const solutions = solutionsContent.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));

          // Get tasks from bound solution
          const boundSolution = solutions.find((s: any) => s.id === issueData.bound_solution_id) ||
                               solutions.find((s: any) => s.is_bound) ||
                               solutions[0];

          if (boundSolution?.tasks) {
            tasksToImport = boundSolution.tasks;
          }
        }

        if (tasksToImport.length === 0) {
          return { success: false, error: 'No tasks found in issue. Bind a solution with tasks first.', status: 400 };
        }

        // Broadcast import start
        broadcastToClients({
          type: 'LOOP_TASK_IMPORT_PROGRESS',
          loop_id: loopId,
          payload: {
            stage: 'starting',
            total: tasksToImport.length,
            imported: 0
          }
        });

        const taskManager = createTaskManager();
        const createdTasks: any[] = [];

        // Convert issue tasks to loop tasks
        for (let i = 0; i < tasksToImport.length; i++) {
          const issueTask = tasksToImport[i];

          // Map issue task fields to loop task fields
          const taskRequest: TaskCreateRequest = {
            description: issueTask.description || issueTask.title || `Task ${i + 1}`,
            tool: mapIssueToolToLoopTool(issueTask.tool) || 'gemini',
            mode: mapIssueModeToLoopMode(issueTask.mode) || 'write',
            prompt_template: issueTask.prompt_template || issueTask.prompt || `Execute: ${issueTask.description || issueTask.title}`,
            command: issueTask.command,
            on_error: mapIssueOnError(issueTask.on_error)
          };

          const task = await taskManager.addTask(loopId, taskRequest);
          createdTasks.push(task);

          // Broadcast progress
          broadcastToClients({
            type: 'LOOP_TASK_IMPORT_PROGRESS',
            loop_id: loopId,
            payload: {
              stage: 'importing',
              total: tasksToImport.length,
              imported: i + 1,
              current_task: task
            }
          });
        }

        // Broadcast completion
        broadcastToClients({
          type: 'LOOP_TASK_IMPORT_COMPLETE',
          loop_id: loopId,
          payload: {
            total: tasksToImport.length,
            imported: createdTasks.length,
            tasks: createdTasks
          }
        });

        return {
          success: true,
          data: createdTasks,
          message: `Imported ${createdTasks.length} tasks from issue ${issue_id}`
        };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  // POST /api/loops/v2/:loopId/generate - Generate tasks via Gemini
  if (pathname.match(/\/api\/loops\/v2\/[^/]+\/generate$/) && req.method === 'POST') {
    const loopId = pathname.split('/').slice(-2)[0];
    if (!loopId || !isValidId(loopId)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ success: false, error: 'Invalid loop ID format' }));
      return true;
    }

    handlePostRequest(req, res, async (body) => {
      const { tool = 'gemini', count } = body as { tool?: string; count?: number };

      try {
        // Get loop details for context
        const loop = await readLoopStorage(loopId);
        if (!loop) {
          return { success: false, error: 'Loop not found', status: 404 };
        }

        // Broadcast generation start
        broadcastToClients({
          type: 'LOOP_TASK_GENERATION_PROGRESS',
          loop_id: loopId,
          payload: {
            stage: 'analyzing',
            message: 'Analyzing loop description...'
          }
        });

        // Build generation prompt
        const generatePrompt = `PURPOSE: Generate ${count || 5} specific tasks for loop execution
TASK: Analyze the loop description and generate a list of actionable tasks that can be executed via CLI tools. Each task should have clear description, tool selection, mode, and prompt template.
MODE: analysis
CONTEXT: Loop title: ${loop.title}
Loop description: ${loop.description || 'No description provided'}
Max iterations: ${loop.max_iterations}
EXPECTED: Return a JSON array of tasks with this exact structure:
[
  {
    "description": "Clear task description",
    "tool": "gemini|codex|qwen|bash",
    "mode": "analysis|write|review",
    "prompt_template": "PURPOSE: ... TASK: ... MODE: analysis CONTEXT: @**/* EXPECTED: ...",
    "on_error": "continue|pause|fail_fast"
  }
]
CONSTRAINTS: Generate ${count || 5} tasks | Use gemini for AI tasks | Use bash for CLI commands | Include error handling strategy`;

        // Call CLI with gemini to generate tasks
        let generatedTasks: any[] = [];
        let outputBuffer = '';

        const result = await executeCliTool({
          tool: tool === 'codex' || tool === 'qwen' || tool === 'gemini' ? tool : 'gemini',
          prompt: generatePrompt,
          mode: 'analysis',
          format: 'plain',
          cd: workflowDir,
          timeout: 120000, // 2 minutes timeout
          stream: true
        }, (unit) => {
          // Collect output
          outputBuffer += unit.content;

          // Broadcast partial output for progress
          broadcastToClients({
            type: 'LOOP_TASK_GENERATION_PROGRESS',
            loop_id: loopId,
            payload: {
              stage: 'generating',
              message: 'Generating tasks...',
              output: unit.content
            }
          });
        });

        if (!result.success) {
          return { success: false, error: 'Failed to generate tasks via CLI', status: 500 };
        }

        // Parse generated tasks from CLI output
        generatedTasks = parseGeneratedTasks(outputBuffer);

        if (generatedTasks.length === 0) {
          return {
            success: false,
            error: 'No valid tasks generated. Check CLI output for details.',
            status: 500,
            output: outputBuffer
          };
        }

        // Broadcast import start
        broadcastToClients({
          type: 'LOOP_TASK_GENERATION_PROGRESS',
          loop_id: loopId,
          payload: {
            stage: 'importing',
            message: `Importing ${generatedTasks.length} generated tasks...`,
            total: generatedTasks.length,
            imported: 0
          }
        });

        const taskManager = createTaskManager();
        const createdTasks: any[] = [];

        // Add generated tasks to loop
        for (let i = 0; i < generatedTasks.length; i++) {
          const genTask = generatedTasks[i];

          const taskRequest: TaskCreateRequest = {
            description: genTask.description || `Generated Task ${i + 1}`,
            tool: validateTool(genTask.tool) ? genTask.tool : 'gemini',
            mode: validateMode(genTask.mode) ? genTask.mode : 'write',
            prompt_template: genTask.prompt_template || `Execute task: ${genTask.description}`,
            command: genTask.command,
            on_error: validateOnError(genTask.on_error) ? genTask.on_error : 'continue'
          };

          const task = await taskManager.addTask(loopId, taskRequest);
          createdTasks.push(task);

          // Broadcast progress
          broadcastToClients({
            type: 'LOOP_TASK_GENERATION_PROGRESS',
            loop_id: loopId,
            payload: {
              stage: 'importing',
              message: `Importing task ${i + 1}/${generatedTasks.length}...`,
              total: generatedTasks.length,
              imported: i + 1,
              current_task: task
            }
          });
        }

        // Broadcast completion
        broadcastToClients({
          type: 'LOOP_TASK_GENERATION_COMPLETE',
          loop_id: loopId,
          payload: {
            total: generatedTasks.length,
            imported: createdTasks.length,
            tasks: createdTasks
          }
        });

        return {
          success: true,
          data: createdTasks,
          message: `Generated and imported ${createdTasks.length} tasks`
        };
      } catch (error) {
        return { success: false, error: (error as Error).message, status: 500 };
      }
    });
    return true;
  }

  return false;
}

/**
 * Sanitize ID parameter to prevent path traversal attacks
 * @returns true if valid, false if invalid
 */
function isValidId(id: string): boolean {
  if (!id) return false;
  // Block path traversal attempts and null bytes
  if (id.includes('/') || id.includes('\\') || id === '..' || id === '.') return false;
  if (id.includes('\0')) return false;
  return true;
}

/**
 * Get enabled tools list from cache
 * If cache is not initialized, it will load from config (fallback for lazy initialization)
 */
function getEnabledToolsList(): string[] {
  // Return cached value if available
  if (cachedEnabledTools) {
    return cachedEnabledTools;
  }

  // Fallback: lazy initialization if cache not initialized (shouldn't happen in normal operation)
  console.warn('[Loop V2] CLI tools cache not initialized, performing lazy load');
  initializeCliToolsCache();
  return cachedEnabledTools || ['bash', 'gemini', 'qwen', 'codex', 'claude'];
}

/**
 * Map issue tool to loop tool
 */
function mapIssueToolToLoopTool(tool: any): string | null {
  const validTools = getEnabledToolsList();
  if (validTools.includes(tool)) return tool;
  // Map aliases
  if (tool === 'ccw') return 'gemini';
  if (tool === 'ai') return 'gemini';
  return null;
}

/**
 * Map issue mode to loop mode
 */
function mapIssueModeToLoopMode(mode: any): 'analysis' | 'write' | 'review' | null {
  const validModes = ['analysis', 'write', 'review'];
  if (validModes.includes(mode)) return mode as any;
  // Map aliases
  if (mode === 'read') return 'analysis';
  if (mode === 'create' || mode === 'modify') return 'write';
  return null;
}

/**
 * Map issue on_error value
 */
function mapIssueOnError(onError: any): 'continue' | 'pause' | 'fail_fast' | undefined {
  const validValues = ['continue', 'pause', 'fail_fast'];
  if (validValues.includes(onError)) return onError as any;
  // Map aliases
  if (onError === 'stop') return 'pause';
  if (onError === 'abort') return 'fail_fast';
  return undefined;
}

/**
 * Validate tool value
 */
function validateTool(tool: any): boolean {
  const validTools = getEnabledToolsList();
  return validTools.includes(tool);
}

/**
 * Validate mode value
 */
function validateMode(mode: any): boolean {
  const validModes = ['analysis', 'write', 'review'];
  return validModes.includes(mode);
}

/**
 * Validate on_error value
 */
function validateOnError(onError: any): boolean {
  const validValues = ['continue', 'pause', 'fail_fast'];
  return validValues.includes(onError);
}

/**
 * Parse generated tasks from CLI output
 * Extracts JSON array from output, handles various response formats
 */
function parseGeneratedTasks(output: string): any[] {
  let tasks: any[] = [];

  // Try to find JSON array in output
  const jsonMatch = output.match(/\[[\s\S]*\]/);
  if (jsonMatch) {
    try {
      tasks = JSON.parse(jsonMatch[0]);
    } catch {
      // Invalid JSON, try alternative parsing
    }
  }

  // If no valid JSON array found, try parsing line by line
  if (tasks.length === 0) {
    const lines = output.split('\n');
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
        try {
          tasks.push(JSON.parse(trimmed));
        } catch {
          // Skip invalid lines
        }
      }
    }
  }

  // Filter and validate task objects
  return tasks.filter(t =>
    t &&
    typeof t === 'object' &&
    (t.description || t.title || t.task) &&
    (t.tool || t.mode || t.prompt_template)
  ).map(t => ({
    description: t.description || t.title || t.task || 'Untitled task',
    tool: t.tool || 'gemini',
    mode: t.mode || 'write',
    prompt_template: t.prompt_template || t.prompt || `Execute: ${t.description || t.title || t.task}`,
    command: t.command,
    on_error: t.on_error || 'continue'
  }));
}