server.js

'use strict';

const express = require('express');
const fs = require('fs');
const path = require('path');
const os = require('os');
const crypto = require('crypto');

const { grade, validateExercise } = require('./lib/grader');

const LAN_MODE = process.argv.includes('--lan') || process.env.LAN === '1';
const PORT = Number(process.env.PORT) || 3000;
const HOST = LAN_MODE ? '0.0.0.0' : '127.0.0.1';
const DATA_DIR = path.join(__dirname, 'data');
const INDEX_FILE = path.join(DATA_DIR, 'index.json');
const ADMIN_PASSWORD = process.env.ADMIN_PASSWORD || '';

fs.mkdirSync(DATA_DIR, { recursive: true });

// ---------- 存储 ----------

function readIndex() {
  try {
    return JSON.parse(fs.readFileSync(INDEX_FILE, 'utf8'));
  } catch {
    return [];
  }
}

function writeIndex(list) {
  fs.writeFileSync(INDEX_FILE, JSON.stringify(list, null, 2));
}

function exercisePath(id) {
  return path.join(DATA_DIR, `exercise-${id}.json`);
}

function readExercise(id) {
  if (!/^[a-f0-9]{12}$/.test(id)) return null;
  try {
    return JSON.parse(fs.readFileSync(exercisePath(id), 'utf8'));
  } catch {
    return null;
  }
}

function seedSample() {
  if (readIndex().length > 0) return;
  const samplePath = path.join(__dirname, 'samples', 'sentence_analysis_template.json');
  try {
    const data = JSON.parse(fs.readFileSync(samplePath, 'utf8'));
    saveExercise('示例练习：Wikipedia Rabbit Hole', data);
    console.log('已导入示例练习');
  } catch (e) {
    console.warn('示例练习导入失败：', e.message);
  }
}

function saveExercise(title, data) {
  const id = crypto.randomBytes(6).toString('hex');
  const exercise = {
    id,
    title: title || `练习 ${new Date().toLocaleString('zh-CN')}`,
    createdAt: new Date().toISOString(),
    sentences: data.sentences.map((s, i) => ({
      sentence_id: s.sentence_id != null ? s.sentence_id : i + 1,
      text: s.text,
      components: s.components,
    })),
  };
  fs.writeFileSync(exercisePath(id), JSON.stringify(exercise, null, 2));
  const index = readIndex();
  index.unshift({
    id,
    title: exercise.title,
    createdAt: exercise.createdAt,
    sentenceCount: exercise.sentences.length,
  });
  writeIndex(index);
  return exercise;
}

// ---------- 应用 ----------

const app = express();
app.use(express.json({ limit: '5mb' }));
app.use(express.static(path.join(__dirname, 'public')));

function requireAdmin(req, res, next) {
  if (!ADMIN_PASSWORD) return next();
  if (req.get('x-admin-password') === ADMIN_PASSWORD) return next();
  res.status(401).json({ error: '管理员口令错误（请求头 x-admin-password）' });
}

// 练习列表
app.get('/api/exercises', (req, res) => {
  res.json({ exercises: readIndex(), adminProtected: Boolean(ADMIN_PASSWORD) });
});

// 练习内容 —— 只返回原文，正确答案保留在后台
app.get('/api/exercises/:id', (req, res) => {
  const ex = readExercise(req.params.id);
  if (!ex) return res.status(404).json({ error: '练习不存在' });
  res.json({
    id: ex.id,
    title: ex.title,
    sentences: ex.sentences.map((s) => ({ sentence_id: s.sentence_id, text: s.text })),
  });
});

// 提交标注，后台批改
app.post('/api/exercises/:id/submit', (req, res) => {
  const ex = readExercise(req.params.id);
  if (!ex) return res.status(404).json({ error: '练习不存在' });
  const annotations = req.body && req.body.annotations;
  if (!Array.isArray(annotations)) {
    return res.status(400).json({ error: '请求体需要 annotations 数组' });
  }
  res.json(grade(ex, annotations));
});

// 管理员：上传 JSON 生成练习
app.post('/api/admin/exercises', requireAdmin, (req, res) => {
  const { title, data } = req.body || {};
  const check = validateExercise(data);
  if (!check.ok) {
    return res.status(400).json({ error: 'JSON 格式有误', details: check.errors });
  }
  const ex = saveExercise(title, data);
  res.json({
    id: ex.id,
    title: ex.title,
    sentenceCount: ex.sentences.length,
    warnings: check.warnings,
  });
});

// 管理员：读取完整练习（含答案），用于编辑
app.get('/api/admin/exercises/:id', requireAdmin, (req, res) => {
  const ex = readExercise(req.params.id);
  if (!ex) return res.status(404).json({ error: '练习不存在' });
  res.json({
    id: ex.id,
    title: ex.title,
    createdAt: ex.createdAt,
    updatedAt: ex.updatedAt || null,
    data: { sentences: ex.sentences },
  });
});

// 管理员：修改练习（标题和/或答案 JSON），整体校验后覆盖保存
app.put('/api/admin/exercises/:id', requireAdmin, (req, res) => {
  const ex = readExercise(req.params.id);
  if (!ex) return res.status(404).json({ error: '练习不存在' });
  const { title, data } = req.body || {};
  const check = validateExercise(data);
  if (!check.ok) {
    return res.status(400).json({ error: 'JSON 格式有误', details: check.errors });
  }
  const updated = {
    id: ex.id,
    title: (title && String(title).trim()) || ex.title,
    createdAt: ex.createdAt,
    updatedAt: new Date().toISOString(),
    sentences: data.sentences.map((s, i) => ({
      sentence_id: s.sentence_id != null ? s.sentence_id : i + 1,
      text: s.text,
      components: s.components,
    })),
  };
  fs.writeFileSync(exercisePath(ex.id), JSON.stringify(updated, null, 2));
  const index = readIndex();
  const entry = index.find((e) => e.id === ex.id);
  if (entry) {
    entry.title = updated.title;
    entry.sentenceCount = updated.sentences.length;
    entry.updatedAt = updated.updatedAt;
    writeIndex(index);
  }
  res.json({
    id: updated.id,
    title: updated.title,
    sentenceCount: updated.sentences.length,
    warnings: check.warnings,
  });
});

// 管理员：删除练习
app.delete('/api/admin/exercises/:id', requireAdmin, (req, res) => {
  const id = req.params.id;
  const index = readIndex();
  const next = index.filter((e) => e.id !== id);
  if (next.length === index.length) return res.status(404).json({ error: '练习不存在' });
  writeIndex(next);
  try {
    fs.unlinkSync(exercisePath(id));
  } catch {}
  res.json({ ok: true });
});

seedSample();

app.listen(PORT, HOST, () => {
  console.log('');
  console.log('  英语语法结构标注练习');
  console.log('  ------------------------------------');
  console.log(`  本机访问:   http://localhost:${PORT}`);
  if (LAN_MODE) {
    const nets = os.networkInterfaces();
    for (const name of Object.keys(nets)) {
      for (const net of nets[name] || []) {
        if (net.family === 'IPv4' && !net.internal) {
          console.log(`  局域网访问: http://${net.address}:${PORT}   (${name})`);
        }
      }
    }
    console.log('  已开启局域网模式，同一网络下的手机 / 平板 / 电脑均可访问');
  } else {
    console.log('  提示: 使用 npm run lan 可开启局域网多终端访问');
  }
  console.log('');
});