const Fastify = require("fastify");

const contractsRegistryRoutes = require("../../../src/routes/contractsRegistry");
const { AppError } = require("../../../src/utils/AppError");
const { currentDateString, parseDateOnlyString } = require("../../../src/utils/date");

const ACTOR_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
const PROJECT_ID = "11111111-1111-4111-8111-111111111111";
const OWNER_ID = "22222222-2222-4222-8222-222222222222";
const MANAGER_ID = "33333333-3333-4333-8333-333333333333";
const MEMBER_ID = "44444444-4444-4444-8444-444444444444";
const DEPARTMENT_ID = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";

function buildFeatureFlagRecord(flagKey) {
  return {
    id: `flag-${flagKey}`,
    flag_key: flagKey,
    override_mode: "force_on",
    rollout_type: "global",
    department_ids: [],
    note: "unit-test",
    version: 1,
    created_at: new Date("2026-04-04T08:00:00.000Z"),
    created_by: null,
    updated_at: new Date("2026-04-04T08:00:00.000Z"),
    updated_by: null,
  };
}

function buildContractRow(overrides = {}) {
  return {
    id: "55555555-5555-4555-8555-555555555551",
    contract_no: "HT-2026-001",
    project_id: PROJECT_ID,
    contract_type: "service",
    counterparty_name: "测试客户",
    summary: "合同摘要",
    amount: "100000.00",
    currency: "CNY",
    signed_date: new Date("2026-03-01T00:00:00.000Z"),
    effective_date: new Date("2026-03-05T00:00:00.000Z"),
    expiry_date: new Date("2026-03-31T00:00:00.000Z"),
    confidentiality_level: "internal",
    archive_location: "/archive/contracts/001",
    offline_archive_no: "OFF-001",
    owner_employee_id: OWNER_ID,
    status: "active",
    terminated_at: null,
    terminated_reason: null,
    terminated_by: null,
    created_at: new Date("2026-03-01T08:00:00.000Z"),
    updated_at: new Date("2026-04-01T08:00:00.000Z"),
    owner: {
      id: OWNER_ID,
      employee_no: "E001",
      name: "Owner",
    },
    project: {
      id: PROJECT_ID,
      project_no: "PRJ-001",
      name: "试点项目",
    },
    terminator: null,
    document_refs: [],
    ...overrides,
  };
}

function mapSelectedRow(row, select) {
  if (!select) {
    return row;
  }

  return Object.entries(select).reduce((result, [key, enabled]) => {
    if (enabled === true) {
      result[key] = row[key];
    }
    return result;
  }, {});
}

function cloneRow(row) {
  return {
    ...row,
    owner: row.owner ? { ...row.owner } : null,
    project: row.project ? { ...row.project } : null,
    terminator: row.terminator ? { ...row.terminator } : null,
    document_refs: (row.document_refs ?? []).map((item) => ({
      ...item,
      owner: item.owner ? { ...item.owner } : null,
    })),
  };
}

function findIdInWhere(where) {
  if (!where || typeof where !== "object") return null;
  if (typeof where.id === "string") return where.id;
  for (const condition of where.AND ?? []) {
    const id = findIdInWhere(condition);
    if (id) return id;
  }
  return null;
}

