#Internationalization (i18n)

// src/locales/zh-CN.ts
export default {
  "user.not_found": { code: 40001, message: "The user does not exist" },
  "user.email_taken": { code: 40002, message: "Email has been registered" },
  "auth.token_expired": { code: 40101, message: "Login has expired, please log in again" },
  "auth.forbidden": { code: 40301, message: "Insufficient permissions" },
  "balance.insufficient": {
    code: 20001,
    message: "Insufficient balance, current balance {{balance}}",
  },
  "order.limit_exceeded": {
    code: 20002,
    message: "The order quantity exceeds the limit, up to {{max}} pieces",
  },
};

// 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) {
        // Automatically return messages in the corresponding language based on the requested Accept-Language
        app.throw(404, "user.not_found");
      }

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

// src/locales/zh-CN.ts
export default {
  // key: { code: business error code, message: translation message }
  "user.not_found": { code: 40001, message: "The user does not exist" },
  "user.email_taken": { code: 40002, message: "Email has been registered" },
  "validate.required": { code: 422, message: "{{field}} cannot be empty" },
};

// Language pack definition
export default {
  "balance.insufficient": {
    code: 20001,
    message: "Insufficient balance, current balance is {{balance}} yuan",
  },
  "order.limit_exceeded": {
    code: 20002,
    message: "Maximum purchase of {{max}} items, currently {{current}} items selected",
  },
  "file.too_large": { code: 20003, message: "The file size cannot exceed {{maxSize}}" },
};

// Pass in variables in the code
app.throw(400, "balance.insufficient", { balance: 50 });
// → "Insufficient balance, current balance is 50 yuan"app.throw(400, "order.limit_exceeded", { max: 10, current: 15 });
// → "Maximum purchase is 10 items, currently 15 items have been selected"

app.throw(400, "file.too_large", { maxSize: "5MB" });
// → "File size cannot exceed 5MB"

// Use i18n key - automatic translation
app.throw(404, "user.not_found");
// zh-CN → { "code": 40001, "message": "The user does not exist", "requestId": "..." }
// en-US → { "code": 40001, "message": "User not found", "requestId": "..." }

//With variables
app.throw(400, "balance.insufficient", { balance: 50 });
// zh-CN → { "code": 20001, "message": "Insufficient balance, current balance is 50 yuan", "requestId": "..." }

//With variables + business error code coverage
app.throw(400, "balance.insufficient", { balance: 50 }, 20001);

// When there is no language pack, the message string is directly used as the response message
app.throw(404, "User does not exist");
// → { "code": 404, "message": "User does not exist", "requestId": "..." }

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

