/**
 * Issue Routes Module (Optimized - Flat JSONL Storage)
 *
 * Storage Structure:
 * .workflow/issues/
 * ├── issues.jsonl              # All issues (one per line)
 * ├── queues/                   # Queue history directory
 * │   ├── index.json            # Queue index (active + history)
 * │   └── {queue-id}.json       # Individual queue files
 * └── solutions/
 *     ├── {issue-id}.jsonl      # Solutions for issue (one per line)
 *     └── ...
 *
 * API Endpoints (8 total):
 * - GET    /api/issues              - List all issues
 * - POST   /api/issues              - Create new issue
 * - GET    /api/issues/:id          - Get issue detail
 * - PATCH  /api/issues/:id          - Update issue (includes binding logic)
 * - DELETE /api/issues/:id          - Delete issue
 * - POST   /api/issues/:id/solutions - Add solution
 * - PATCH  /api/issues/:id/tasks/:taskId - Update task
 * - GET    /api/queue               - Get execution queue
 * - POST   /api/queue/reorder       - Reorder queue items
 */
import { readFileSync, existsSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
import { join } from 'path';
// ========== JSONL Helper Functions ==========
function readIssuesJsonl(issuesDir) {
    const issuesPath = join(issuesDir, 'issues.jsonl');
    if (!existsSync(issuesPath))
        return [];
    try {
        const content = readFileSync(issuesPath, 'utf8');
        return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
    }
    catch {
        return [];
    }
}
function writeIssuesJsonl(issuesDir, issues) {
    if (!existsSync(issuesDir))
        mkdirSync(issuesDir, { recursive: true });
    const issuesPath = join(issuesDir, 'issues.jsonl');
    writeFileSync(issuesPath, issues.map(i => JSON.stringify(i)).join('\n'));
}
function readSolutionsJsonl(issuesDir, issueId) {
    const solutionsPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
    if (!existsSync(solutionsPath))
        return [];
    try {
        const content = readFileSync(solutionsPath, 'utf8');
        return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
    }
    catch {
        return [];
    }
}
function readIssueHistoryJsonl(issuesDir) {
    const historyPath = join(issuesDir, 'issue-history.jsonl');
    if (!existsSync(historyPath))
        return [];
    try {
        const content = readFileSync(historyPath, 'utf8');
        return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
    }
    catch {
        return [];
    }
}
function writeSolutionsJsonl(issuesDir, issueId, solutions) {
    const solutionsDir = join(issuesDir, 'solutions');
    if (!existsSync(solutionsDir))
        mkdirSync(solutionsDir, { recursive: true });
    writeFileSync(join(solutionsDir, `${issueId}.jsonl`), solutions.map(s => JSON.stringify(s)).join('\n'));
}
function readQueue(issuesDir) {
    // Try new multi-queue structure first
    const queuesDir = join(issuesDir, 'queues');
    const indexPath = join(queuesDir, 'index.json');
    if (existsSync(indexPath)) {
        try {
            const index = JSON.parse(readFileSync(indexPath, 'utf8'));
            const activeQueueId = index.active_queue_id;
            if (activeQueueId) {
                const queueFilePath = join(queuesDir, `${activeQueueId}.json`);
                if (existsSync(queueFilePath)) {
                    return JSON.parse(readFileSync(queueFilePath, 'utf8'));
                }
            }
        }
        catch {
            // Fall through to legacy check
        }
    }
    // Fallback to legacy queue.json
    const legacyQueuePath = join(issuesDir, 'queue.json');
    if (existsSync(legacyQueuePath)) {
        try {
            return JSON.parse(readFileSync(legacyQueuePath, 'utf8'));
        }
        catch {
            // Return empty queue
        }
    }
    return { tasks: [], conflicts: [], execution_groups: [], _metadata: { version: '1.0', total_tasks: 0 } };
}
function writeQueue(issuesDir, queue) {
    if (!existsSync(issuesDir))
        mkdirSync(issuesDir, { recursive: true });
    // Support both solution-based and task-based queues
    const items = queue.solutions || queue.tasks || [];
    const isSolutionBased = Array.isArray(queue.solutions) && queue.solutions.length > 0;
    queue._metadata = {
        ...queue._metadata,
        updated_at: new Date().toISOString(),
        ...(isSolutionBased
            ? { total_solutions: items.length }
            : { total_tasks: items.length })
    };
    // Check if using new multi-queue structure
    const queuesDir = join(issuesDir, 'queues');
    const indexPath = join(queuesDir, 'index.json');
    if (existsSync(indexPath) && queue.id) {
        // Write to new structure
        const queueFilePath = join(queuesDir, `${queue.id}.json`);
        writeFileSync(queueFilePath, JSON.stringify(queue, null, 2));
        // Update index metadata
        try {
            const index = JSON.parse(readFileSync(indexPath, 'utf8'));
            const queueEntry = index.queues?.find((q) => q.id === queue.id);
            if (queueEntry) {
                if (isSolutionBased) {
                    queueEntry.total_solutions = items.length;
                    queueEntry.completed_solutions = items.filter((i) => i.status === 'completed').length;
                }
                else {
                    queueEntry.total_tasks = items.length;
                    queueEntry.completed_tasks = items.filter((i) => i.status === 'completed').length;
                }
                writeFileSync(indexPath, JSON.stringify(index, null, 2));
            }
        }
        catch {
            // Ignore index update errors
        }
    }
    else {
        // Fallback to legacy queue.json
        writeFileSync(join(issuesDir, 'queue.json'), JSON.stringify(queue, null, 2));
    }
}
function getIssueDetail(issuesDir, issueId) {
    const issues = readIssuesJsonl(issuesDir);
    const issue = issues.find(i => i.id === issueId);
    if (!issue)
        return null;
    const solutions = readSolutionsJsonl(issuesDir, issueId);
    let tasks = [];
    if (issue.bound_solution_id) {
        const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
        if (boundSol?.tasks)
            tasks = boundSol.tasks;
    }
    return { ...issue, solutions, tasks };
}
function enrichIssues(issues, issuesDir) {
    return issues.map(issue => {
        const solutions = readSolutionsJsonl(issuesDir, issue.id);
        let taskCount = 0;
        // Get task count from bound solution
        if (issue.bound_solution_id) {
            const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
            if (boundSol?.tasks) {
                taskCount = boundSol.tasks.length;
            }
        }
        return {
            ...issue,
            solution_count: solutions.length,
            task_count: taskCount
        };
    });
}
/**
 * Get queue items (supports both solution-based and task-based queues)
 */
function getQueueItems(queue) {
    return queue.solutions || queue.tasks || [];
}
/**
 * Check if queue is solution-based
 */
function isSolutionBasedQueue(queue) {
    return Array.isArray(queue.solutions) && queue.solutions.length > 0;
}
function groupQueueByExecutionGroup(queue) {
    const groups = {};
    const items = getQueueItems(queue);
    const isSolutionBased = isSolutionBasedQueue(queue);
    for (const item of items) {
        const groupId = item.execution_group || 'ungrouped';
        if (!groups[groupId])
            groups[groupId] = [];
        groups[groupId].push(item);
    }
    for (const groupId of Object.keys(groups)) {
        groups[groupId].sort((a, b) => (a.execution_order || 0) - (b.execution_order || 0));
    }
    const executionGroups = Object.entries(groups).map(([id, groupItems]) => ({
        id,
        type: id.startsWith('P') ? 'parallel' : id.startsWith('S') ? 'sequential' : 'unknown',
        // Use appropriate count field based on queue type
        ...(isSolutionBased
            ? { solution_count: groupItems.length, solutions: groupItems.map(i => i.item_id) }
            : { task_count: groupItems.length, tasks: groupItems.map(i => i.item_id) })
    })).sort((a, b) => {
        const aFirst = groups[a.id]?.[0]?.execution_order || 0;
        const bFirst = groups[b.id]?.[0]?.execution_order || 0;
        return aFirst - bFirst;
    });
    return { ...queue, execution_groups: executionGroups, grouped_items: groups };
}
/**
 * Bind solution to issue with proper side effects
 */
function bindSolutionToIssue(issuesDir, issueId, solutionId, issues, issueIndex) {
    const solutions = readSolutionsJsonl(issuesDir, issueId);
    const solIndex = solutions.findIndex(s => s.id === solutionId);
    if (solIndex === -1)
        return { error: `Solution ${solutionId} not found` };
    // Unbind all, bind new
    solutions.forEach(s => { s.is_bound = false; });
    solutions[solIndex].is_bound = true;
    solutions[solIndex].bound_at = new Date().toISOString();
    writeSolutionsJsonl(issuesDir, issueId, solutions);
    // Update issue
    issues[issueIndex].bound_solution_id = solutionId;
    issues[issueIndex].status = 'planned';
    issues[issueIndex].planned_at = new Date().toISOString();
    return { success: true, bound: solutionId };
}
// ========== Route Handler ==========
export async function handleIssueRoutes(ctx) {
    const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
    const projectPath = url.searchParams.get('path') || initialPath;
    const issuesDir = join(projectPath, '.workflow', 'issues');
    // ===== Queue Routes (top-level /api/queue) =====
    // GET /api/queue - Get execution queue
    if (pathname === '/api/queue' && req.method === 'GET') {
        const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(queue));
        return true;
    }
    // GET /api/queue/history - Get queue history (all queues from index)
    if (pathname === '/api/queue/history' && req.method === 'GET') {
        const queuesDir = join(issuesDir, 'queues');
        const indexPath = join(queuesDir, 'index.json');
        if (!existsSync(indexPath)) {
            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ queues: [], active_queue_id: null }));
            return true;
        }
        try {
            const index = JSON.parse(readFileSync(indexPath, 'utf8'));
            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify(index));
        }
        catch {
            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ queues: [], active_queue_id: null }));
        }
        return true;
    }
    // GET /api/queue/:id - Get specific queue by ID
    const queueDetailMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
    if (queueDetailMatch && req.method === 'GET' && queueDetailMatch[1] !== 'history' && queueDetailMatch[1] !== 'reorder') {
        const queueId = queueDetailMatch[1];
        const queuesDir = join(issuesDir, 'queues');
        const queueFilePath = join(queuesDir, `${queueId}.json`);
        if (!existsSync(queueFilePath)) {
            res.writeHead(404, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
            return true;
        }
        try {
            const queue = JSON.parse(readFileSync(queueFilePath, 'utf8'));
            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify(groupQueueByExecutionGroup(queue)));
        }
        catch {
            res.writeHead(500, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: 'Failed to read queue' }));
        }
        return true;
    }
    // POST /api/queue/switch - Switch active queue
    if (pathname === '/api/queue/switch' && req.method === 'POST') {
        handlePostRequest(req, res, async (body) => {
            const { queueId } = body;
            if (!queueId)
                return { error: 'queueId required' };
            const queuesDir = join(issuesDir, 'queues');
            const indexPath = join(queuesDir, 'index.json');
            const queueFilePath = join(queuesDir, `${queueId}.json`);
            if (!existsSync(queueFilePath)) {
                return { error: `Queue ${queueId} not found` };
            }
            try {
                const index = existsSync(indexPath)
                    ? JSON.parse(readFileSync(indexPath, 'utf8'))
                    : { active_queue_id: null, queues: [] };
                index.active_queue_id = queueId;
                writeFileSync(indexPath, JSON.stringify(index, null, 2));
                return { success: true, active_queue_id: queueId };
            }
            catch (err) {
                return { error: 'Failed to switch queue' };
            }
        });
        return true;
    }
    // POST /api/queue/reorder - Reorder queue items (supports both solutions and tasks)
    if (pathname === '/api/queue/reorder' && req.method === 'POST') {
        handlePostRequest(req, res, async (body) => {
            const { groupId, newOrder } = body;
            if (!groupId || !Array.isArray(newOrder)) {
                return { error: 'groupId and newOrder (array) required' };
            }
            const queue = readQueue(issuesDir);
            const items = getQueueItems(queue);
            const isSolutionBased = isSolutionBasedQueue(queue);
            const groupItems = items.filter((item) => item.execution_group === groupId);
            const otherItems = items.filter((item) => item.execution_group !== groupId);
            if (groupItems.length === 0)
                return { error: `No items in group ${groupId}` };
            const groupItemIds = new Set(groupItems.map((i) => i.item_id));
            if (groupItemIds.size !== new Set(newOrder).size) {
                return { error: 'newOrder must contain all group items' };
            }
            for (const id of newOrder) {
                if (!groupItemIds.has(id))
                    return { error: `Invalid item_id: ${id}` };
            }
            const itemMap = new Map(groupItems.map((i) => [i.item_id, i]));
            const reorderedItems = newOrder.map((qid, idx) => ({ ...itemMap.get(qid), _idx: idx }));
            const newQueueItems = [...otherItems, ...reorderedItems].sort((a, b) => {
                const aGroup = parseInt(a.execution_group?.match(/\d+/)?.[0] || '999');
                const bGroup = parseInt(b.execution_group?.match(/\d+/)?.[0] || '999');
                if (aGroup !== bGroup)
                    return aGroup - bGroup;
                if (a.execution_group === b.execution_group) {
                    return (a._idx ?? a.execution_order ?? 999) - (b._idx ?? b.execution_order ?? 999);
                }
                return (a.execution_order || 0) - (b.execution_order || 0);
            });
            newQueueItems.forEach((item, idx) => { item.execution_order = idx + 1; delete item._idx; });
            // Write back to appropriate array based on queue type
            if (isSolutionBased) {
                queue.solutions = newQueueItems;
            }
            else {
                queue.tasks = newQueueItems;
            }
            writeQueue(issuesDir, queue);
            return { success: true, groupId, reordered: newOrder.length };
        });
        return true;
    }
    // Legacy: GET /api/issues/queue (backward compat)
    if (pathname === '/api/issues/queue' && req.method === 'GET') {
        const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(queue));
        return true;
    }
    // ===== Issue Routes =====
    // GET /api/issues - List all issues
    if (pathname === '/api/issues' && req.method === 'GET') {
        const issues = enrichIssues(readIssuesJsonl(issuesDir), issuesDir);
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
            issues,
            _metadata: { version: '2.0', storage: 'jsonl', total_issues: issues.length, last_updated: new Date().toISOString() }
        }));
        return true;
    }
    // GET /api/issues/history - List completed issues from history
    if (pathname === '/api/issues/history' && req.method === 'GET') {
        const history = readIssueHistoryJsonl(issuesDir);
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
            issues: history,
            _metadata: { version: '1.0', storage: 'jsonl', total_issues: history.length, last_updated: new Date().toISOString() }
        }));
        return true;
    }
    // POST /api/issues - Create issue
    if (pathname === '/api/issues' && req.method === 'POST') {
        handlePostRequest(req, res, async (body) => {
            if (!body.id || !body.title)
                return { error: 'id and title required' };
            const issues = readIssuesJsonl(issuesDir);
            if (issues.find(i => i.id === body.id))
                return { error: `Issue ${body.id} exists` };
            const newIssue = {
                id: body.id,
                title: body.title,
                status: body.status || 'registered',
                priority: body.priority || 3,
                context: body.context || '',
                source: body.source || 'text',
                source_url: body.source_url || null,
                tags: body.tags || [],
                created_at: new Date().toISOString(),
                updated_at: new Date().toISOString()
            };
            issues.push(newIssue);
            writeIssuesJsonl(issuesDir, issues);
            return { success: true, issue: newIssue };
        });
        return true;
    }
    // GET /api/issues/:id - Get issue detail
    const detailMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
    if (detailMatch && req.method === 'GET') {
        const issueId = decodeURIComponent(detailMatch[1]);
        if (issueId === 'queue')
            return false;
        const detail = getIssueDetail(issuesDir, issueId);
        if (!detail) {
            res.writeHead(404, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: 'Issue not found' }));
            return true;
        }
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(detail));
        return true;
    }
    // PATCH /api/issues/:id - Update issue (with binding support)
    const updateMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
    if (updateMatch && req.method === 'PATCH') {
        const issueId = decodeURIComponent(updateMatch[1]);
        if (issueId === 'queue')
            return false;
        handlePostRequest(req, res, async (body) => {
            const issues = readIssuesJsonl(issuesDir);
            const issueIndex = issues.findIndex(i => i.id === issueId);
            if (issueIndex === -1)
                return { error: 'Issue not found' };
            const updates = [];
            // Handle binding if bound_solution_id provided
            if (body.bound_solution_id !== undefined) {
                if (body.bound_solution_id) {
                    const bindResult = bindSolutionToIssue(issuesDir, issueId, body.bound_solution_id, issues, issueIndex);
                    if (bindResult.error)
                        return bindResult;
                    updates.push('bound_solution_id');
                }
                else {
                    // Unbind
                    const solutions = readSolutionsJsonl(issuesDir, issueId);
                    solutions.forEach(s => { s.is_bound = false; });
                    writeSolutionsJsonl(issuesDir, issueId, solutions);
                    issues[issueIndex].bound_solution_id = null;
                    updates.push('bound_solution_id (unbound)');
                }
            }
            // Update other fields
            for (const field of ['title', 'context', 'status', 'priority', 'tags']) {
                if (body[field] !== undefined) {
                    issues[issueIndex][field] = body[field];
                    updates.push(field);
                }
            }
            issues[issueIndex].updated_at = new Date().toISOString();
            writeIssuesJsonl(issuesDir, issues);
            return { success: true, issueId, updated: updates };
        });
        return true;
    }
    // DELETE /api/issues/:id
    const deleteMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
    if (deleteMatch && req.method === 'DELETE') {
        const issueId = decodeURIComponent(deleteMatch[1]);
        const issues = readIssuesJsonl(issuesDir);
        const filtered = issues.filter(i => i.id !== issueId);
        if (filtered.length === issues.length) {
            res.writeHead(404, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: 'Issue not found' }));
            return true;
        }
        writeIssuesJsonl(issuesDir, filtered);
        // Clean up solutions file
        const solPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
        if (existsSync(solPath)) {
            try {
                unlinkSync(solPath);
            }
            catch { }
        }
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: true, issueId }));
        return true;
    }
    // POST /api/issues/:id/solutions - Add solution
    const addSolMatch = pathname.match(/^\/api\/issues\/([^/]+)\/solutions$/);
    if (addSolMatch && req.method === 'POST') {
        const issueId = decodeURIComponent(addSolMatch[1]);
        handlePostRequest(req, res, async (body) => {
            if (!body.id || !body.tasks)
                return { error: 'id and tasks required' };
            const solutions = readSolutionsJsonl(issuesDir, issueId);
            if (solutions.find(s => s.id === body.id))
                return { error: `Solution ${body.id} exists` };
            const newSolution = {
                id: body.id,
                description: body.description || '',
                tasks: body.tasks,
                exploration_context: body.exploration_context || {},
                analysis: body.analysis || {},
                score: body.score || 0,
                is_bound: false,
                created_at: new Date().toISOString()
            };
            solutions.push(newSolution);
            writeSolutionsJsonl(issuesDir, issueId, solutions);
            // Update issue solution_count
            const issues = readIssuesJsonl(issuesDir);
            const idx = issues.findIndex(i => i.id === issueId);
            if (idx !== -1) {
                issues[idx].solution_count = solutions.length;
                issues[idx].updated_at = new Date().toISOString();
                writeIssuesJsonl(issuesDir, issues);
            }
            return { success: true, solution: newSolution };
        });
        return true;
    }
    // PATCH /api/issues/:id/tasks/:taskId - Update task
    const taskMatch = pathname.match(/^\/api\/issues\/([^/]+)\/tasks\/([^/]+)$/);
    if (taskMatch && req.method === 'PATCH') {
        const issueId = decodeURIComponent(taskMatch[1]);
        const taskId = decodeURIComponent(taskMatch[2]);
        handlePostRequest(req, res, async (body) => {
            const issues = readIssuesJsonl(issuesDir);
            const issue = issues.find(i => i.id === issueId);
            if (!issue?.bound_solution_id)
                return { error: 'Issue or bound solution not found' };
            const solutions = readSolutionsJsonl(issuesDir, issueId);
            const solIdx = solutions.findIndex(s => s.id === issue.bound_solution_id);
            if (solIdx === -1)
                return { error: 'Bound solution not found' };
            const taskIdx = solutions[solIdx].tasks?.findIndex((t) => t.id === taskId);
            if (taskIdx === -1 || taskIdx === undefined)
                return { error: 'Task not found' };
            const updates = [];
            for (const field of ['status', 'priority', 'result', 'error']) {
                if (body[field] !== undefined) {
                    solutions[solIdx].tasks[taskIdx][field] = body[field];
                    updates.push(field);
                }
            }
            solutions[solIdx].tasks[taskIdx].updated_at = new Date().toISOString();
            writeSolutionsJsonl(issuesDir, issueId, solutions);
            return { success: true, issueId, taskId, updated: updates };
        });
        return true;
    }
    // Legacy: PUT /api/issues/:id/task/:taskId (backward compat)
    const legacyTaskMatch = pathname.match(/^\/api\/issues\/([^/]+)\/task\/([^/]+)$/);
    if (legacyTaskMatch && req.method === 'PUT') {
        const issueId = decodeURIComponent(legacyTaskMatch[1]);
        const taskId = decodeURIComponent(legacyTaskMatch[2]);
        handlePostRequest(req, res, async (body) => {
            const issues = readIssuesJsonl(issuesDir);
            const issue = issues.find(i => i.id === issueId);
            if (!issue?.bound_solution_id)
                return { error: 'Issue or bound solution not found' };
            const solutions = readSolutionsJsonl(issuesDir, issueId);
            const solIdx = solutions.findIndex(s => s.id === issue.bound_solution_id);
            if (solIdx === -1)
                return { error: 'Bound solution not found' };
            const taskIdx = solutions[solIdx].tasks?.findIndex((t) => t.id === taskId);
            if (taskIdx === -1 || taskIdx === undefined)
                return { error: 'Task not found' };
            const updates = [];
            if (body.status !== undefined) {
                solutions[solIdx].tasks[taskIdx].status = body.status;
                updates.push('status');
            }
            if (body.priority !== undefined) {
                solutions[solIdx].tasks[taskIdx].priority = body.priority;
                updates.push('priority');
            }
            solutions[solIdx].tasks[taskIdx].updated_at = new Date().toISOString();
            writeSolutionsJsonl(issuesDir, issueId, solutions);
            return { success: true, issueId, taskId, updated: updates };
        });
        return true;
    }
    // Legacy: PUT /api/issues/:id/bind/:solutionId (backward compat)
    const legacyBindMatch = pathname.match(/^\/api\/issues\/([^/]+)\/bind\/([^/]+)$/);
    if (legacyBindMatch && req.method === 'PUT') {
        const issueId = decodeURIComponent(legacyBindMatch[1]);
        const solutionId = decodeURIComponent(legacyBindMatch[2]);
        const issues = readIssuesJsonl(issuesDir);
        const issueIndex = issues.findIndex(i => i.id === issueId);
        if (issueIndex === -1) {
            res.writeHead(404, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: 'Issue not found' }));
            return true;
        }
        const result = bindSolutionToIssue(issuesDir, issueId, solutionId, issues, issueIndex);
        if (result.error) {
            res.writeHead(404, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify(result));
            return true;
        }
        issues[issueIndex].updated_at = new Date().toISOString();
        writeIssuesJsonl(issuesDir, issues);
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ success: true, issueId, solutionId }));
        return true;
    }
    // Legacy: PUT /api/issues/:id (backward compat for PATCH)
    const legacyUpdateMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
    if (legacyUpdateMatch && req.method === 'PUT') {
        const issueId = decodeURIComponent(legacyUpdateMatch[1]);
        if (issueId === 'queue')
            return false;
        handlePostRequest(req, res, async (body) => {
            const issues = readIssuesJsonl(issuesDir);
            const issueIndex = issues.findIndex(i => i.id === issueId);
            if (issueIndex === -1)
                return { error: 'Issue not found' };
            const updates = [];
            for (const field of ['title', 'context', 'status', 'priority', 'bound_solution_id', 'tags']) {
                if (body[field] !== undefined) {
                    issues[issueIndex][field] = body[field];
                    updates.push(field);
                }
            }
            issues[issueIndex].updated_at = new Date().toISOString();
            writeIssuesJsonl(issuesDir, issues);
            return { success: true, issueId, updated: updates };
        });
        return true;
    }
    return false;
}
//# sourceMappingURL=issue-routes.js.map