function buildStatefulPrisma(initialContracts, options = {}) {
  const state = {
    contracts: initialContracts.map((item) => cloneRow(item)),
    audits: [],
  };

  const auditCreate = vi.fn(async ({ data }) => {
    if (options.failAuditAction === data.action) {
      throw new Error("audit unavailable");
    }
    state.audits.push(data);
    return data;
  });

  const contractRegistry = {
    findMany: vi.fn(async ({ where, select, include }) => {
      let rows = [...state.contracts];
      if (where?.contract_no?.startsWith) {
        rows = rows.filter((item) => item.contract_no.startsWith(where.contract_no.startsWith));
      }

      if (select) {
        return rows.map((item) => mapSelectedRow(item, select));
      }

      if (include) {
        return rows.map((item) => cloneRow(item));
      }

      return rows.map((item) => cloneRow(item));
    }),
    findUnique: vi.fn(async ({ where, select, include }) => {
      const row = state.contracts.find((item) => item.id === where.id);
      if (!row) {
        return null;
      }
      if (select) {
        return mapSelectedRow(row, select);
      }
      if (include) {
        return cloneRow(row);
      }
      return cloneRow(row);
    }),
    findFirst: vi.fn(async ({ where, select, include }) => {
      const id = findIdInWhere(where);
      const row = id ? state.contracts.find((item) => item.id === id) : state.contracts[0];
      if (!row) return null;
      if (select) return mapSelectedRow(row, select);
      return include ? cloneRow(row) : cloneRow(row);
    }),
    create: vi.fn(async ({ data, include }) => {
      const created = buildContractRow({
        id: `66666666-6666-4666-8666-${String(state.contracts.length + 1).padStart(12, "0")}`,
        contract_no: data.contract_no,
        project_id: data.project_id ?? null,
        contract_type: data.contract_type,
        counterparty_name: data.counterparty_name,
        summary: data.summary,
        amount: data.amount ?? null,
        currency: data.currency,
        signed_date: data.signed_date,
        effective_date: data.effective_date,
        expiry_date: data.expiry_date,
        confidentiality_level: data.confidentiality_level,
        archive_location: data.archive_location,
        offline_archive_no: data.offline_archive_no,
        owner_employee_id: data.owner_employee_id,
        status: data.status,
        terminated_at: data.terminated_at ?? null,
        terminated_reason: data.terminated_reason ?? null,
        terminated_by: data.terminated_by ?? null,
      });
      state.contracts.push(created);
      return include ? cloneRow(created) : created;
    }),
    update: vi.fn(async ({ where, data, include }) => {
      const index = state.contracts.findIndex((item) => item.id === where.id);
      if (index < 0) {
        return null;
      }
      state.contracts[index] = {
        ...state.contracts[index],
        ...data,
        updated_at: new Date("2026-04-04T09:30:00.000Z"),
      };
      return include ? cloneRow(state.contracts[index]) : state.contracts[index];
    }),
    updateMany: vi.fn(async ({ where, data }) => {
      const sameValue = (current, expected) =>
        current instanceof Date && expected instanceof Date
          ? current.getTime() === expected.getTime()
          : current === expected;
      const index = state.contracts.findIndex((item) =>
        Object.entries(where).every(([key, value]) => sameValue(item[key], value)),
      );
      if (index < 0) return { count: 0 };
      state.contracts[index] = {
        ...state.contracts[index],
        ...data,
        updated_at: new Date("2026-04-04T12:00:00.000Z"),
        terminator: data.terminated_by
          ? { id: data.terminated_by, employee_no: "E-ACTOR", name: "Actor" }
          : state.contracts[index].terminator,
      };
      return { count: 1 };
    }),
  };

  return {
    state,
    prisma: {
      featureFlag: {
        findUnique: vi.fn().mockImplementation(async ({ where }) => buildFeatureFlagRecord(where.flag_key)),
      },
      auditLog: {
        create: auditCreate,
        findMany: vi.fn(async () =>
          state.audits.map((item, index) => ({
            id: `audit-${index + 1}`,
            ...item,
            created_at: new Date(`2026-04-04T10:0${index}:00.000Z`),
            actor: { id: ACTOR_ID, employee_no: "E-ACTOR", name: "Actor" },
          })),
        ),
      },
      contractRegistry,
      $transaction: async (callback) => {
        const contractsBefore = state.contracts.map((item) => cloneRow(item));
        const auditsBefore = [...state.audits];
        try {
          return await callback({
            auditLog: { create: auditCreate },
            contractRegistry,
          });
        } catch (error) {
          state.contracts = contractsBefore;
          state.audits = auditsBefore;
          throw error;
        }
      },
    },
    auditCreate,
  };
}

