import "server-only";

import { readFile, rename, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { isPostgresBackend, queryDatabase } from "@/lib/server/database";
import { createId } from "@/lib/server/ids";
import { dataDir, ensureRuntimeDirs } from "@/lib/server/runtime";
import type {
  BillingCurrency,
  BillingLedgerEntry,
  BillingLedgerKind,
  BillingParameterDimension,
  BillingPriceRule,
  BillingRuleConditions,
  OrganizationWallet
} from "@/lib/types";

const STORE_FILE = "billing-state.json";
let localWriteQueue: Promise<unknown> = Promise.resolve();

type BillingState = {
  priceRules: BillingPriceRule[];
  wallets: OrganizationWallet[];
  ledgerEntries: BillingLedgerEntry[];
};

export type BillingPriceRuleInput = Omit<BillingPriceRule, "id" | "createdAt" | "updatedAt"> & Partial<Pick<BillingPriceRule, "id" | "createdAt" | "updatedAt">>;

export type BillingLedgerFilters = {
  organizationId?: string;
  accountId?: string;
  jobId?: string;
  kind?: BillingLedgerKind;
  limit?: number;
};

export type WalletEntryInput = {
  organizationId: string;
  accountId?: string;
  jobId?: string;
  kind: BillingLedgerKind;
  deltaFen: number;
  currency?: BillingCurrency;
  idempotencyKey: string;
  description: string;
  metadata?: Record<string, unknown>;
};

export class BillingStoreError extends Error {
  status: number;

  constructor(message: string, status = 400) {
    super(normalizeBillingStoreErrorMessage(message));
    this.name = "BillingStoreError";
    this.status = status;
  }
}

export class InsufficientBalanceError extends BillingStoreError {
  constructor(message = "余额不足，请先充值。") {
    super(message, 402);
    this.name = "InsufficientBalanceError";
  }
}

export async function listBillingPriceRules(options: { includeDisabled?: boolean } = {}): Promise<BillingPriceRule[]> {
  if (isPostgresBackend()) {
    const result = await billingQuery(
      `SELECT * FROM billing_price_rules
       WHERE ($1::boolean OR enabled = true)
       ORDER BY provider ASC, capability ASC, updated_at DESC`,
      [Boolean(options.includeDisabled)]
    );
    return result.map(priceRuleFromRow);
  }
  const state = await readState();
  return state.priceRules
    .filter((rule) => options.includeDisabled || rule.enabled)
    .sort((left, right) => left.provider.localeCompare(right.provider) || left.capability.localeCompare(right.capability) || right.updatedAt.localeCompare(left.updatedAt));
}

export async function getBillingPriceRule(id: string): Promise<BillingPriceRule | null> {
  if (isPostgresBackend()) {
    const [row] = await billingQuery("SELECT * FROM billing_price_rules WHERE id = $1 LIMIT 1", [id]);
    return row ? priceRuleFromRow(row) : null;
  }
  const state = await readState();
  return state.priceRules.find((rule) => rule.id === id) || null;
}

export async function createBillingPriceRule(input: BillingPriceRuleInput): Promise<BillingPriceRule> {
  const now = new Date().toISOString();
  const rule: BillingPriceRule = {
    ...input,
    id: input.id || createId("price"),
    createdAt: input.createdAt || now,
    updatedAt: input.updatedAt || now
  };
  if (isPostgresBackend()) {
    const row = priceRuleToRow(rule);
    const [created] = await billingQuery(
      `INSERT INTO billing_price_rules (
         id, provider, capability, req_key, variant_key, unit, standard_unit_price_fen,
         markup_multiplier, enabled, conditions, quantity_source, priority, note, source,
         parameter_dimensions, created_at, updated_at
       ) VALUES (
         $1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb, $11, $12, $13,
         $14::jsonb, $15::jsonb, $16, $17
       ) RETURNING *`,
      [row.id, row.provider, row.capability, row.req_key, row.variant_key, row.unit,
        row.standard_unit_price_fen, row.markup_multiplier, row.enabled, JSON.stringify(row.conditions),
        row.quantity_source, row.priority, row.note, JSON.stringify(row.source),
        JSON.stringify(row.parameter_dimensions), row.created_at, row.updated_at],
      true
    );
    return priceRuleFromRow(created);
  }
  return mutateLocalState((state) => {
    if (state.priceRules.some((item) => item.id === rule.id)) throw new BillingStoreError("计费规则 ID 已存在。", 409);
    if (state.priceRules.some((item) => priceRuleMatchKey(item) === priceRuleMatchKey(rule))) {
      throw new BillingStoreError("相同服务商、能力、模型和变体的计费规则已存在。", 409);
    }
    state.priceRules.unshift(rule);
    return rule;
  });
}

export async function updateBillingPriceRule(id: string, patch: Partial<Omit<BillingPriceRule, "id" | "createdAt" | "updatedAt">>): Promise<BillingPriceRule | null> {
  const existing = await getBillingPriceRule(id);
  if (!existing) return null;
  const updated: BillingPriceRule = { ...existing, ...patch, updatedAt: new Date().toISOString() };
  if (isPostgresBackend()) {
    const row = priceRuleToRow(updated);
    const [saved] = await billingQuery(
      `UPDATE billing_price_rules SET
         provider = $2, capability = $3, req_key = $4, variant_key = $5, unit = $6,
         standard_unit_price_fen = $7, markup_multiplier = $8, enabled = $9,
         conditions = $10::jsonb, quantity_source = $11, priority = $12, note = $13,
         source = $14::jsonb, parameter_dimensions = $15::jsonb, updated_at = $16
       WHERE id = $1 RETURNING *`,
      [id, row.provider, row.capability, row.req_key, row.variant_key, row.unit,
        row.standard_unit_price_fen, row.markup_multiplier, row.enabled, JSON.stringify(row.conditions),
        row.quantity_source, row.priority, row.note, JSON.stringify(row.source),
        JSON.stringify(row.parameter_dimensions), row.updated_at],
      true
    );
    return saved ? priceRuleFromRow(saved) : null;
  }
  return mutateLocalState((state) => {
    const index = state.priceRules.findIndex((item) => item.id === id);
    if (index === -1) return null;
    if (state.priceRules.some((item) => item.id !== id && priceRuleMatchKey(item) === priceRuleMatchKey(updated))) {
      throw new BillingStoreError("相同服务商、能力、模型和参数条件的计费规则已存在。", 409);
    }
    state.priceRules[index] = updated;
    return updated;
  });
}

export async function updateBillingPriceTierMultiplier(input: {
  ruleId: string;
  dimensionKey: string;
  tierValue: string;
  markupMultiplier: number;
}): Promise<BillingPriceRule | null> {
  if (!Number.isFinite(input.markupMultiplier) || input.markupMultiplier < 1 || input.markupMultiplier > 1000) {
    throw new BillingStoreError("上浮倍率必须在 1.00 至 1000.00 之间。", 400);
  }
  const existing = await getBillingPriceRule(input.ruleId);
  if (!existing) return null;
  const dimensions = existing.parameterDimensions || [];
  const dimension = dimensions.find((item) => item.key === input.dimensionKey);
  if (!dimension) throw new BillingStoreError("平台价格参数不存在。", 404);
  const tierIndex = dimension.tiers.findIndex((item) => String(item.value) === input.tierValue);
  if (tierIndex === -1) throw new BillingStoreError("平台价格档位不存在。", 404);
  const nextDimensions = dimensions.map((item) => item.key !== input.dimensionKey ? item : {
    ...item,
    tiers: item.tiers.map((tier, index) => index === tierIndex ? { ...tier, markupMultiplier: input.markupMultiplier } : tier)
  });
  return updateBillingPriceRule(input.ruleId, { parameterDimensions: nextDimensions });
}

export async function getOrganizationWallet(organizationId: string): Promise<OrganizationWallet> {
  if (isPostgresBackend()) {
    const [row] = await billingQuery("SELECT * FROM billing_wallets WHERE organization_id = $1 LIMIT 1", [organizationId]);
    return row ? walletFromRow(row) : emptyWallet(organizationId);
  }
  const state = await readState();
  return state.wallets.find((wallet) => wallet.organizationId === organizationId) || emptyWallet(organizationId);
}

export async function listOrganizationWallets(): Promise<OrganizationWallet[]> {
  if (isPostgresBackend()) {
    return (await billingQuery("SELECT * FROM billing_wallets ORDER BY updated_at DESC")).map(walletFromRow);
  }
  const state = await readState();
  return [...state.wallets].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
}

export async function postWalletEntry(input: WalletEntryInput): Promise<{ entry: BillingLedgerEntry; wallet: OrganizationWallet }> {
  const deltaFen = Math.trunc(input.deltaFen);
  if (!Number.isSafeInteger(deltaFen) || deltaFen === 0) throw new BillingStoreError("账务变动金额必须是安全整数且不能为 0。", 400);
  if (!input.organizationId) throw new BillingStoreError("组织 ID 不能为空。", 400);
  if (!input.idempotencyKey) throw new BillingStoreError("账务幂等键不能为空。", 400);
  const accountId = effectiveLedgerAccountId(input);
  const currency = input.currency || "CNY";
  const metadata = input.metadata || {};
  if (isPostgresBackend()) {
    const [row] = await billingQuery(
      `SELECT * FROM billing_post_wallet_entry(
         $1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb
       )`,
      [createId("ledger"), input.organizationId, accountId || null, input.jobId || null,
        input.kind, deltaFen, currency, input.idempotencyKey, input.description, JSON.stringify(metadata)]
    ).catch((error: unknown) => {
      if (error instanceof BillingStoreError && /BILLING_INSUFFICIENT_BALANCE/i.test(error.message)) throw new InsufficientBalanceError();
      if (error instanceof BillingStoreError && /BILLING_IDEMPOTENCY_PAYLOAD_MISMATCH/i.test(error.message)) {
        throw new BillingStoreError("账务幂等键已被不同请求使用。", 409);
      }
      throw error;
    });
    if (!row) throw new BillingStoreError("账务服务未返回流水结果。", 500);
    return {
      entry: ledgerFromRpcRow(row, input, accountId),
      wallet: walletFromRpcRow(row, input.organizationId)
    };
  }

  return mutateLocalState((state) => {
    const existing = state.ledgerEntries.find(
      (entry) => entry.organizationId === input.organizationId && entry.idempotencyKey === input.idempotencyKey
    );
    if (existing) {
      if (existing.accountId !== accountId
        || existing.jobId !== input.jobId
        || existing.kind !== input.kind
        || existing.deltaFen !== deltaFen
        || existing.currency !== currency) {
        throw new BillingStoreError("账务幂等键已被不同请求使用。", 409);
      }
      const wallet = state.wallets.find((item) => item.organizationId === input.organizationId) || emptyWallet(input.organizationId);
      return { entry: existing, wallet };
    }
    const wallet = state.wallets.find((item) => item.organizationId === input.organizationId) || emptyWallet(input.organizationId);
    if (deltaFen < 0 && wallet.balanceFen < Math.abs(deltaFen)) throw new InsufficientBalanceError();
    const now = new Date().toISOString();
    const nextWallet: OrganizationWallet = {
      ...wallet,
      balanceFen: safeInteger(wallet.balanceFen + deltaFen, "local billing wallet balance"),
      totalRechargedFen: safeInteger(wallet.totalRechargedFen + (input.kind === "recharge" && deltaFen > 0 ? deltaFen : 0), "local billing wallet total recharged"),
      totalChargedFen: safeInteger(wallet.totalChargedFen + (input.kind === "charge" && deltaFen < 0 ? Math.abs(deltaFen) : 0), "local billing wallet total charged"),
      updatedAt: now
    };
    const entry: BillingLedgerEntry = {
      id: createId("ledger"),
      organizationId: input.organizationId,
      accountId,
      jobId: input.jobId,
      kind: input.kind,
      deltaFen,
      balanceAfterFen: nextWallet.balanceFen,
      currency,
      idempotencyKey: input.idempotencyKey,
      description: input.description,
      metadata,
      createdAt: now
    };
    const walletIndex = state.wallets.findIndex((item) => item.organizationId === input.organizationId);
    if (walletIndex === -1) state.wallets.push(nextWallet);
    else state.wallets[walletIndex] = nextWallet;
    state.ledgerEntries.unshift(entry);
    return { entry, wallet: nextWallet };
  });
}

export async function listBillingLedgerEntries(filters: BillingLedgerFilters = {}): Promise<BillingLedgerEntry[]> {
  const limit = Math.max(1, Math.min(filters.limit || 100, 500));
  if (isPostgresBackend()) {
    const rows = await billingQuery(
      `SELECT * FROM billing_ledger
       WHERE ($1::text IS NULL OR organization_id = $1)
         AND ($2::text IS NULL OR account_id = $2)
         AND ($3::text IS NULL OR job_id = $3)
         AND ($4::text IS NULL OR kind = $4)
       ORDER BY created_at DESC
       LIMIT $5`,
      [filters.organizationId || null, filters.accountId || null, filters.jobId || null, filters.kind || null, limit]
    );
    return rows.map(ledgerFromRow);
  }
  const state = await readState();
  return state.ledgerEntries
    .filter((entry) => !filters.organizationId || entry.organizationId === filters.organizationId)
    .filter((entry) => !filters.accountId || entry.accountId === filters.accountId)
    .filter((entry) => !filters.jobId || entry.jobId === filters.jobId)
    .filter((entry) => !filters.kind || entry.kind === filters.kind)
    .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
    .slice(0, limit);
}

async function readState(): Promise<BillingState> {
  await ensureRuntimeDirs();
  const path = join(dataDir(), STORE_FILE);
  try {
    return normalizeState(JSON.parse(await readFile(path, "utf8")));
  } catch {
    const state = normalizeState({});
    await writeState(state);
    return state;
  }
}

async function writeState(state: BillingState): Promise<void> {
  await ensureRuntimeDirs();
  const path = join(dataDir(), STORE_FILE);
  const temp = `${path}.${createId("tmp")}.tmp`;
  await writeFile(temp, JSON.stringify(state, null, 2));
  await rename(temp, path);
}

async function mutateLocalState<T>(mutator: (state: BillingState) => T): Promise<T> {
  const run = localWriteQueue.then(async () => {
    const state = await readState();
    const result = mutator(state);
    await writeState(state);
    return result;
  });
  localWriteQueue = run.catch(() => undefined);
  return run;
}

function normalizeState(raw: Partial<BillingState>): BillingState {
  return {
    priceRules: Array.isArray(raw.priceRules) ? raw.priceRules : [],
    wallets: Array.isArray(raw.wallets) ? raw.wallets : [],
    ledgerEntries: Array.isArray(raw.ledgerEntries) ? raw.ledgerEntries : []
  };
}

function emptyWallet(organizationId: string): OrganizationWallet {
  return {
    organizationId,
    balanceFen: 0,
    totalRechargedFen: 0,
    totalChargedFen: 0,
    updatedAt: new Date(0).toISOString()
  };
}

function priceRuleToRow(rule: Partial<BillingPriceRule>) {
  return {
    id: rule.id,
    provider: rule.provider,
    capability: rule.capability,
    req_key: rule.reqKey || null,
    variant_key: rule.variantKey || null,
    unit: rule.unit,
    standard_unit_price_fen: safeInteger(rule.standardUnitPriceFen, "billing price rule standard unit price"),
    markup_multiplier: finiteNumber(rule.markupMultiplier, "billing price rule markup multiplier"),
    enabled: rule.enabled,
    conditions: canonicalConditionValue(rule.conditions || {}) as BillingRuleConditions,
    quantity_source: rule.quantitySource || null,
    priority: rule.priority || 0,
    note: rule.note || null,
    source: rule.source || null,
    parameter_dimensions: rule.parameterDimensions || [],
    created_at: rule.createdAt,
    updated_at: rule.updatedAt
  };
}

function priceRuleFromRow(row: Record<string, unknown>): BillingPriceRule {
  return {
    id: String(row.id),
    provider: row.provider as BillingPriceRule["provider"],
    capability: row.capability as BillingPriceRule["capability"],
    reqKey: optionalString(row.req_key),
    variantKey: optionalString(row.variant_key),
    unit: row.unit as BillingPriceRule["unit"],
    standardUnitPriceFen: safeInteger(row.standard_unit_price_fen, "billing_price_rules.standard_unit_price_fen"),
    markupMultiplier: finiteNumber(row.markup_multiplier ?? 1, "billing_price_rules.markup_multiplier"),
    enabled: row.enabled !== false,
    conditions: isRecord(row.conditions) ? row.conditions as BillingRuleConditions : undefined,
    quantitySource: row.quantity_source === "request" || row.quantity_source === "image_count" || row.quantity_source === "duration"
      ? row.quantity_source
      : undefined,
    priority: Number.isFinite(Number(row.priority)) ? Number(row.priority) : 0,
    note: optionalString(row.note),
    source: isRecord(row.source) ? row.source as BillingPriceRule["source"] : undefined,
    parameterDimensions: billingParameterDimensions(row.parameter_dimensions),
    createdAt: databaseTimestamp(row.created_at, "billing_price_rules.created_at"),
    updatedAt: databaseTimestamp(row.updated_at, "billing_price_rules.updated_at")
  };
}

function priceRuleMatchKey(rule: Pick<BillingPriceRule, "provider" | "capability" | "reqKey" | "variantKey" | "conditions">): string {
  return [rule.provider, rule.capability, rule.reqKey || "", rule.variantKey || "", canonicalConditions(rule.conditions)].join("\u0000");
}

function canonicalConditions(conditions?: BillingRuleConditions): string {
  if (!conditions || !isRecord(conditions)) return "{}";
  const entries = Object.entries(conditions)
    .sort(([left], [right]) => left.localeCompare(right))
    .map(([key, value]) => [key, canonicalConditionValue(value)] as const);
  return JSON.stringify(Object.fromEntries(entries));
}

function canonicalConditionValue(value: unknown): unknown {
  if (Array.isArray(value)) return value.map(canonicalConditionValue).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
  if (isRecord(value)) {
    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalConditionValue(item)]));
  }
  return value;
}

