#国际化 (i18n)

// src/locales/zh-CN.ts
export default {
  'user.not_found':       { code: 40001, message: '用户不存在' },
  'user.email_taken':     { code: 40002, message: '邮箱已被注册' },
  'auth.token_expired':   { code: 40101, message: '登录已过期，请重新登录' },
  'auth.forbidden':       { code: 40301, message: '权限不足' },
  'balance.insufficient': { code: 20001, message: '余额不足，当前余额 {{balance}}' },
  'order.limit_exceeded': { code: 20002, message: '订单数量超出限制，最多 {{max}} 件' },
};

// src/locales/en-US.ts
export default {
  'user.not_found':       { code: 40001, message: 'User not found' },
  'user.email_taken':     { code: 40002, message: 'Email already registered' },
  'auth.token_expired':   { code: 40101, message: 'Session expired, please login again' },
  'auth.forbidden':       { code: 40301, message: 'Insufficient permissions' },
  'balance.insufficient': { code: 20001, message: 'Insufficient balance, current: {{balance}}' },
  'order.limit_exceeded': { code: 20002, message: 'Order quantity limit exceeded, max {{max}}' },
};

// src/routes/users.ts
import { defineRoutes } from 'vextjs';

export default defineRoutes((app) => {
  app.get('/:id', {
    validate: { param: { id: 'string!' } },
  }, async (req, res) => {
    const { id } = req.valid('param');
    const user = await app.services.user.findById(id);

    if (!user) {
      // 自动根据请求的 Accept-Language 返回对应语言的消息
      app.throw(404, 'user.not_found');
    }

    res.json(user);
  });
});

// src/locales/zh-CN.ts
export default {
  // key: { code: 业务错误码, message: 翻译消息 }
  'user.not_found':     { code: 40001, message: '用户不存在' },
  'user.email_taken':   { code: 40002, message: '邮箱已被注册' },
  'validate.required':  { code: 422,   message: '{{field}} 不能为空' },
};

// 语言包定义
export default {
  'balance.insufficient': { code: 20001, message: '余额不足，当前余额 {{balance}} 元' },
  'order.limit_exceeded': { code: 20002, message: '最多购买 {{max}} 件，当前已选 {{current}} 件' },
  'file.too_large':       { code: 20003, message: '文件大小不能超过 {{maxSize}}' },
};

// 在代码中传入变量
app.throw(400, 'balance.insufficient', { balance: 50 });
// → "余额不足，当前余额 50 元"

app.throw(400, 'order.limit_exceeded', { max: 10, current: 15 });
// → "最多购买 10 件，当前已选 15 件"

app.throw(400, 'file.too_large', { maxSize: '5MB' });
// → "文件大小不能超过 5MB"

// 使用 i18n key — 自动翻译
app.throw(404, 'user.not_found');
// zh-CN → { "code": 40001, "message": "用户不存在", "requestId": "..." }
// en-US → { "code": 40001, "message": "User not found", "requestId": "..." }

// 带变量
app.throw(400, 'balance.insufficient', { balance: 50 });
// zh-CN → { "code": 20001, "message": "余额不足，当前余额 50 元", "requestId": "..." }

// 带变量 + 业务错误码覆盖
app.throw(400, 'balance.insufficient', { balance: 50 }, 20001);

// 没有语言包时，message 字符串直接作为响应消息
app.throw(404, '用户不存在');
// → { "code": 404, "message": "用户不存在", "requestId": "..." }

// src/middlewares/detect-locale.ts
import { defineMiddleware } from 'vextjs';

export default defineMiddleware(async (req, res, next) => {
  // 优先级：URL 参数 > Cookie > Accept-Language
  let locale = req.query.lang
    || parseCookie(req.headers['cookie'])?.lang
    || parseAcceptLanguage(req.headers['accept-language']);

  // 写入请求上下文（需要 requestContext.enabled = true）
  // 后续 app.throw() 会自动使用此 locale
  (req as any).locale = locale || 'zh-CN';

  await next();
});

function parseCookie(cookie?: string) {
  if (!cookie) return {};
  return Object.fromEntries(
    cookie.split(';').map(c => c.trim().split('='))
  );
}

function parseAcceptLanguage(header?: string) {
  if (!header) return undefined;
  return header.split(',')[0]?.split(';')[0]?.trim();
}

