snakkimo-API/src/routes/categories.js

const router = require('express').Router();
const { query } = require('../db');
const { runCategorizationTick, classifyWordsSync } = require('../lib/classifyWords');

const STATUSES = ['requested', 'blocked', 'published'];

// POST /api/categories/auto-assign — Kategorisierung anstoßen.
//   ?sync=true            → sofortiger One-Shot-Backfill bestehender Wörter (synchron, kein 24h-Verzug)
//   ?sync=true&reset=true → bestehende Zuordnungen verwerfen und alles neu klassifizieren
//   sonst                 → ein asynchroner Batch-Tick (submit/collect über die Message Batches API)
router.post('/auto-assign', async (req, res, next) => {
  try {
    const sync = req.query.sync === 'true' || req.body?.sync === true;
    const reset = req.query.reset === 'true' || req.body?.reset === true;
    const result = sync ? await classifyWordsSync({ reset }) : await runCategorizationTick();
    res.json(result);
  } catch (err) { next(err); }
});

const STATUS_TIMESTAMP = {
  requested: 'requested_at',
  published: 'published_at',
  blocked:   'blocked_at',
};

// GET /api/categories
router.get('/', async (req, res, next) => {
  try {
    const { status, search, limit = 50, offset = 0 } = req.query;
    const params = [Math.min(parseInt(limit), 500), parseInt(offset)];
    const conditions = [];
    if (status) { conditions.push(`c.status = $${params.length + 1}`); params.push(status); }
    if (search) {
      const p = `%${search.toLowerCase()}%`;
      conditions.push(`(lower(c.name_de) LIKE $${params.length + 1} OR lower(c.name_en) LIKE $${params.length + 1} OR lower(c.name_sv) LIKE $${params.length + 1})`);
      params.push(p);
    }
    const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
    const result = await query(
      `SELECT c.*,
        COALESCE(json_agg(DISTINCT w.id) FILTER (WHERE w.id IS NOT NULL), '[]') AS word_ids
       FROM categories c
       LEFT JOIN word_categories wc ON wc.category_id = c.id
       LEFT JOIN words w ON w.id = wc.word_id
       ${where}
       GROUP BY c.id
       ORDER BY c.created_at DESC
       LIMIT $1 OFFSET $2`,
      params
    );
    res.json(result.rows);
  } catch (err) { next(err); }
});

// GET /api/categories/:id
router.get('/:id', async (req, res, next) => {
  try {
    const result = await query(
      `SELECT c.*,
        COALESCE(json_agg(DISTINCT w.id) FILTER (WHERE w.id IS NOT NULL), '[]') AS word_ids
       FROM categories c
       LEFT JOIN word_categories wc ON wc.category_id = c.id
       LEFT JOIN words w ON w.id = wc.word_id
       WHERE c.id = $1
       GROUP BY c.id`,
      [req.params.id]
    );
    if (!result.rows.length) return res.status(404).json({ error: 'Not found' });
    res.json(result.rows[0]);
  } catch (err) { next(err); }
});

// POST /api/categories
router.post('/', async (req, res, next) => {
  try {
    const { titel_de, titel_en, titel_sv, difficulty_level } = req.body;
    const result = await query(
      `INSERT INTO categories (titel_de, titel_en, titel_sv, difficulty_level, requested_at)
       VALUES ($1, $2, $3, $4, NOW()) RETURNING *`,
      [titel_de || null, titel_en || null, titel_sv || null, difficulty_level || null]
    );
    res.status(201).json({ ...result.rows[0], word_ids: [] });
  } catch (err) { next(err); }
});

// PATCH /api/categories/:id
router.patch('/:id', async (req, res, next) => {
  try {
    const allowed = ['titel_de', 'titel_en', 'titel_sv', 'status',
                     'difficulty_level', 'requested_at', 'published_at', 'blocked_at'];
    const fields = Object.keys(req.body).filter(k => allowed.includes(k));
    if (!fields.length) return res.status(400).json({ error: 'No valid fields provided' });

    if (req.body.status && !STATUSES.includes(req.body.status))
      return res.status(400).json({ error: `status must be one of: ${STATUSES.join(', ')}` });

    const tsField = STATUS_TIMESTAMP[req.body.status];
    if (tsField && !req.body[tsField]) {
      fields.push(tsField);
      req.body[tsField] = new Date().toISOString();
    }

    const setClauses = fields.map((f, i) => `${f} = $${i + 1}`).join(', ');
    const values = [...fields.map(f => req.body[f]), req.params.id];
    const result = await query(
      `UPDATE categories SET ${setClauses} WHERE id = $${fields.length + 1} RETURNING *`,
      values
    );
    if (!result.rows.length) return res.status(404).json({ error: 'Not found' });
    res.json(result.rows[0]);
  } catch (err) { next(err); }
});

// DELETE /api/categories/:id
router.delete('/:id', async (req, res, next) => {
  try {
    const result = await query('DELETE FROM categories WHERE id = $1 RETURNING id', [req.params.id]);
    if (!result.rows.length) return res.status(404).json({ error: 'Not found' });
    res.status(204).end();
  } catch (err) { next(err); }
});

module.exports = router;