function walletFromRow(row: Record<string, unknown>): OrganizationWallet {
  return {
    organizationId: String(row.organization_id),
    balanceFen: safeInteger(row.balance_fen, "billing_wallets.balance_fen"),
    totalRechargedFen: safeInteger(row.total_recharged_fen, "billing_wallets.total_recharged_fen"),
    totalChargedFen: safeInteger(row.total_charged_fen, "billing_wallets.total_charged_fen"),
    updatedAt: databaseTimestamp(row.updated_at ?? new Date(), "billing_wallets.updated_at")
  };
}

function walletFromRpcRow(row: Record<string, unknown>, organizationId: string): OrganizationWallet {
  return {
    organizationId,
    balanceFen: safeInteger(row.balance_fen ?? row.balance_after_fen, "billing_post_wallet_entry.balance_fen"),
    totalRechargedFen: safeInteger(row.total_recharged_fen, "billing_post_wallet_entry.total_recharged_fen"),
    totalChargedFen: safeInteger(row.total_charged_fen, "billing_post_wallet_entry.total_charged_fen"),
    updatedAt: databaseTimestamp(row.updated_at ?? row.created_at ?? new Date(), "billing_post_wallet_entry.updated_at")
  };
}

function ledgerFromRow(row: Record<string, unknown>): BillingLedgerEntry {
  return {
    id: String(row.id),
    organizationId: String(row.organization_id),
    accountId: optionalString(row.account_id),
    jobId: optionalString(row.job_id),
    kind: row.kind as BillingLedgerKind,
    deltaFen: safeInteger(row.delta_fen, "billing_ledger.delta_fen"),
    balanceAfterFen: safeInteger(row.balance_after_fen, "billing_ledger.balance_after_fen"),
    currency: row.currency === "CNY" ? "CNY" : "CNY",
    idempotencyKey: String(row.idempotency_key),
    description: String(row.description || ""),
    metadata: isRecord(row.metadata) ? row.metadata : {},
    createdAt: databaseTimestamp(row.created_at, "billing_ledger.created_at")
  };
}