// src/locales/zh-CN.ts
export default {
  // 用户模块
  'user.not_found':     { code: 40001, message: '用户不存在' },
  'user.email_taken':   { code: 40002, message: '邮箱已被注册' },

  // 认证模块
  'auth.unauthorized':  { code: 40100, message: '请先登录' },
  'auth.forbidden':     { code: 40300, message: '权限不足' },

  // 订单模块
  'order.not_found':    { code: 40004, message: '订单不存在' },
  'order.cancelled':    { code: 40005, message: '订单已取消，无法操作' },

  // 通用
  'server.error':       { code: 50000, message: '服务器内部错误，请稍后重试' },
};

// vext.config.ts
import { defineConfig } from 'vextjs';
import path from 'node:path';

export default defineConfig({
  // 方式 1（推荐）：传字符串路径 → schema-dsl 自动递归扫描
  locale: {
    default: 'zh-CN',
    supported: ['zh-CN', 'en-US'],
    directory: path.join(__dirname, 'src/locales'),
  },
});

// 方式 2：在插件中通过 schema-dsl API 配置
import { dsl } from 'schema-dsl';

dsl.config({
  i18n: './src/locales',  // 字符串路径，自动递归扫描
});

// 方式 3：使用 localesPath 对象形态
import { dsl } from 'schema-dsl';

dsl.config({
  i18n: { localesPath: './src/locales' },
});

import { dsl } from 'schema-dsl';

dsl.config({
  i18n: './src/locales',
  strict: true,  // 🔴 key 冲突时抛错阻断启动
});

// src/services/user.ts
import type { VextApp } from 'vextjs';

export default class UserService {
  constructor(private app: VextApp) {}

  async findById(id: string) {
    const user = await this.queryDatabase(id);
    if (!user) {
      this.app.throw(404, 'user.not_found');
    }
    return user;
  }

  async create(data: { name: string; email: string }) {
    const existing = await this.findByEmail(data.email);
    if (existing) {
      this.app.throw(409, 'user.email_taken');
    }

    const user = await this.insertDatabase(data);
    return user;
  }

  async withdraw(userId: string, amount: number) {
    const balance = await this.getBalance(userId);
    if (balance < amount) {
      // 带插值变量
      this.app.throw(400, 'balance.insufficient', { balance });
    }
    // ...
  }

  private async queryDatabase(id: string) { return null; }
  private async findByEmail(email: string) { return null; }
  private async insertDatabase(data: any) { return data; }
  private async getBalance(userId: string) { return 0; }
}

// src/locales/zh-CN.ts
export default {
  // 校验错误消息
  'validate.required':     { code: 422, message: '{{field}} 为必填项' },
  'validate.min_length':   { code: 422, message: '{{field}} 长度不能少于 {{min}} 个字符' },
  'validate.max_length':   { code: 422, message: '{{field}} 长度不能超过 {{max}} 个字符' },
  'validate.invalid_email':{ code: 422, message: '请输入有效的邮箱地址' },
  'validate.out_of_range': { code: 422, message: '{{field}} 必须在 {{min}} 到 {{max}} 之间' },

  // 业务错误消息
  'user.not_found':        { code: 40001, message: '用户不存在' },
  // ...
};

// src/config/default.ts
export default {
  locale: 'zh-CN',   // 默认语言
};

// src/locales/zh-CN.ts
export default {
  // ── 用户模块 ──
  'user.not_found':       { code: 40001, message: '用户不存在' },
  'user.email_taken':     { code: 40002, message: '该邮箱已被注册' },
  'user.disabled':        { code: 40003, message: '账号已被禁用，请联系管理员' },

  // ── 认证模块 ──
  'auth.unauthorized':    { code: 40100, message: '请先登录' },
  'auth.token_expired':   { code: 40101, message: '登录已过期，请重新登录' },
  'auth.invalid_token':   { code: 40102, message: '无效的登录凭证' },
  'auth.forbidden':       { code: 40301, message: '权限不足，需要 {{role}} 角色' },

  // ── 订单模块 ──
  'order.not_found':      { code: 40004, message: '订单不存在' },
  'order.already_paid':   { code: 40005, message: '订单已支付，请勿重复操作' },
  'order.cancelled':      { code: 40006, message: '订单已取消' },
  'order.limit_exceeded': { code: 20002, message: '单次最多购买 {{max}} 件商品' },

  // ── 支付模块 ──
  'balance.insufficient': { code: 20001, message: '余额不足，当前余额 {{balance}} 元，需要 {{required}} 元' },
  'payment.failed':       { code: 20003, message: '支付失败，请稍后重试' },
  'payment.timeout':      { code: 20004, message: '支付超时，请检查支付状态' },

  // ── 通用 ──
  'server.error':         { code: 50000, message: '服务器开小差了，请稍后重试' },
  'server.maintenance':   { code: 50001, message: '系统维护中，预计 {{time}} 恢复' },
};