async function buildApp(options = {}) {
  const app = Fastify();
  const actor = options.actor ?? {
    id: ACTOR_ID,
    department_id: DEPARTMENT_ID,
    permissionCodes: ["project.manage"],
  };
  const prisma =
    options.prisma ??
    (() => {
      const fallback = {
        featureFlag: {
          findUnique: vi.fn().mockImplementation(async ({ where }) => buildFeatureFlagRecord(where.flag_key)),
        },
        auditLog: {
          create: vi.fn().mockResolvedValue({}),
          findMany: vi.fn().mockResolvedValue([]),
        },
        contractRegistry: {
          findMany: vi.fn().mockResolvedValue([]),
          findUnique: vi.fn().mockResolvedValue(null),
          findFirst: vi.fn().mockResolvedValue(null),
          create: vi.fn().mockResolvedValue(buildContractRow()),
          update: vi.fn().mockResolvedValue(buildContractRow()),
          updateMany: vi.fn().mockResolvedValue({ count: 0 }),
        },
      };
      fallback.$transaction = async (callback) => callback(fallback);
      return fallback;
    })();

  app.decorate("authenticate", async (request) => {
    request.employee = actor;
  });
  app.decorate("hasPermission", (employee, permissionCode) => {
    const permissionCodes = employee.permissionCodes ?? [];
    return permissionCodes.includes("*") || permissionCodes.includes(permissionCode);
  });
  app.decorate("config", {
    appTimezone: "Asia/Shanghai",
    projectLinkingEnabled: true,
  });
  app.decorate("prisma", prisma);
  app.setErrorHandler((error, request, reply) => {
    if (error instanceof AppError) {
      return reply.status(error.statusCode).send({
        requestId: request.id,
        error: { code: error.code, message: error.message, details: error.details ?? {} },
      });
    }
    return reply.status(500).send({
      requestId: request.id,
      error: { code: "SYS_001", message: "服务器内部错误", details: {} },
    });
  });

  await app.register(contractsRegistryRoutes, { prefix: "/api" });
  return { app, prisma };
}

