cve-dashboard/backend/routes/compliance.js

// Compliance Routes — AEO metric tracking
// Handles xlsx upload/parse, non-compliant item history, and notes.
//
// Endpoints:
//   POST /preview          — parse xlsx, compute diff vs DB, return summary (no DB write)
//   POST /commit           — commit a previewed upload to DB
//   GET  /uploads          — list all uploads
//   GET  /summary          — metric health cards for a team (from latest upload)
//   GET  /items            — non-compliant devices grouped by hostname (?team=X&status=active)
//   GET  /items/:hostname  — detail panel: all metrics + notes + upload history for a device
//   POST /notes            — add a note to a (hostname, metric_id) pair
//   GET  /notes/:hostname/:metricId — notes for a specific device+metric

const express  = require('express');
const path     = require('path');
const fs       = require('fs');
const { spawn } = require('child_process');

const PARSER_SCRIPT = path.join(__dirname, '../scripts/parse_compliance_xlsx.py');
const PYTHON_BIN    = process.env.PYTHON_BIN || 'python3';
const TEMP_DIR      = path.join(process.cwd(), 'uploads', 'temp');
const ALLOWED_TEAMS = new Set(['STEAM', 'ACCESS-ENG', 'ACCESS-OPS', 'INTELDEV']);

// ---------------------------------------------------------------------------
// DB helpers
// ---------------------------------------------------------------------------
function dbRun(db, sql, params = []) {
    return new Promise((resolve, reject) => {
        db.run(sql, params, function (err) {
            if (err) reject(err);
            else resolve({ lastID: this.lastID, changes: this.changes });
        });
    });
}
function dbGet(db, sql, params = []) {
    return new Promise((resolve, reject) => {
        db.get(sql, params, (err, row) => { if (err) reject(err); else resolve(row || null); });
    });
}
function dbAll(db, sql, params = []) {
    return new Promise((resolve, reject) => {
        db.all(sql, params, (err, rows) => { if (err) reject(err); else resolve(rows || []); });
    });
}

// ---------------------------------------------------------------------------
// Run Python parser, return parsed object
// ---------------------------------------------------------------------------
function parseXlsx(filePath) {
    return new Promise((resolve, reject) => {
        const py = spawn(PYTHON_BIN, [PARSER_SCRIPT, filePath]);
        let out = '';
        let err = '';
        py.stdout.on('data', d => { out += d; });
        py.stderr.on('data', d => { err += d; });
        py.on('close', code => {
            if (code !== 0) return reject(new Error(err || `Parser exited with code ${code}`));
            try { resolve(JSON.parse(out)); }
            catch (e) { reject(new Error('Parser returned invalid JSON')); }
        });
        py.on('error', reject);
    });
}

// ---------------------------------------------------------------------------
// Validate that a temp file path is safely within uploads/temp/
// ---------------------------------------------------------------------------
function isSafeTempPath(filePath) {
    const resolved = path.resolve(filePath);
    return resolved.startsWith(TEMP_DIR + path.sep) && path.extname(resolved) === '.json';
}

// ---------------------------------------------------------------------------
// Compute diff: new / recurring / resolved
// ---------------------------------------------------------------------------
async function computeDiff(db, incomingItems) {
    const activeRows = await dbAll(db,
        `SELECT hostname, metric_id FROM compliance_items WHERE status = 'active'`
    );
    const activeKeys = new Set(activeRows.map(r => `${r.hostname}|||${r.metric_id}`));
    const newKeys    = new Set(incomingItems.map(i => `${i.hostname}|||${i.metric_id}`));

    let newCount = 0, recurringCount = 0, resolvedCount = 0;
    for (const k of newKeys)    { if (activeKeys.has(k)) recurringCount++; else newCount++; }
    for (const k of activeKeys) { if (!newKeys.has(k))   resolvedCount++; }

    return { newCount, recurringCount, resolvedCount };
}