function ledgerFromRpcRow(row: Record<string, unknown>, input: WalletEntryInput, accountId?: string): BillingLedgerEntry {
  return {
    id: String(row.ledger_id || row.id),
    organizationId: input.organizationId,
    accountId,
    jobId: input.jobId,
    kind: input.kind,
    deltaFen: safeInteger(row.delta_fen ?? input.deltaFen, "billing_post_wallet_entry.delta_fen"),
    balanceAfterFen: safeInteger(row.balance_after_fen, "billing_post_wallet_entry.balance_after_fen"),
    currency: input.currency || "CNY",
    idempotencyKey: input.idempotencyKey,
    description: input.description,
    metadata: input.metadata || {},
    createdAt: databaseTimestamp(row.created_at ?? new Date(), "billing_post_wallet_entry.created_at")
  };
}

function effectiveLedgerAccountId(input: Pick<WalletEntryInput, "kind" | "accountId">): string | undefined {
  if (input.kind === "recharge" || input.kind === "adjustment") return undefined;
  return optionalString(input.accountId);
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function optionalString(value: unknown): string | undefined {
  if (typeof value !== "string") return undefined;
  const trimmed = value.trim();
  return trimmed || undefined;
}

async function billingQuery(
  text: string,
  values: readonly unknown[] = [],
  conflictOnUniqueViolation = false
): Promise<Record<string, unknown>[]> {
  try {
    const result = await queryDatabase<Record<string, unknown>>(text, values);
    return result.rows;
  } catch (error) {
    if (error instanceof BillingStoreError) throw error;
    const message = error instanceof Error ? error.message : String(error);
    const code = isRecord(error) ? optionalString(error.code) : undefined;
    throw new BillingStoreError(message, conflictOnUniqueViolation && code === "23505" ? 409 : 500);
  }
}

function safeInteger(value: unknown, field: string): number {
  const numberValue = typeof value === "bigint" ? Number(value) : Number(value ?? 0);
  if (!Number.isSafeInteger(numberValue)) {
    throw new BillingStoreError(`数据库字段 ${field} 超出 JavaScript 安全整数范围。`, 500);
  }
  return numberValue;
}

function finiteNumber(value: unknown, field: string): number {
  const numberValue = Number(value);
  if (!Number.isFinite(numberValue)) throw new BillingStoreError(`数据库字段 ${field} 不是有限数值。`, 500);
  return numberValue;
}

function databaseTimestamp(value: unknown, field: string): string {
  if (value instanceof Date && Number.isFinite(value.getTime())) return value.toISOString();
  if (typeof value === "string") {
    const parsed = new Date(value);
    if (Number.isFinite(parsed.getTime())) return parsed.toISOString();
  }
  throw new BillingStoreError(`数据库字段 ${field} 不是有效时间。`, 500);
}

function billingParameterDimensions(value: unknown): BillingParameterDimension[] | undefined {
  if (!Array.isArray(value)) return undefined;
  return value.map((dimension, dimensionIndex) => {
    if (!isRecord(dimension) || !Array.isArray(dimension.tiers)) {
      throw new BillingStoreError(`数据库字段 billing_price_rules.parameter_dimensions[${dimensionIndex}] 格式无效。`, 500);
    }
    return {
      ...dimension,
      tiers: dimension.tiers.map((tier, tierIndex) => {
        if (!isRecord(tier)) {
          throw new BillingStoreError(`数据库字段 billing_price_rules.parameter_dimensions[${dimensionIndex}].tiers[${tierIndex}] 格式无效。`, 500);
        }
        return {
          ...tier,
          standardFactor: finiteNumber(tier.standardFactor, `billing_price_rules.parameter_dimensions[${dimensionIndex}].tiers[${tierIndex}].standardFactor`),
          markupMultiplier: finiteNumber(tier.markupMultiplier, `billing_price_rules.parameter_dimensions[${dimensionIndex}].tiers[${tierIndex}].markupMultiplier`)
        };
      })
    } as BillingParameterDimension;
  });
}

function normalizeBillingStoreErrorMessage(message: string): string {
  if (/(billing_|billing_post_wallet_entry|variant_key|standard_unit_price_fen|markup_multiplier|source)/i.test(message)
    && /(relation .* does not exist|table .* does not exist|column .* does not exist|function .* does not exist)/i.test(message)) {
    return "计费数据库尚未初始化或未完成升级，请先对 PostgreSQL 数据库运行仓库中的版本化迁移，再重启服务。";
  }
  return message;
}