describe("contracts registry routes", () => {
  it("lists contracts with expired filtering and computed status", async () => {
    const contractFindMany = vi.fn().mockResolvedValue([buildContractRow()]);
    const { app } = await buildApp({
      prisma: (() => {
        const prisma = {
        featureFlag: {
          findUnique: vi.fn().mockImplementation(async ({ where }) => buildFeatureFlagRecord(where.flag_key)),
        },
        auditLog: { create: vi.fn().mockResolvedValue({}) },
        contractRegistry: {
          findMany: contractFindMany,
          findUnique: vi.fn().mockResolvedValue(null),
          create: vi.fn(),
          update: vi.fn(),
        },
        };
        prisma.$transaction = async (callback) => callback(prisma);
        return prisma;
      })(),
    });

    const today = parseDateOnlyString(currentDateString("Asia/Shanghai"));
    const response = await app.inject({
      method: "GET",
      url: `/api/contracts-registry?status=expired&contractType=service&counterpartyName=%E6%B5%8B%E8%AF%95&expiryDateFrom=2026-03-01&expiryDateTo=2026-03-31`,
    });

    expect(response.statusCode).toBe(200);
    const payload = response.json();
    expect(payload.data.items[0]).toEqual(
      expect.objectContaining({
        status: "expired",
        persistedStatus: "active",
        contractType: "service",
        amount: "100000.00",
      }),
    );
    expect(payload.data.items[0]).not.toHaveProperty("terminatedAt");
    expect(payload.data.items[0]).not.toHaveProperty("terminatedReason");
    expect(payload.data.items[0]).not.toHaveProperty("terminatedBy");
    expect(payload.data.items[0]).not.toHaveProperty("terminator");
    expect(contractFindMany).toHaveBeenCalledWith(
      expect.objectContaining({
        where: {
          AND: expect.arrayContaining([
            expect.objectContaining({ status: "active", expiry_date: { lt: today } }),
            expect.objectContaining({ contract_type: "service" }),
            expect.objectContaining({
              counterparty_name: expect.objectContaining({ contains: "测试", mode: "insensitive" }),
            }),
            expect.objectContaining({
              expiry_date: expect.objectContaining({
                gte: new Date("2026-03-01T00:00:00.000Z"),
                lte: new Date("2026-03-31T00:00:00.000Z"),
              }),
            }),
          ]),
        },
      }),
    );

    await app.close();
  });

  it("keeps terminated contracts terminal even when their expiry date is in the past", async () => {
    const contractFindMany = vi.fn().mockResolvedValue([
      buildContractRow({
        status: "terminated",
        expiry_date: new Date("2026-03-31T00:00:00.000Z"),
        terminated_at: new Date("2026-03-20T08:00:00.000Z"),
        terminated_reason: "双方确认提前终止合同并保留原编号",
        terminated_by: ACTOR_ID,
        terminator: { id: ACTOR_ID, employee_no: "E-ACTOR", name: "Actor" },
      }),
    ]);
    const { app } = await buildApp({
      prisma: {
        featureFlag: {
          findUnique: vi.fn().mockImplementation(async ({ where }) => buildFeatureFlagRecord(where.flag_key)),
        },
        auditLog: { create: vi.fn().mockResolvedValue({}) },
        contractRegistry: {
          findMany: contractFindMany,
          findUnique: vi.fn().mockResolvedValue(null),
          create: vi.fn(),
          update: vi.fn(),
        },
      },
    });

    const response = await app.inject({ method: "GET", url: "/api/contracts-registry" });

    expect(response.statusCode).toBe(200);
    expect(response.json().data.items[0]).toEqual(expect.objectContaining({
      status: "terminated",
      persistedStatus: "terminated",
    }));

    await app.close();
  });

  it("rejects invalid expiry date range", async () => {
    const { app } = await buildApp();
    const response = await app.inject({
      method: "GET",
      url: "/api/contracts-registry?expiryDateFrom=2026-04-10&expiryDateTo=2026-04-01",
    });

    expect(response.statusCode).toBe(400);
    expect(response.json().error).toEqual(
      expect.objectContaining({
        code: "VALID_001",
        details: expect.objectContaining({
          expiryDateTo: "must_be_after_or_equal_expiryDateFrom",
        }),
      }),
    );

    await app.close();
  });

  it("returns expiring contracts within the default window", async () => {
    const contractFindMany = vi.fn().mockResolvedValue([
      buildContractRow({
        id: "contract-2",
        contract_no: "HT-2026-002",
        expiry_date: new Date("2026-04-10T00:00:00.000Z"),
      }),
    ]);
    const { app } = await buildApp({
      prisma: (() => {
        const prisma = {
        featureFlag: {
          findUnique: vi.fn().mockImplementation(async ({ where }) => buildFeatureFlagRecord(where.flag_key)),
        },
        auditLog: { create: vi.fn().mockResolvedValue({}) },
        contractRegistry: {
          findMany: contractFindMany,
          findUnique: vi.fn().mockResolvedValue(null),
          create: vi.fn(),
          update: vi.fn(),
        },
        };
        prisma.$transaction = async (callback) => callback(prisma);
        return prisma;
      })(),
    });

    const today = parseDateOnlyString(currentDateString("Asia/Shanghai"));
    const end = new Date(today.getTime());
    end.setUTCDate(end.getUTCDate() + 30);

    const response = await app.inject({
      method: "GET",
      url: "/api/contracts-registry/expiring",
    });

    expect(response.statusCode).toBe(200);
    expect(response.json().data).toEqual(
      expect.objectContaining({
        days: 30,
        total: 1,
      }),
    );
    expect(contractFindMany).toHaveBeenCalledWith(
      expect.objectContaining({
        where: {
          AND: expect.arrayContaining([
            { status: "active" },
            expect.objectContaining({
              expiry_date: expect.objectContaining({
                gte: today,
                lte: end,
              }),
            }),
          ]),
        },
      }),
    );

    await app.close();
  });

  it("returns a scoped contract detail with safe document references and history", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([
      buildContractRow({
        id: contractId,
        document_refs: [
          {
            id: "77777777-7777-4777-8777-777777777777",
            title: "线下涉密资料索引",
            document_no: "DOC-001",
            confidentiality_level: "restricted",
            storage_type: "offline_archive",
            storage_path: "/sensitive/full/path",
            offline_archive_no: "OFF-DOC-001",
            access_rule_json: { raw: true },
            created_at: new Date("2026-04-01T08:00:00.000Z"),
            updated_at: new Date("2026-04-02T08:00:00.000Z"),
            owner: { id: OWNER_ID, employee_no: "E001", name: "Owner" },
          },
        ],
      }),
    ]);
    stateful.state.audits.push({
      request_id: "request-1",
      actor_id: ACTOR_ID,
      action: "CONTRACT_REGISTRY_UPDATED",
      target_type: "contract_registry",
      target_id: contractId,
      extra: { fields: ["summary"], rawPayload: "不得返回" },
    });
    const { app } = await buildApp({
      prisma: stateful.prisma,
      actor: {
        id: OWNER_ID,
        department_id: DEPARTMENT_ID,
        permissionCodes: ["project.view_own"],
      },
    });

    const response = await app.inject({ method: "GET", url: `/api/contracts-registry/${contractId}` });

    expect(response.statusCode).toBe(200);
    const item = response.json().data.item;
    expect(item.documentRefs[0]).toEqual(
      expect.objectContaining({
        title: "线下涉密资料索引",
        documentNo: "DOC-001",
        storageType: "offline_archive",
        offlineArchiveNo: "OFF-DOC-001",
      }),
    );
    expect(item.documentRefs[0]).not.toHaveProperty("storagePath");
    expect(item.documentRefs[0]).not.toHaveProperty("accessRuleJson");
    expect(item.history[0]).toEqual(expect.objectContaining({ summary: "更新合同信息" }));
    expect(item.history[0]).not.toHaveProperty("extra");
    expect(stateful.prisma.contractRegistry.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({
        where: expect.objectContaining({ AND: expect.arrayContaining([{ id: contractId }]) }),
      }),
    );

    await app.close();
  });

  it("terminates an active or expired contract with complete fields and required audit", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([buildContractRow({ id: contractId, status: "active" })]);
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "POST",
      url: `/api/contracts-registry/${contractId}/terminate`,
      payload: { reason: "客户项目已取消，双方确认不再继续履行" },
    });

    expect(response.statusCode).toBe(200);
    expect(response.json().data.item).toEqual(
      expect.objectContaining({
        status: "terminated",
        persistedStatus: "terminated",
        terminatedReason: "客户项目已取消，双方确认不再继续履行",
        terminatedBy: ACTOR_ID,
        terminator: expect.objectContaining({ id: ACTOR_ID }),
      }),
    );
    const stored = stateful.state.contracts.find((item) => item.id === contractId);
    expect(stored).toEqual(
      expect.objectContaining({
        status: "terminated",
        terminated_reason: "客户项目已取消，双方确认不再继续履行",
        terminated_by: ACTOR_ID,
      }),
    );
    expect(stored.terminated_at).toBeInstanceOf(Date);
    expect(stateful.state.audits.map((item) => item.action)).toContain("CONTRACT_REGISTRY_TERMINATED");
    const terminationAudit = stateful.state.audits.find((item) => item.action === "CONTRACT_REGISTRY_TERMINATED");
    expect(terminationAudit?.extra).toEqual(expect.objectContaining({
      reasonSummary: "客户项目已取消，双方确认不再继续履行",
    }));
    expect(terminationAudit?.extra).not.toHaveProperty("reason");

    await app.close();
  });

  it("rolls back all termination fields when required audit creation fails", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([buildContractRow({ id: contractId })], {
      failAuditAction: "CONTRACT_REGISTRY_TERMINATED",
    });
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "POST",
      url: `/api/contracts-registry/${contractId}/terminate`,
      payload: { reason: "客户项目已取消，双方确认不再继续履行" },
    });

    expect(response.statusCode).toBe(500);
    expect(stateful.state.contracts[0]).toEqual(
      expect.objectContaining({
        status: "active",
        terminated_at: null,
        terminated_reason: null,
        terminated_by: null,
      }),
    );
    expect(stateful.state.audits).toEqual([]);

    await app.close();
  });

  it("rejects terminated through general PATCH and keeps terminated contracts final", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const terminated = buildContractRow({
      id: contractId,
      status: "terminated",
      terminated_at: new Date("2026-04-04T08:30:00.000Z"),
      terminated_reason: "双方确认提前终止合同并保留原编号",
      terminated_by: ACTOR_ID,
      terminator: { id: ACTOR_ID, employee_no: "E-ACTOR", name: "Actor" },
    });
    const stateful = buildStatefulPrisma([terminated]);
    const { app } = await buildApp({ prisma: stateful.prisma });

    const bypassResponse = await app.inject({
      method: "PATCH",
      url: `/api/contracts-registry/${contractId}`,
      payload: { status: "terminated" },
    });
    expect(bypassResponse.statusCode).toBe(400);

    const editResponse = await app.inject({
      method: "PATCH",
      url: `/api/contracts-registry/${contractId}`,
      payload: { summary: "试图覆盖已终止合同" },
    });
    expect(editResponse.statusCode).toBe(409);
    expect(editResponse.json().error.details).toEqual(expect.objectContaining({ status: "terminated_is_final" }));

    const renewResponse = await app.inject({
      method: "POST",
      url: `/api/contracts-registry/${contractId}/renew`,
    });
    expect(renewResponse.statusCode).toBe(409);

    await app.close();
  });

  it("locks archived fields and appends corrections without overwriting the contract", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([buildContractRow({ id: contractId, status: "archived" })]);
    const { app } = await buildApp({ prisma: stateful.prisma });

    const editResponse = await app.inject({
      method: "PATCH",
      url: `/api/contracts-registry/${contractId}`,
      payload: { archiveLocation: "新位置" },
    });
    expect(editResponse.statusCode).toBe(409);
    expect(editResponse.json().error.details).toEqual(expect.objectContaining({ status: "archived_fields_locked" }));

    const correctionResponse = await app.inject({
      method: "POST",
      url: `/api/contracts-registry/${contractId}/corrections`,
      payload: { summary: "原归档位置登记有误，实际以线下档案号为准" },
    });
    expect(correctionResponse.statusCode).toBe(200);
    expect(stateful.state.contracts[0].archive_location).toBe("/archive/contracts/001");
    expect(stateful.state.audits).toEqual([
      expect.objectContaining({
        action: "CONTRACT_REGISTRY_CORRECTION_APPENDED",
        extra: expect.objectContaining({ summary: "原归档位置登记有误，实际以线下档案号为准" }),
      }),
    ]);

    await app.close();
  });

  it("rejects a stale archived correction when the contract changed concurrently", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([buildContractRow({ id: contractId, status: "archived" })]);
    stateful.prisma.contractRegistry.updateMany.mockResolvedValueOnce({ count: 0 });
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "POST",
      url: `/api/contracts-registry/${contractId}/corrections`,
      payload: { summary: "原归档位置登记有误，实际以线下档案号为准" },
    });

    expect(response.statusCode).toBe(409);
    expect(response.json().error.details).toEqual(expect.objectContaining({ status: "correction_state_conflict" }));
    expect(stateful.state.audits).toEqual([]);

    await app.close();
  });

  it("rolls back an archive status change when required audit creation fails", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([buildContractRow({ id: contractId })], {
      failAuditAction: "CONTRACT_REGISTRY_STATUS_CHANGED",
    });
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "PATCH",
      url: `/api/contracts-registry/${contractId}`,
      payload: { status: "archived" },
    });

    expect(response.statusCode).toBe(500);
    expect(stateful.state.contracts[0].status).toBe("active");

    await app.close();
  });

  it("rolls back an archive status change when its history audit fails", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([buildContractRow({ id: contractId })], {
      failAuditAction: "CONTRACT_REGISTRY_UPDATED",
    });
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "PATCH",
      url: `/api/contracts-registry/${contractId}`,
      payload: { status: "archived" },
    });

    expect(response.statusCode).toBe(500);
    expect(stateful.state.contracts[0].status).toBe("active");
    expect(stateful.state.audits).toEqual([]);

    await app.close();
  });

  it("fails closed when a contract row violates the termination field invariant", async () => {
    const stateful = buildStatefulPrisma([
      buildContractRow({
        terminated_reason: "存在终止原因但状态尚未切换",
      }),
    ]);
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({ method: "GET", url: "/api/contracts-registry" });

    expect(response.statusCode).toBe(500);
    expect(response.json().error).toEqual(expect.objectContaining({ code: "SYS_001" }));

    await app.close();
  });

  it("rejects a stale general update instead of overwriting a concurrent terminal transition", async () => {
    const contractId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([buildContractRow({ id: contractId })]);
    stateful.prisma.contractRegistry.updateMany.mockResolvedValueOnce({ count: 0 });
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "PATCH",
      url: `/api/contracts-registry/${contractId}`,
      payload: { summary: "并发状态变化后不得覆盖合同" },
    });

    expect(response.statusCode).toBe(409);
    expect(response.json().error.details).toEqual(
      expect.objectContaining({ status: "contract_state_conflict" }),
    );
    expect(stateful.state.contracts[0].summary).toBe("合同摘要");

    await app.close();
  });

  it("uses the same non-enumerating 404 for an unavailable contract detail", async () => {
    const { app } = await buildApp({
      actor: { id: ACTOR_ID, department_id: DEPARTMENT_ID, permissionCodes: ["project.view_own"] },
    });

    const response = await app.inject({
      method: "GET",
      url: "/api/contracts-registry/55555555-5555-4555-8555-555555555551",
    });

    expect(response.statusCode).toBe(404);
    expect(response.json().error).toEqual(expect.objectContaining({ code: "SYS_404", message: "Not Found" }));
    expect(response.body).not.toContain("合同摘要");

    await app.close();
  });

  it("renews an active contract into the next draft revision and archives the source", async () => {
    const stateful = buildStatefulPrisma([
      buildContractRow({
        id: "55555555-5555-4555-8555-555555555551",
        contract_no: "HT-2026-001",
        status: "active",
      }),
      buildContractRow({
        id: "55555555-5555-4555-8555-555555555552",
        contract_no: "HT-2026-001-R1",
        status: "archived",
      }),
    ]);
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "POST",
      url: "/api/contracts-registry/55555555-5555-4555-8555-555555555551/renew",
    });

    expect(response.statusCode).toBe(200);
    expect(response.json().data).toEqual(
      expect.objectContaining({
        item: expect.objectContaining({
          contractNo: "HT-2026-001-R2",
          status: "draft",
          persistedStatus: "draft",
        }),
        sourceItem: expect.objectContaining({
          contractNo: "HT-2026-001",
          status: "archived",
          persistedStatus: "archived",
        }),
      }),
    );
    expect(stateful.state.contracts.find((item) => item.id === "55555555-5555-4555-8555-555555555551")?.status).toBe("archived");
    expect(
      stateful.state.contracts.some((item) => item.contract_no === "HT-2026-001-R2" && item.status === "draft"),
    ).toBe(true);
    expect(stateful.state.audits.map((item) => item.action)).toEqual(
      expect.arrayContaining(["CONTRACT_REGISTRY_RENEWED", "CONTRACT_REGISTRY_STATUS_CHANGED"]),
    );

    await app.close();
  });

  it("rolls back the renewal draft and source archive when renewal audit fails", async () => {
    const sourceId = "55555555-5555-4555-8555-555555555551";
    const stateful = buildStatefulPrisma([
      buildContractRow({ id: sourceId, contract_no: "HT-2026-001", status: "active" }),
    ], {
      failAuditAction: "CONTRACT_REGISTRY_RENEWED",
    });
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "POST",
      url: `/api/contracts-registry/${sourceId}/renew`,
    });

    expect(response.statusCode).toBe(500);
    expect(stateful.state.contracts).toHaveLength(1);
    expect(stateful.state.contracts[0]).toEqual(expect.objectContaining({ id: sourceId, status: "active" }));
    expect(stateful.state.audits).toEqual([]);

    await app.close();
  });

  it("rejects renewing a draft contract", async () => {
    const stateful = buildStatefulPrisma([
      buildContractRow({
        id: "55555555-5555-4555-8555-555555555553",
        contract_no: "HT-2026-003",
        status: "draft",
      }),
    ]);
    const { app } = await buildApp({ prisma: stateful.prisma });

    const response = await app.inject({
      method: "POST",
      url: "/api/contracts-registry/55555555-5555-4555-8555-555555555553/renew",
    });

    expect(response.statusCode).toBe(409);
    expect(response.json().error).toEqual(
      expect.objectContaining({
        code: "VALID_001",
        details: expect.objectContaining({ status: "renew_not_allowed" }),
      }),
    );

    await app.close();
  });
});