// ---------------------------------------------------------------------------
// Write a parsed upload to the DB (within a transaction)
// ---------------------------------------------------------------------------
async function persistUpload(db, { items, summary, reportDate, filename, userId }) {
    // Pull current active items before we modify anything
    const activeRows = await dbAll(db,
        `SELECT id, hostname, metric_id, seen_count, first_seen_upload_id FROM compliance_items WHERE status = 'active'`
    );
    const activeMap = {};
    activeRows.forEach(r => { activeMap[`${r.hostname}|||${r.metric_id}`] = r; });

    const newKeys = new Set(items.map(i => `${i.hostname}|||${i.metric_id}`));

    await dbRun(db, 'BEGIN TRANSACTION');
    try {
        // 1. Insert the upload record
        const { lastID: uploadId } = await dbRun(db,
            `INSERT INTO compliance_uploads (filename, report_date, uploaded_by, uploaded_at, summary_json)
             VALUES (?, ?, ?, datetime('now'), ?)`,
            [filename, reportDate || null, userId || null, JSON.stringify(summary)]
        );

        let newCount = 0, recurringCount = 0, resolvedCount = 0;

        // 2. Upsert each incoming non-compliant item
        for (const item of items) {
            const key      = `${item.hostname}|||${item.metric_id}`;
            const existing = activeMap[key];
            const extraStr = JSON.stringify(item.extra_json || {});

            if (existing) {
                // Recurring — bump seen_count, refresh snapshot fields
                await dbRun(db,
                    `UPDATE compliance_items
                     SET upload_id = ?, seen_count = ?, ip_address = ?, device_type = ?, extra_json = ?
                     WHERE id = ?`,
                    [uploadId, existing.seen_count + 1, item.ip_address, item.device_type, extraStr, existing.id]
                );
                recurringCount++;
            } else {
                // New item (or previously resolved and re-appearing)
                await dbRun(db,
                    `INSERT INTO compliance_items
                     (upload_id, hostname, ip_address, device_type, team, metric_id, metric_desc,
                      category, extra_json, status, first_seen_upload_id, seen_count)
                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, 1)`,
                    [uploadId, item.hostname, item.ip_address, item.device_type, item.team,
                     item.metric_id, item.metric_desc, item.category, extraStr, uploadId]
                );
                newCount++;
            }
        }

        // 3. Mark items not present in this upload as resolved
        for (const [key, row] of Object.entries(activeMap)) {
            if (!newKeys.has(key)) {
                await dbRun(db,
                    `UPDATE compliance_items
                     SET status = 'resolved', resolved_upload_id = ?
                     WHERE id = ?`,
                    [uploadId, row.id]
                );
                resolvedCount++;
            }
        }

        // 4. Update upload with final counts
        await dbRun(db,
            `UPDATE compliance_uploads
             SET new_count = ?, resolved_count = ?, recurring_count = ?
             WHERE id = ?`,
            [newCount, resolvedCount, recurringCount, uploadId]
        );

        await dbRun(db, 'COMMIT');
        return { uploadId, newCount, recurringCount, resolvedCount };

    } catch (err) {
        await dbRun(db, 'ROLLBACK').catch(() => {});
        throw err;
    }
}

// ---------------------------------------------------------------------------
// Group flat compliance_items rows into per-device objects
// ---------------------------------------------------------------------------
function groupByHostname(rows, noteHostnames) {
    const deviceMap = {};

    for (const row of rows) {
        if (!deviceMap[row.hostname]) {
            deviceMap[row.hostname] = {
                hostname:        row.hostname,
                ip_address:      row.ip_address  || '',
                device_type:     row.device_type || '',
                team:            row.team        || '',
                status:          row.status,
                failing_metrics: [],
                seen_count:      row.seen_count  || 1,
                first_seen:      row.first_seen  || null,
                last_seen:       row.last_seen   || null,
                resolved_on:     row.resolved_on || null,
                has_notes:       noteHostnames.has(row.hostname),
            };
        }

        const dev = deviceMap[row.hostname];
        dev.failing_metrics.push({
            metric_id:   row.metric_id,
            metric_desc: row.metric_desc  || '',
            category:    row.category     || '',
        });
        // Use the highest seen_count and earliest first_seen across all metrics
        if ((row.seen_count || 1) > dev.seen_count) dev.seen_count = row.seen_count;
        if (row.first_seen && (!dev.first_seen || row.first_seen < dev.first_seen))
            dev.first_seen = row.first_seen;
        if (row.last_seen  && (!dev.last_seen  || row.last_seen  > dev.last_seen))
            dev.last_seen  = row.last_seen;
    }

    return Object.values(deviceMap);
}