// src/locales/en-US.ts
export default {
  // ── User ──
  'user.not_found':       { code: 40001, message: 'User not found' },
  'user.email_taken':     { code: 40002, message: 'Email already registered' },
  'user.disabled':        { code: 40003, message: 'Account has been disabled, please contact admin' },

  // ── Auth ──
  'auth.unauthorized':    { code: 40100, message: 'Please login first' },
  'auth.token_expired':   { code: 40101, message: 'Session expired, please login again' },
  'auth.invalid_token':   { code: 40102, message: 'Invalid credentials' },
  'auth.forbidden':       { code: 40301, message: 'Insufficient permissions, {{role}} role required' },

  // ── Order ──
  'order.not_found':      { code: 40004, message: 'Order not found' },
  'order.already_paid':   { code: 40005, message: 'Order already paid' },
  'order.cancelled':      { code: 40006, message: 'Order has been cancelled' },
  'order.limit_exceeded': { code: 20002, message: 'Maximum {{max}} items per order' },

  // ── Payment ──
  'balance.insufficient': { code: 20001, message: 'Insufficient balance. Current: {{balance}}, required: {{required}}' },
  'payment.failed':       { code: 20003, message: 'Payment failed, please try again later' },
  'payment.timeout':      { code: 20004, message: 'Payment timeout, please check payment status' },

  // ── General ──
  'server.error':         { code: 50000, message: 'Internal server error, please try again later' },
  'server.maintenance':   { code: 50001, message: 'System maintenance in progress, estimated recovery at {{time}}' },
};

// src/routes/orders.ts
import { defineRoutes } from 'vextjs';

export default defineRoutes((app) => {
  app.post('/', {
    validate: {
      body: {
        productId: 'string!',
        quantity: 'number:1-99!',
      },
    },
    middlewares: ['auth'],
    docs: { summary: '创建订单' },
  }, async (req, res) => {
    const data = req.valid('body');
    const userId = (req as any).user.id;

    try {
      const order = await app.services.order.create(userId, data);
      res.json(order, 201);
    } catch (err) {
      // app.throw() 抛出的错误会被框架自动捕获
      // i18n 翻译自动生效
      throw err;
    }
  });
});

// src/services/order.ts
import type { VextApp } from 'vextjs';

export default class OrderService {
  constructor(private app: VextApp) {}

  async create(userId: string, data: { productId: string; quantity: number }) {
    // 检查商品
    const product = await this.findProduct(data.productId);
    if (!product) {
      this.app.throw(404, 'order.not_found');
    }

    // 检查数量限制
    if (data.quantity > 10) {
      this.app.throw(400, 'order.limit_exceeded', { max: 10 });
    }

    // 检查余额
    const balance = await this.getBalance(userId);
    const required = product.price * data.quantity;
    if (balance < required) {
      this.app.throw(400, 'balance.insufficient', { balance, required });
      // zh-CN → "余额不足，当前余额 50 元，需要 100 元"
      // en-US → "Insufficient balance. Current: 50, required: 100"
    }

    // 创建订单...
    return { orderId: crypto.randomUUID(), status: 'pending' };
  }

  private async findProduct(id: string) {
    return { id, price: 10, name: 'Sample Product' };
  }

  private async getBalance(userId: string) {
    return 50;
  }
}

// ✅ 正确 — 不同错误使用不同 code
'user.not_found':   { code: 40001, message: '...' },
'user.email_taken': { code: 40002, message: '...' },

// ❌ 错误 — 不同错误使用相同 code
'user.not_found':   { code: 400, message: '...' },
'user.email_taken': { code: 400, message: '...' },

// ✅ 用户友好
{ message: '余额不足，当前余额 {{balance}} 元' }
{ message: '登录已过期，请重新登录' }

// ❌ 技术化表述
{ message: 'InsufficientBalanceException: current={{balance}}' }
{ message: 'JWT token expired at timestamp' }

// ✅ 使用模板变量
{ message: '最多购买 {{max}} 件' }
app.throw(400, 'order.limit_exceeded', { max: 10 });

// ❌ 避免拼接
app.throw(400, `最多购买 ${max} 件`);  // 无法 i18n