export default defineMiddleware(async (req, res, next) => {
  // Priority: URL Parameters > Cookie > Accept-Language
  let locale =
    req.query.lang ||
    parseCookie(req.headers["cookie"])?.lang ||
    parseAcceptLanguage(req.headers["accept-language"]);

  //Write request context (requires requestContext.enabled = true)
  // Subsequent app.throw() will automatically use this 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 module
  "user.not_found": { code: 40001, message: "The user does not exist" },
  "user.email_taken": { code: 40002, message: "Email has been registered" },

  // Authentication module
  "auth.unauthorized": { code: 40100, message: "Please log in first" },
  "auth.forbidden": { code: 40300, message: "Insufficient permissions" },

  // order module
  "order.not_found": { code: 40004, message: "Order does not exist" },
  "order.cancelled": { code: 40005, message: "The order has been canceled and cannot be operated" },

  // Universal
  "server.error": { code: 50000, message: "Server internal error, please try again later" },
};

// src/config/default.ts
import path from "node:path";

export default {
  // Method 1 (recommended): Pass string path → schema-dsl automatic recursive scan
  locale: {
    default: "zh-CN",
    supported: ["zh-CN", "en-US"],
    directory: path.join(__dirname, "src/locales"),
  },
};

// Method 2: Configure through the schema-dsl API in the plug-in
import { dsl } from "schema-dsl";

dsl.config({
  i18n: "./src/locales", // String path, automatic recursive scanning
});

// Method 3: Use localesPath object form
import { dsl } from "schema-dsl";

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

import { dsl } from "schema-dsl";

dsl.config({
  i18n: "./src/locales",
  strict: true, // When 🔴 key conflicts, an error is thrown and the startup is blocked.
});

// 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) {
      //With interpolation variables
      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 {
  //Verify error message
  "validate.required": { code: 422, message: "{{field}} is required" },
  "validate.min_length": {
    code: 422,
    message: "{{field}} cannot be less than {{min}} characters in length",
  },
  "validate.max_length": {
    code: 422,
    message: "{{field}} cannot be longer than {{max}} characters",
  },
  "validate.invalid_email": { code: 422, message: "Please enter a valid email address" },
  "validate.out_of_range": {
    code: 422,
    message: "{{field}} must be between {{min}} and {{max}}",
  },

  //Business error message
  "user.not_found": { code: 40001, message: "The user does not exist" },
  // ...
};

// src/config/default.ts
export default {
  locale: "zh-CN", //Default language
};

// src/locales/zh-CN.ts
export default {
  // ── User module ──
  "user.not_found": { code: 40001, message: "The user does not exist" },
  "user.email_taken": { code: 40002, message: "This email has been registered" },
  "user.disabled": { code: 40003, message: "The account has been disabled, please contact the administrator" },

  //──Authentication module──
  "auth.unauthorized": { code: 40100, message: "Please log in first" },
  "auth.token_expired": { code: 40101, message: "Login has expired, please log in again" },
  "auth.invalid_token": { code: 40102, message: "Invalid login credentials" },
  "auth.forbidden": { code: 40301, message: "Insufficient permissions, {{role}} required" },

  //──Order module──
  "order.not_found": { code: 40004, message: "Order does not exist" },
  "order.already_paid": { code: 40005, message: "The order has been paid, please do not repeat the operation" },
  "order.cancelled": { code: 40006, message: "Order has been canceled" },
  "order.limit_exceeded": {
    code: 20002,
    message: "A maximum of {{max}} items can be purchased at a time",
  },// ── Payment module ──
  "balance.insufficient": {
    code: 20001,
    message: "The balance is insufficient, the current balance is {{balance}} yuan, and {{required}} yuan is needed",
  },
  "payment.failed": { code: 20003, message: "Payment failed, please try again later" },
  "payment.timeout": { code: 20004, message: "Payment timeout, please check the payment status" },

  // ── General ──
  "server.error": { code: 50000, message: "The server is out of service, please try again later" },
  "server.maintenance": {
    code: 50001,
    message: "The system is under maintenance and is expected to be restored in {{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 canceled" },
  "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: "Create order" },
    },
    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) {
        // Errors thrown by app.throw() will be automatically caught by the framework
        // i18n translation takes effect automatically
        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 }) {
    // Check the product
    const product = await this.findProduct(data.productId);
    if (!product) {
      this.app.throw(404, "order.not_found");
    }

    // Check quantity limit
    if (data.quantity > 10) {
      this.app.throw(400, "order.limit_exceeded", { max: 10 });
    }

    // Check balance
    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 → "Insufficient balance, current balance is 50 yuan, 100 yuan is needed"
      // en-US → "Insufficient balance. Current: 50, required: 100"
    }//Create order...
    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;
  }
}

// ✅ Correct — use different codes for different errors
'user.not_found': { code: 40001, message: '...' },
'user.email_taken': { code: 40002, message: '...' },

// ❌ Error — use the same code for different errors
'user.not_found': { code: 400, message: '...' },
'user.email_taken': { code: 400, message: '...' },

// ✅ User friendly
{
  message: "Insufficient balance, current balance is {{balance}} yuan";
}
{
  message: "Login has expired, please log in again";
}

// ❌ Technical expression
{
  message: "InsufficientBalanceException: current={{balance}}";
}
{
  message: "JWT token expired at timestamp";
}

// ✅ Use template variables
{
  message: "Buy up to {{max}} items";
}
app.throw(400, "order.limit_exceeded", { max: 10 });

// ❌ Avoid splicing
app.throw(400, `Maximum purchase of ${max} items`); // Unable i18n