// ---------------------------------------------------------------------------
// Router factory
// ---------------------------------------------------------------------------
function createComplianceRouter(db, upload, requireAuth, requireGroup) {
    const router = express.Router();

    // Idempotent column additions — errors mean column already exists, which is fine
    db.run(`ALTER TABLE compliance_items   ADD COLUMN seen_count   INTEGER DEFAULT 1`, () => {});
    db.run(`ALTER TABLE compliance_uploads ADD COLUMN summary_json TEXT`,              () => {});

    // All compliance routes require authentication
    router.use(requireAuth(db));

    // -----------------------------------------------------------------------
    // POST /preview
    // Parse the uploaded xlsx, compute diff, save parsed data to a temp JSON.
    // Returns diff counts + tempFile path for the commit step.
    // -----------------------------------------------------------------------
    router.post('/preview', requireGroup('Admin', 'Standard_User'), (req, res) => {
        upload.single('file')(req, res, async (uploadErr) => {
            if (uploadErr) {
                return res.status(400).json({ error: uploadErr.message });
            }
            if (!req.file) {
                return res.status(400).json({ error: 'No file uploaded' });
            }
            if (path.extname(req.file.originalname).toLowerCase() !== '.xlsx') {
                fs.unlink(req.file.path, () => {});
                return res.status(400).json({ error: 'File must be an .xlsx spreadsheet' });
            }

            try {
                const parsed = await parseXlsx(req.file.path);

                if (parsed.error) {
                    fs.unlink(req.file.path, () => {});
                    return res.status(422).json({ error: parsed.error });
                }

                const diff = await computeDiff(db, parsed.items);

                // Save parsed data to temp JSON — the commit step reads this
                if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
                const tempFilename = `compliance_preview_${Date.now()}_${Math.random().toString(36).slice(2)}.json`;
                const tempFilePath = path.join(TEMP_DIR, tempFilename);

                fs.writeFileSync(tempFilePath, JSON.stringify({
                    items:       parsed.items,
                    summary:     parsed.summary,
                    report_date: parsed.report_date,
                    filename:    req.file.originalname.replace(/[^\w.\-() ]/g, '_'),
                }));

                // Delete the original xlsx from temp (we only need the JSON now)
                fs.unlink(req.file.path, () => {});

                res.json({
                    diff: {
                        new_count:       diff.newCount,
                        recurring_count: diff.recurringCount,
                        resolved_count:  diff.resolvedCount,
                    },
                    tempFile:    tempFilePath,
                    filename:    req.file.originalname,
                    report_date: parsed.report_date,
                    total_items: parsed.total,
                });

            } catch (err) {
                fs.unlink(req.file.path, () => {});
                console.error('[Compliance] Preview error:', err.message);
                res.status(500).json({ error: 'Failed to parse file: ' + err.message });
            }
        });
    });

    // -----------------------------------------------------------------------
    // POST /commit
    // Commit a previewed upload to the DB.
    // Body: { tempFile, filename, report_date }
    // -----------------------------------------------------------------------
    router.post('/commit', requireGroup('Admin', 'Standard_User'), async (req, res) => {
        const { tempFile, filename, report_date } = req.body;

        if (!tempFile || typeof tempFile !== 'string') {
            return res.status(400).json({ error: 'tempFile is required' });
        }
        if (!isSafeTempPath(tempFile)) {
            return res.status(400).json({ error: 'Invalid tempFile path' });
        }
        if (!fs.existsSync(tempFile)) {
            return res.status(400).json({ error: 'Preview session expired — please upload again' });
        }

        let parsed;
        try {
            parsed = JSON.parse(fs.readFileSync(tempFile, 'utf8'));
        } catch {
            return res.status(400).json({ error: 'Could not read preview data — please upload again' });
        }

        try {
            const result = await persistUpload(db, {
                items:      parsed.items,
                summary:    parsed.summary,
                reportDate: report_date || parsed.report_date,
                filename:   filename   || parsed.filename,
                userId:     req.user?.id || null,
            });

            fs.unlink(tempFile, () => {});

            const upload = await dbGet(db,
                `SELECT id, filename, report_date, uploaded_at,
                        new_count, resolved_count, recurring_count
                 FROM compliance_uploads WHERE id = ?`,
                [result.uploadId]
            );

            res.json({ upload });

        } catch (err) {
            console.error('[Compliance] Commit error:', err.message);
            res.status(500).json({ error: 'Failed to commit upload: ' + err.message });
        }
    });

    // -----------------------------------------------------------------------
    // GET /uploads
    // List all uploads, most recent first.
    // -----------------------------------------------------------------------
    router.get('/uploads', async (req, res) => {
        try {
            const rows = await dbAll(db,
                `SELECT id, filename, report_date, uploaded_at,
                        new_count, resolved_count, recurring_count
                 FROM compliance_uploads
                 ORDER BY id DESC`
            );
            res.json({ uploads: rows });
        } catch (err) {
            console.error('[Compliance] GET /uploads error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /summary?team=STEAM
    // Return metric health rows for a team from the latest upload's summary_json.
    // -----------------------------------------------------------------------
    router.get('/summary', async (req, res) => {
        const team = req.query.team;
        if (team && !ALLOWED_TEAMS.has(team)) {
            return res.status(400).json({ error: 'Invalid team' });
        }

        try {
            const latestUpload = await dbGet(db,
                `SELECT id, summary_json, report_date, uploaded_at
                 FROM compliance_uploads ORDER BY id DESC LIMIT 1`
            );
            if (!latestUpload || !latestUpload.summary_json) {
                return res.json({ entries: [], overall_scores: {}, upload: null });
            }

            let summary;
            try { summary = JSON.parse(latestUpload.summary_json); }
            catch { return res.json({ entries: [], overall_scores: {}, upload: null }); }

            let entries = summary.entries || [];
            if (team) {
                entries = entries.filter(e => e.team === team);
            }

            res.json({
                entries,
                overall_scores: summary.overall_scores || {},
                upload: {
                    id:          latestUpload.id,
                    report_date: latestUpload.report_date,
                    uploaded_at: latestUpload.uploaded_at,
                },
            });
        } catch (err) {
            console.error('[Compliance] GET /summary error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /items?team=STEAM&status=active
    // Return non-compliant devices grouped by hostname.
    // -----------------------------------------------------------------------
    router.get('/items', async (req, res) => {
        const { team, status = 'active' } = req.query;

        if (!team) return res.status(400).json({ error: 'team is required' });
        if (!ALLOWED_TEAMS.has(team)) return res.status(400).json({ error: 'Invalid team' });
        if (!['active', 'resolved'].includes(status)) return res.status(400).json({ error: 'Invalid status' });

        try {
            const rows = await dbAll(db,
                `SELECT
                     ci.hostname, ci.ip_address, ci.device_type, ci.team,
                     ci.metric_id, ci.metric_desc, ci.category,
                     ci.status, ci.seen_count,
                     fu.report_date AS first_seen,
                     lu.report_date AS last_seen,
                     ru.report_date AS resolved_on
                 FROM compliance_items ci
                 LEFT JOIN compliance_uploads fu ON ci.first_seen_upload_id = fu.id
                 LEFT JOIN compliance_uploads lu ON ci.upload_id             = lu.id
                 LEFT JOIN compliance_uploads ru ON ci.resolved_upload_id    = ru.id
                 WHERE ci.team = ? AND ci.status = ?
                 ORDER BY ci.hostname, ci.metric_id`,
                [team, status]
            );

            // Fetch hostnames that have any notes (for the has_notes indicator)
            const noteRows = await dbAll(db,
                `SELECT DISTINCT hostname FROM compliance_notes`
            );
            const noteHostnames = new Set(noteRows.map(r => r.hostname));

            const devices = groupByHostname(rows, noteHostnames);

            res.json({ devices, team, status });

        } catch (err) {
            console.error('[Compliance] GET /items error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /items/:hostname
    // Detail panel: all metric rows for this hostname + notes + upload history.
    // -----------------------------------------------------------------------
    router.get('/items/:hostname', async (req, res) => {
        const hostname = req.params.hostname;
        if (!hostname || hostname.length > 300) {
            return res.status(400).json({ error: 'Invalid hostname' });
        }

        try {
            // All metric rows for this hostname
            const metricRows = await dbAll(db,
                `SELECT
                     ci.metric_id, ci.metric_desc, ci.category, ci.status,
                     ci.ip_address, ci.device_type, ci.team,
                     ci.seen_count, ci.extra_json,
                     fu.report_date AS first_seen,
                     fu.uploaded_at AS first_seen_at,
                     lu.report_date AS last_seen,
                     lu.uploaded_at AS last_seen_at,
                     ru.report_date AS resolved_on
                 FROM compliance_items ci
                 LEFT JOIN compliance_uploads fu ON ci.first_seen_upload_id = fu.id
                 LEFT JOIN compliance_uploads lu ON ci.upload_id             = lu.id
                 LEFT JOIN compliance_uploads ru ON ci.resolved_upload_id    = ru.id
                 WHERE ci.hostname = ?
                 ORDER BY ci.status DESC, ci.metric_id`,
                [hostname]
            );

            if (metricRows.length === 0) {
                return res.status(404).json({ error: 'Device not found' });
            }

            // Parse extra_json on each row
            const metrics = metricRows.map(r => ({
                ...r,
                extra: (() => { try { return JSON.parse(r.extra_json || '{}'); } catch { return {}; } })(),
                extra_json: undefined,
            }));

            // Notes (all metrics for this hostname, sorted newest first)
            const notes = await dbAll(db,
                `SELECT cn.id, cn.metric_id, cn.note, cn.created_at,
                        u.username AS created_by
                 FROM compliance_notes cn
                 LEFT JOIN users u ON cn.created_by = u.id
                 WHERE cn.hostname = ?
                 ORDER BY cn.created_at DESC`,
                [hostname]
            );

            // Derive device identity from the first active row, else any row
            const identity = metricRows.find(r => r.status === 'active') || metricRows[0];

            res.json({
                hostname,
                ip_address:  identity.ip_address  || '',
                device_type: identity.device_type || '',
                team:        identity.team        || '',
                metrics,
                notes,
            });

        } catch (err) {
            console.error('[Compliance] GET /items/:hostname error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // POST /notes
    // Add a note to a (hostname, metric_id) pair.
    // Body: { hostname, metric_id, note }
    // -----------------------------------------------------------------------
    router.post('/notes', requireGroup('Admin', 'Standard_User'), async (req, res) => {
        const { hostname, metric_id, note } = req.body;

        if (!hostname || typeof hostname !== 'string' || hostname.length > 300 || !/^[a-zA-Z0-9._-]+$/.test(hostname)) {
            return res.status(400).json({ error: 'Invalid hostname format' });
        }
        if (!metric_id || typeof metric_id !== 'string' || metric_id.length > 50) {
            return res.status(400).json({ error: 'Invalid metric_id' });
        }
        const noteText = String(note || '').trim().slice(0, 1000);
        if (!noteText) {
            return res.status(400).json({ error: 'Note cannot be empty' });
        }

        try {
            const { lastID } = await dbRun(db,
                `INSERT INTO compliance_notes (hostname, metric_id, note, created_by, created_at)
                 VALUES (?, ?, ?, ?, datetime('now'))`,
                [hostname, metric_id, noteText, req.user?.id || null]
            );

            const created = await dbGet(db,
                `SELECT cn.id, cn.hostname, cn.metric_id, cn.note, cn.created_at,
                        u.username AS created_by
                 FROM compliance_notes cn
                 LEFT JOIN users u ON cn.created_by = u.id
                 WHERE cn.id = ?`,
                [lastID]
            );

            res.status(201).json(created);

        } catch (err) {
            console.error('[Compliance] POST /notes error:', err.message);
            res.status(500).json({ error: 'Failed to save note' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /notes/:hostname/:metricId
    // Return all notes for a (hostname, metric_id) pair.
    // -----------------------------------------------------------------------
    router.get('/notes/:hostname/:metricId', async (req, res) => {
        const { hostname, metricId } = req.params;

        if (!hostname || hostname.length > 300) return res.status(400).json({ error: 'Invalid hostname' });
        if (!metricId || metricId.length > 50)  return res.status(400).json({ error: 'Invalid metricId' });

        try {
            const notes = await dbAll(db,
                `SELECT cn.id, cn.note, cn.created_at, u.username AS created_by
                 FROM compliance_notes cn
                 LEFT JOIN users u ON cn.created_by = u.id
                 WHERE cn.hostname = ? AND cn.metric_id = ?
                 ORDER BY cn.created_at DESC`,
                [hostname, metricId]
            );
            res.json({ notes });
        } catch (err) {
            console.error('[Compliance] GET /notes error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /trends
    // Per-upload active totals + per-team counts for time-series charts.
    // Returns rows ordered ascending by report_date.
    // -----------------------------------------------------------------------
    router.get('/trends', async (req, res) => {
        try {
            const uploads = await dbAll(db,
                `SELECT id, report_date,
                        COALESCE(new_count, 0)       AS new_count,
                        COALESCE(recurring_count, 0) AS recurring_count,
                        COALESCE(resolved_count, 0)  AS resolved_count,
                        COALESCE(new_count, 0) + COALESCE(recurring_count, 0) AS total_active
                 FROM compliance_uploads
                 ORDER BY report_date ASC`
            );

            if (uploads.length === 0) return res.json({ trends: [] });

            // Per-team active counts — items whose upload_id matches the upload
            // (recurring items have upload_id bumped each cycle, so this is accurate)
            const teamRows = await dbAll(db,
                `SELECT ci.upload_id, ci.team, COUNT(ci.id) AS count
                 FROM compliance_items ci
                 WHERE ci.team IS NOT NULL
                 GROUP BY ci.upload_id, ci.team`
            );

            const teamMap = {};
            teamRows.forEach(r => {
                if (!teamMap[r.upload_id]) teamMap[r.upload_id] = {};
                teamMap[r.upload_id][r.team] = r.count;
            });

            const trends = uploads.map(u => ({
                report_date:      u.report_date,
                new_count:        u.new_count,
                recurring_count:  u.recurring_count,
                resolved_count:   u.resolved_count,
                total_active:     u.total_active,
                STEAM:            teamMap[u.id]?.STEAM            || 0,
                'ACCESS-ENG':     teamMap[u.id]?.['ACCESS-ENG']   || 0,
                'ACCESS-OPS':     teamMap[u.id]?.['ACCESS-OPS']   || 0,
                INTELDEV:         teamMap[u.id]?.INTELDEV          || 0,
            }));

            res.json({ trends });
        } catch (err) {
            console.error('[Compliance] GET /trends error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /mttr
    // Mean time to resolution (calendar days) per team, for resolved items.
    // -----------------------------------------------------------------------
    router.get('/mttr', async (req, res) => {
        try {
            const rows = await dbAll(db,
                `SELECT
                     ci.team,
                     ROUND(AVG(JULIANDAY(ru.report_date) - JULIANDAY(fu.report_date)), 1) AS avg_days,
                     COUNT(*) AS resolved_count
                 FROM compliance_items ci
                 JOIN compliance_uploads fu ON ci.first_seen_upload_id = fu.id
                 JOIN compliance_uploads ru ON ci.resolved_upload_id    = ru.id
                 WHERE ci.resolved_upload_id IS NOT NULL
                   AND fu.report_date IS NOT NULL
                   AND ru.report_date IS NOT NULL
                 GROUP BY ci.team
                 ORDER BY avg_days DESC`
            );
            res.json({ mttr: rows });
        } catch (err) {
            console.error('[Compliance] GET /mttr error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /top-recurring
    // Active findings grouped by team + metric_id, sorted by seen_count desc.
    // Identifies chronic compliance gaps that keep reappearing.
    // -----------------------------------------------------------------------
    router.get('/top-recurring', async (req, res) => {
        try {
            const rows = await dbAll(db,
                `SELECT team, metric_id, metric_desc, seen_count, COUNT(*) AS host_count
                 FROM compliance_items
                 WHERE status = 'active'
                 GROUP BY team, metric_id
                 ORDER BY seen_count DESC, host_count DESC
                 LIMIT 20`
            );
            res.json({ items: rows });
        } catch (err) {
            console.error('[Compliance] GET /top-recurring error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    // -----------------------------------------------------------------------
    // GET /category-trend
    // Active item counts per category per upload, for stacked area chart.
    // -----------------------------------------------------------------------
    router.get('/category-trend', async (req, res) => {
        try {
            const rows = await dbAll(db,
                `SELECT cu.report_date, COALESCE(ci.category, 'Unknown') AS category, COUNT(ci.id) AS count
                 FROM compliance_uploads cu
                 JOIN compliance_items ci ON ci.upload_id = cu.id
                 GROUP BY cu.id, category
                 ORDER BY cu.report_date ASC`
            );
            res.json({ categoryTrend: rows });
        } catch (err) {
            console.error('[Compliance] GET /category-trend error:', err.message);
            res.status(500).json({ error: 'Database error' });
        }
    });

    return router;
}

module.exports = createComplianceRouter;