Pelaporan RUPS Tahunan (LAPORAN_RUPS_TAHUNAN) Flow — Implementation Plan

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { SubmissionType, RupsJenisAudit } from "../../generated/prisma/enums";
import { processorKindForType } from "../../services/submission-dispatch";
import { FLOW_REGISTRY } from "../registry";

/**
 * Task 1 — LAPORAN_RUPS_TAHUNAN schema slice + the two compile-forced wiring
 * points (registry key + ProcessorKind case). The registry entry is a TEMPORARY
 * v1-fork stub until Task 6 registers the real defineFlow config.
 */
describe("LAPORAN_RUPS_TAHUNAN schema + compile-gate", () => {
  const ids: string[] = [];
  const docIds: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: ids } } });
    await db.document.deleteMany({ where: { id: { in: docIds } } });
  });

  it("exposes the new enums", () => {
    expect(SubmissionType.LAPORAN_RUPS_TAHUNAN).toBe("LAPORAN_RUPS_TAHUNAN");
    expect(RupsJenisAudit.WAJIB_AUDIT).toBe("WAJIB_AUDIT");
    expect(RupsJenisAudit.NON_AUDIT).toBe("NON_AUDIT");
  });

  it("persists tahunLaporan / jenisAudit / rupsSubmittedAt / rupsDeclarations", async () => {
    const sub = await db.submission.create({
      data: {
        type: "LAPORAN_RUPS_TAHUNAN",
        status: "CREATED",
        tahunLaporan: 2023,
        jenisAudit: "WAJIB_AUDIT",
        rupsDeclarations: { declaration: true, warningAcks: [] },
      },
    });
    ids.push(sub.id);
    expect(sub.tahunLaporan).toBe(2023);
    expect(sub.jenisAudit).toBe("WAJIB_AUDIT");
    expect(sub.rupsSubmittedAt).toBeNull();
  });

  it("persists a LaporanKeuanganExtraction satellite keyed by documentId", async () => {
    const doc = await db.document.create({
      data: { filename: "lk.pdf", originalName: "lk.pdf", fileSize: 0, filePath: "/tmp/lk.pdf", documentType: "LAPORAN_KEUANGAN", status: "UPLOADED", rawText: "" },
    });
    docIds.push(doc.id);
    const lk = await db.laporanKeuanganExtraction.create({
      data: { documentId: doc.id, namaAkuntanPublik: "Drs. Mulyoto, Ak., CPA", nomorIzinAkuntanPublik: "AP.1234", tahunBuku: "2023" },
    });
    expect(lk.confidence).toBe(0);
    expect(lk.tanggalIzinAkuntanPublik).toBeNull();
    // @unique on documentId
    await expect(
      db.laporanKeuanganExtraction.create({ data: { documentId: doc.id } }),
    ).rejects.toThrow();
  });

  it("routes the new type to the v2-generic ProcessorKind and a total registry", () => {
    expect(processorKindForType("LAPORAN_RUPS_TAHUNAN")).toBe("v2-generic");
    expect(FLOW_REGISTRY.LAPORAN_RUPS_TAHUNAN).toBeDefined();
  });
});

  /// Pelaporan RUPS Tahunan (UUPT Ps.66-68): the statutory annual filing. TERMINAL
  /// self-service — submit → COMPLETED, no verifier queue, no VerifikasiPerubahan row.
  /// FIRST engine:'v2-generic' FLOW_REGISTRY tenant. Spelling = mechanical uppercase
  /// of the classifier taxonomy `laporan_rups_tahunan` (NOT SABH's PELAPORAN_ noun).
  LAPORAN_RUPS_TAHUNAN

/// Jenis-audit attestation for LAPORAN_RUPS_TAHUNAN (UUPT Ps.68 wajib-audit gate).
enum RupsJenisAudit {
  WAJIB_AUDIT
  NON_AUDIT
}

  // ── Pelaporan RUPS Tahunan (null for all other submission types) ──
  /// Backlog-capable reporting year; SABH window currentYear-10 … currentYear-1.
  tahunLaporan Int?
  jenisAudit   RupsJenisAudit?
  /// Terminal self-service submit timestamp (this flow has NO verifikator stage).
  rupsSubmittedAt DateTime?
  /// Submit declarations {declaration:true, warningAcks:string[], declaredAt}. JSON on
  /// Submission (akuisisiAttestation precedent) because recordAuditEvent is keyed on
  /// VerifikasiPerubahan and this flow NEVER creates a verifikasi row.
  rupsDeclarations Json?

/// Per-document satellite for the LAPORAN_KEUANGAN focused grounded pass (akuntan-
/// publik block, flow-spec §4.4/§6). Mirrors BeritaAcaraRupsExtraction's shape.
model LaporanKeuanganExtraction {
  id         String   @id @default(uuid())
  documentId String   @unique
  document   Document @relation(fields: [documentId], references: [id], onDelete: Cascade)

  namaAkuntanPublik        String?
  nomorIzinAkuntanPublik   String?
  tanggalIzinAkuntanPublik String?
  tahunBuku                String?

  confidence        Float   @default(0)
  rawOcrText        String? @db.Text
  rawExtractionJson Json?

  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

  laporanKeuanganExtraction LaporanKeuanganExtraction?

  // TEMPORARY v1-fork stub — satisfies Record totality until Task 6 registers the
  // real defineFlow(...) entry. processorKindForType already returns "v2-generic",
  // so a premature legacy dispatch throws LOUD (unreachable while the classifier
  // gate keeps the flow dark — BUILT_AKTA_TXN_TYPES flips in Task 7).
  LAPORAN_RUPS_TAHUNAN: { engine: "v1-fork", type: "LAPORAN_RUPS_TAHUNAN" },

    case "LAPORAN_RUPS_TAHUNAN":
      // v2-generic: dispatch resolves FLOW_REGISTRY BEFORE this switch; the
      // switch's "v2-generic" case below is a deliberate unreachable-throw.
      return "v2-generic";

import { describe, it, expect, afterAll } from "bun:test";
import { db } from "../../lib/db";
import { buildRupsTahunanContext, LAMPIRAN_FINE_LABELS } from "../context/rups-tahunan-context";

describe("buildRupsTahunanContext", () => {
  const ids: string[] = [];
  const docIds: string[] = [];
  afterAll(async () => {
    await db.submission.deleteMany({ where: { id: { in: ids } } });
    await db.document.deleteMany({ where: { id: { in: docIds } } });
  });

  async function seed(opts: { withLk: boolean; withLampiran: boolean }) {
    const akta = await db.document.create({
      data: { filename: "a.pdf", originalName: "a.pdf", fileSize: 0, filePath: "/tmp/a.pdf", documentType: "AKTA", status: "AI_EXTRACTION", rawText: "" },
    });
    docIds.push(akta.id);
    await db.extractedField.createMany({
      data: [
        { documentId: akta.id, fieldKey: "nama_perseroan", value: "PT RUPS UJI" },
        { documentId: akta.id, fieldKey: "tanggal_rups", value: "2024-04-10" },
      ],
    });
    const sub = await db.submission.create({
      data: { type: "LAPORAN_RUPS_TAHUNAN", status: "VALIDATING", tahunLaporan: 2023, jenisAudit: "WAJIB_AUDIT" },
    });
    ids.push(sub.id);
    await db.submissionDocument.create({
      data: { submissionId: sub.id, documentId: akta.id, classifiedType: "AKTA_RUPS_TAHUNAN", processingOrder: 0, extractionStatus: "DONE" },
    });
    if (opts.withLk) {
      const lk = await db.document.create({
        data: { filename: "lk.pdf", originalName: "lk.pdf", fileSize: 0, filePath: "/tmp/lk.pdf", documentType: "LAPORAN_KEUANGAN", status: "VERIFICATION_READY", rawText: "LAPORAN KEUANGAN" },
      });
      docIds.push(lk.id);
      await db.submissionDocument.create({
        data: { submissionId: sub.id, documentId: lk.id, classifiedType: "LAPORAN_KEUANGAN", processingOrder: 6, extractionStatus: "DONE" },
      });
      await db.laporanKeuanganExtraction.create({
        data: { documentId: lk.id, namaAkuntanPublik: "KAP Mulyoto & Rekan", nomorIzinAkuntanPublik: "AP.1234", tanggalIzinAkuntanPublik: "12 Januari 2020", tahunBuku: "2023" },
      });
    }
    if (opts.withLampiran) {
      const lamp = await db.document.create({
        data: { filename: "tjsl.pdf", originalName: "tjsl.pdf", fileSize: 0, filePath: "/tmp/tjsl.pdf", documentType: "LAMPIRAN_LAPORAN_TAHUNAN", status: "UPLOADED", rawText: "" },
      });
      docIds.push(lamp.id);
      await db.submissionDocument.create({
        data: { submissionId: sub.id, documentId: lamp.id, classifiedType: "LAMPIRAN_TJSL", processingOrder: 7, extractionStatus: "DONE" },
      });
    }
    return sub.id;
  }

  it("assembles base PtAktaCtx + typed columns + akuntan from the satellite + lampiran slots", async () => {
    const id = await seed({ withLk: true, withLampiran: true });
    const ctx = await buildRupsTahunanContext(id);
    expect(ctx.input.aktaNamaPerseroan).toBe("PT RUPS UJI"); // base builder ran with AKTA_RUPS_TAHUNAN
    expect(ctx.tahunLaporan).toBe(2023);
    expect(ctx.jenisAudit).toBe("WAJIB_AUDIT");
    expect(ctx.hasLaporanKeuanganDoc).toBe(true);
    expect(ctx.akuntan).toEqual({ nama: "KAP Mulyoto & Rekan", nomorIzin: "AP.1234", tanggalIzin: "12 Januari 2020", tahunBuku: "2023" });
    expect(ctx.lampiranSlots).toHaveLength(LAMPIRAN_FINE_LABELS.length);
    expect(ctx.lampiranSlots.find((s) => s.key === "LAMPIRAN_TJSL")?.filled).toBe(true);
    expect(ctx.lampiranSlots.find((s) => s.key === "LAMPIRAN_GAJI_PENGURUS")?.filled).toBe(false);
  });

  it("null-safe when no laporan keuangan doc / satellite / attestation", async () => {
    const id = await seed({ withLk: false, withLampiran: false });
    await db.submission.update({ where: { id }, data: { tahunLaporan: null, jenisAudit: null } });
    const ctx = await buildRupsTahunanContext(id);
    expect(ctx.tahunLaporan).toBeNull();
    expect(ctx.jenisAudit).toBeNull();
    expect(ctx.hasLaporanKeuanganDoc).toBe(false);
    expect(ctx.akuntan).toEqual({ nama: null, nomorIzin: null, tanggalIzin: null, tahunBuku: null });
    expect(ctx.lampiranSlots.every((s) => !s.filled)).toBe(true);
  });
});

import { db } from "../../lib/db";
import { buildPtAktaContext, type PtAktaCtx } from "./pt-akta-context";

/** The six UUPT Ps.66(2) letters b-g upload slots. Fine labels live on
 *  SubmissionDocument.classifiedType; they ALL map to the ONE Prisma carrier
 *  DocumentType LAMPIRAN_LAPORAN_TAHUNAN (store-only, manual board assignment). */
export const LAMPIRAN_FINE_LABELS = [
  "LAMPIRAN_KEGIATAN_PERSEROAN",
  "LAMPIRAN_TJSL",
  "LAMPIRAN_RINCIAN_MASALAH",
  "LAMPIRAN_PENGAWASAN_KOMISARIS",
  "LAMPIRAN_SUSUNAN_PENGURUS",
  "LAMPIRAN_GAJI_PENGURUS",
] as const;

export interface RupsTahunanCtx extends PtAktaCtx {
  tahunLaporan: number | null;
  jenisAudit: "WAJIB_AUDIT" | "NON_AUDIT" | null;
  hasLaporanKeuanganDoc: boolean;
  /** Akuntan-publik block from the LaporanKeuanganExtraction satellite (focused
   *  pass OR manual entry via PUT /akuntan-publik — same row either way). */
  akuntan: { nama: string | null; nomorIzin: string | null; tanggalIzin: string | null; tahunBuku: string | null };
  lampiranSlots: { key: string; filled: boolean }[];
}

export async function buildRupsTahunanContext(submissionId: string): Promise<RupsTahunanCtx> {
  const base = await buildPtAktaContext(submissionId, { aktaClassifiedType: "AKTA_RUPS_TAHUNAN" });
  const submission = await db.submission.findUnique({
    where: { id: submissionId },
    select: {
      tahunLaporan: true,
      jenisAudit: true,
      documents: { select: { classifiedType: true, documentId: true, document: { select: { documentType: true } } } },
    },
  });
  if (!submission) throw new Error(`buildRupsTahunanContext: submission ${submissionId} not found`);

  const lkDoc = submission.documents.find((d) => d.document.documentType === "LAPORAN_KEUANGAN");
  const lk = lkDoc
    ? await db.laporanKeuanganExtraction.findUnique({ where: { documentId: lkDoc.documentId } })
    : null;

  return {
    ...base,
    tahunLaporan: submission.tahunLaporan,
    jenisAudit: submission.jenisAudit,
    hasLaporanKeuanganDoc: !!lkDoc,
    akuntan: {
      nama: lk?.namaAkuntanPublik ?? null,
      nomorIzin: lk?.nomorIzinAkuntanPublik ?? null,
      tanggalIzin: lk?.tanggalIzinAkuntanPublik ?? null,
      tahunBuku: lk?.tahunBuku ?? null,
    },
    lampiranSlots: LAMPIRAN_FINE_LABELS.map((key) => ({
      key,
      filled: submission.documents.some((d) => d.classifiedType === key),
    })),
  };
}

import { describe, it, expect } from "bun:test";
import {
  parseFlexibleDate,
  rupsAktaFieldsPresentRule, tahunLaporanValidRule, tahunBukuOrderingRule,
  akuntanPublikRequiredRule, rupsAnnualWindowRule, akuntanIzinFormatRule,
  laporanKeuanganTahunMatchRule, rupsLampiranCompletenessRule,
  RUPS_TAHUNAN_RULE_SET,
} from "../rules/laporan-rups/index";
import type { RupsTahunanCtx } from "../context/rups-tahunan-context";
import type { RuleResult } from "../types";

const YEAR = new Date().getFullYear();

function ctx(over: Partial<RupsTahunanCtx> = {}): RupsTahunanCtx {
  return {
    input: {} as never,
    rupsQuorum: { pemegangSaham: [], hasBaRupsDoc: false },
    aktaFields: [
      { fieldKey: "nomor_akta", value: "12" },
      { fieldKey: "tanggal_akta", value: `10-04-${YEAR}` },
      { fieldKey: "tanggal_rups", value: `10-04-${YEAR}` },
    ],
    tahunLaporan: YEAR - 1,
    jenisAudit: "NON_AUDIT",
    hasLaporanKeuanganDoc: false,
    akuntan: { nama: null, nomorIzin: null, tanggalIzin: null, tahunBuku: null },
    lampiranSlots: [{ key: "LAMPIRAN_TJSL", filled: false }],
    ...over,
  } as RupsTahunanCtx;
}
const run = (r: { run: (c: RupsTahunanCtx) => unknown }, c: RupsTahunanCtx) => r.run(c) as RuleResult;

describe("parseFlexibleDate", () => {
  it("parses ISO / DD-MM-YYYY / DD/MM/YYYY / Indonesian word dates", () => {
    expect(parseFlexibleDate("2024-04-10")?.toISOString().slice(0, 10)).toBe("2024-04-10");
    expect(parseFlexibleDate("10-04-2024")?.toISOString().slice(0, 10)).toBe("2024-04-10");
    expect(parseFlexibleDate("10/04/2024")?.toISOString().slice(0, 10)).toBe("2024-04-10");
    expect(parseFlexibleDate("10 April 2024")?.toISOString().slice(0, 10)).toBe("2024-04-10");
    expect(parseFlexibleDate("31 Desember 2023")?.toISOString().slice(0, 10)).toBe("2023-12-31");
    expect(parseFlexibleDate("32 Januari 2024")).toBeNull();
    expect(parseFlexibleDate("kapan-kapan")).toBeNull();
    expect(parseFlexibleDate(null)).toBeNull();
  });
});

describe("RUPS_AKTA_FIELDS_PRESENT (FAIL)", () => {
  it("PASSes when nomor_akta + tanggal_akta present", () => {
    expect(run(rupsAktaFieldsPresentRule, ctx()).status).toBe("PASS");
  });
  it("FAILs listing the missing SABH-mandatory fields", () => {
    const c = ctx({ aktaFields: [{ fieldKey: "nomor_akta", value: "  " }] });
    const r = run(rupsAktaFieldsPresentRule, c);
    expect(r.status).toBe("FAIL");
    expect(r.message).toContain("nomor_akta");
    expect(r.message).toContain("tanggal_akta");
  });
});

describe("TAHUN_LAPORAN_VALID (FAIL, backlog window)", () => {
  it("FAILs when unset (nudges the picker; the gate also blocks)", () => {
    expect(run(tahunLaporanValidRule, ctx({ tahunLaporan: null })).status).toBe("FAIL");
  });
  it("accepts the -10 and -1 boundaries", () => {
    expect(run(tahunLaporanValidRule, ctx({ tahunLaporan: YEAR - 10 })).status).toBe("PASS");
    expect(run(tahunLaporanValidRule, ctx({ tahunLaporan: YEAR - 1 })).status).toBe("PASS");
  });
  it("FAILs at -11 and at the current year", () => {
    expect(run(tahunLaporanValidRule, ctx({ tahunLaporan: YEAR - 11 })).status).toBe("FAIL");
    expect(run(tahunLaporanValidRule, ctx({ tahunLaporan: YEAR })).status).toBe("FAIL");
  });
});

describe("TAHUN_BUKU_ORDERING (FAIL) — RUPS must be AFTER 31 Dec of tahunLaporan", () => {
  const base = { tahunLaporan: 2023 };
  it("FAILs on RUPS dated 31 Dec of the tahun buku (boundary)", () => {
    const c = ctx({ ...base, aktaFields: [{ fieldKey: "tanggal_rups", value: "31-12-2023" }] });
    expect(run(tahunBukuOrderingRule, c).status).toBe("FAIL");
  });
  it("PASSes on 1 Jan of tahunLaporan+1 (boundary)", () => {
    const c = ctx({ ...base, aktaFields: [{ fieldKey: "tanggal_rups", value: "01-01-2024" }] });
    expect(run(tahunBukuOrderingRule, c).status).toBe("PASS");
  });
  it("SKIPs when tahun unset or tanggal_rups unparseable", () => {
    expect(run(tahunBukuOrderingRule, ctx({ tahunLaporan: null })).status).toBe("SKIPPED");
    expect(run(tahunBukuOrderingRule, ctx({ ...base, aktaFields: [] })).status).toBe("SKIPPED");
  });
});

describe("AKUNTAN_PUBLIK_REQUIRED (conditional FAIL, UUPT Ps.68)", () => {
  it("SKIPs when NON_AUDIT or unattested", () => {
    expect(run(akuntanPublikRequiredRule, ctx({ jenisAudit: "NON_AUDIT" })).status).toBe("SKIPPED");
    expect(run(akuntanPublikRequiredRule, ctx({ jenisAudit: null })).status).toBe("SKIPPED");
  });
  it("FAILs under WAJIB_AUDIT listing every missing element (doc + 3 AP fields)", () => {
    const r = run(akuntanPublikRequiredRule, ctx({ jenisAudit: "WAJIB_AUDIT" }));
    expect(r.status).toBe("FAIL");
    expect(r.message).toContain("LAPORAN_KEUANGAN");
    expect(r.message).toContain("nama_akuntan_publik");
  });
  it("PASSes under WAJIB_AUDIT when doc + all three AP values exist", () => {
    const c = ctx({
      jenisAudit: "WAJIB_AUDIT", hasLaporanKeuanganDoc: true,
      akuntan: { nama: "KAP X", nomorIzin: "AP.1234", tanggalIzin: "2020-01-12", tahunBuku: "2023" },
    });
    expect(run(akuntanPublikRequiredRule, c).status).toBe("PASS");
  });
});

describe("RUPS_ANNUAL_WINDOW (WARNING — NEVER FAIL, Ps.78(2) + 10y backlog)", () => {
  it("WARNs when RUPS is after 30 Jun of tahunLaporan+1 — never FAIL even years late", () => {
    const c = ctx({ tahunLaporan: 2015, aktaFields: [{ fieldKey: "tanggal_rups", value: "10-04-2024" }] });
    const r = run(rupsAnnualWindowRule, c);
    expect(r.status).toBe("WARNING");
  });
  it("PASSes on/before 30 Jun of tahunLaporan+1", () => {
    const c = ctx({ tahunLaporan: 2023, aktaFields: [{ fieldKey: "tanggal_rups", value: "30-06-2024" }] });
    expect(run(rupsAnnualWindowRule, c).status).toBe("PASS");
  });
  it("SKIPs on missing inputs", () => {
    expect(run(rupsAnnualWindowRule, ctx({ tahunLaporan: null })).status).toBe("SKIPPED");
  });
});

describe("AKUNTAN_IZIN_FORMAT (WARNING — NEVER FAIL, no on-prem P2PK registry)", () => {
  it("SKIPs without a nomor izin; PASSes AP.1234; WARNs on odd shapes", () => {
    expect(run(akuntanIzinFormatRule, ctx()).status).toBe("SKIPPED");
    const ok = ctx({ akuntan: { nama: "X", nomorIzin: "AP.1234", tanggalIzin: null, tahunBuku: null } });
    expect(run(akuntanIzinFormatRule, ok).status).toBe("PASS");
    const odd = ctx({ akuntan: { nama: "X", nomorIzin: "SK-99/WEIRD", tanggalIzin: null, tahunBuku: null } });
    expect(run(akuntanIzinFormatRule, odd).status).toBe("WARNING");
  });
});

describe("LAPORAN_KEUANGAN_TAHUN_MATCH (WARNING)", () => {
  it("PASS on match, WARNING on mismatch, SKIPPED when either side missing", () => {
    const match = ctx({ tahunLaporan: 2023, akuntan: { nama: null, nomorIzin: null, tanggalIzin: null, tahunBuku: "per 31 Desember 2023" } });
    expect(run(laporanKeuanganTahunMatchRule, match).status).toBe("PASS");
    const mis = ctx({ tahunLaporan: 2023, akuntan: { nama: null, nomorIzin: null, tanggalIzin: null, tahunBuku: "2022" } });
    expect(run(laporanKeuanganTahunMatchRule, mis).status).toBe("WARNING");
    expect(run(laporanKeuanganTahunMatchRule, ctx()).status).toBe("SKIPPED");
  });
});

describe("RUPS_LAMPIRAN_COMPLETENESS (WARNING — NEVER FAIL, Ps.66(2) conditionals)", () => {
  it("WARNs listing empty slots; PASSes when all filled", () => {
    const r = run(rupsLampiranCompletenessRule, ctx());
    expect(r.status).toBe("WARNING");
    expect(r.message).toContain("LAMPIRAN_TJSL");
    const full = ctx({ lampiranSlots: [{ key: "LAMPIRAN_TJSL", filled: true }] });
    expect(run(rupsLampiranCompletenessRule, full).status).toBe("PASS");
  });
});

describe("RUPS_TAHUNAN_RULE_SET composition (the tuned matrix)", () => {
  const codes = RUPS_TAHUNAN_RULE_SET.map((r) => r.code);
  it("contains exactly the 14 tuned rules", () => {
    expect([...codes].sort()).toEqual([
      "AKUNTAN_IZIN_FORMAT", "AKUNTAN_PUBLIK_REQUIRED", "LAPORAN_KEUANGAN_TAHUN_MATCH",
      "NAMA_PT_CONSISTENCY", "NOTARIS_TERAKHIR", "NPWP_PERSEROAN_FUZZY",
      "OLD_DATA_CONSISTENCY", "PERSEROAN_STATE", "RUPS_AKTA_FIELDS_PRESENT",
      "RUPS_ANNUAL_WINDOW", "RUPS_ATTENDANCE_QUORUM", "RUPS_LAMPIRAN_COMPLETENESS",
      "TAHUN_BUKU_ORDERING", "TAHUN_LAPORAN_VALID",
    ]);
  });
  it("EXCLUDES AKTA_DATE_WINDOW — the 30-day window false-FAILs every backlog filing (guard: a runAllValidations refactor must trip this)", () => {
    expect(codes).not.toContain("AKTA_DATE_WINDOW");
  });
  it("EXCLUDES the identity/kontak/modal/KBLI/jenis groups (filing registers no person)", () => {
    for (const off of ["NIK_KTP_AKTA", "NAMA_NPWP_KTP", "KTP_COMPLETENESS", "NPWP_COMPLETENESS", "PASSPORT_AKTA", "CONTACT_INFO_COMPLETE", "PEMEGANG_SAHAM_CONTACT", "DOMISILI_NAMA", "MODAL_BUKTI_SETOR", "PP29_MODAL", "KBLI_VALID", "PERUBAHAN_KBLI", "JENIS_SELECTION_NONEMPTY", "CONTRADICTORY_JENIS", "REQUIRED_SUPPORTING_DOCS", "DATA_ACTUALLY_CHANGED"]) {
      expect(codes).not.toContain(off);
    }
  });
});

import type { Rule, RuleResult } from "../../types";
import type { RupsTahunanCtx } from "../../context/rups-tahunan-context";
import { PT_AKTA_RULE_SET, pickRules } from "../pt-akta/index";
import { rupsQuorumRule } from "../pt-akta/rups-quorum";

// ── date helper ───────────────────────────────────────────────────────────────
const MONTHS: Record<string, number> = {
  januari: 1, februari: 2, maret: 3, april: 4, mei: 5, juni: 6,
  juli: 7, agustus: 8, september: 9, oktober: 10, november: 11, desember: 12,
};
function utc(y: number, mo: number, d: number): Date | null {
  const dt = new Date(Date.UTC(y, mo - 1, d));
  return dt.getUTCFullYear() === y && dt.getUTCMonth() === mo - 1 && dt.getUTCDate() === d ? dt : null;
}
/** "2024-04-10" | "10-04-2024" | "10/04/2024" | "10 April 2024" → UTC Date | null. */
export function parseFlexibleDate(s: string | null | undefined): Date | null {
  if (!s) return null;
  const t = s.trim();
  let m = t.match(/^(\d{4})-(\d{2})-(\d{2})/);
  if (m) return utc(+m[1]!, +m[2]!, +m[3]!);
  m = t.match(/^(\d{1,2})[-/](\d{1,2})[-/](\d{4})/);
  if (m) return utc(+m[3]!, +m[2]!, +m[1]!);
  m = t.match(/^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})/);
  if (m) {
    const month = MONTHS[m[2]!.toLowerCase()];
    if (month) return utc(+m[3]!, month, +m[1]!);
  }
  return null;
}

const field = (ctx: RupsTahunanCtx, key: string): string | null =>
  ctx.aktaFields.find((f) => f.fieldKey === key)?.value ?? null;
const rr = (ruleCode: string, ruleLabel: string, status: RuleResult["status"], message: string, details?: unknown): RuleResult =>
  ({ ruleCode, ruleLabel, status, message, ...(details !== undefined ? { details: details as never } : {}) });

// ── the 8 flow rules ──────────────────────────────────────────────────────────

/** FAIL — SABH's two mandatory typed fields (no_akta_notaris + tanggal_akta_notaris).
 *  A terminal submit with them missing is an unfixable filing (no verifier catches it). */
export const rupsAktaFieldsPresentRule: Rule<RupsTahunanCtx> = {
  code: "RUPS_AKTA_FIELDS_PRESENT",
  label: "Nomor & Tanggal Akta RUPS Tahunan Terisi",
  run: (ctx) => {
    const missing: string[] = [];
    if (!field(ctx, "nomor_akta")?.trim()) missing.push("nomor_akta");
    if (!field(ctx, "tanggal_akta")?.trim()) missing.push("tanggal_akta");
    if (missing.length > 0)
      return rr("RUPS_AKTA_FIELDS_PRESENT", "Nomor & Tanggal Akta RUPS Tahunan Terisi", "FAIL",
        `Field akta wajib SABH belum terisi: ${missing.join(", ")}`, { missing });
    return rr("RUPS_AKTA_FIELDS_PRESENT", "Nomor & Tanggal Akta RUPS Tahunan Terisi", "PASS",
      "Nomor dan tanggal akta terisi");
  },
};

/** FAIL — SABH accepts backlog filings only within currentYear-10 … currentYear-1
 *  (the pelaporan dropdown window); outside it SABH hard-rejects. Unset → FAIL
 *  (nudges the picker; the submit gate independently blocks on unset). */
export const tahunLaporanValidRule: Rule<RupsTahunanCtx> = {
  code: "TAHUN_LAPORAN_VALID",
  label: "Tahun Laporan dalam Jendela Backlog SABH",
  run: (ctx) => {
    const now = new Date().getFullYear();
    const min = now - 10, max = now - 1;
    if (ctx.tahunLaporan == null)
      return rr("TAHUN_LAPORAN_VALID", "Tahun Laporan dalam Jendela Backlog SABH", "FAIL",
        `Tahun laporan belum dipilih (jendela ${min}-${max})`, { min, max });
    if (ctx.tahunLaporan < min || ctx.tahunLaporan > max)
      return rr("TAHUN_LAPORAN_VALID", "Tahun Laporan dalam Jendela Backlog SABH", "FAIL",
        `Tahun laporan ${ctx.tahunLaporan} di luar jendela backlog SABH (${min}-${max})`, { min, max });
    return rr("TAHUN_LAPORAN_VALID", "Tahun Laporan dalam Jendela Backlog SABH", "PASS",
      `Tahun laporan ${ctx.tahunLaporan} valid`);
  },
};

/** FAIL — a RUPS cannot ratify a fiscal year that has not ended: tanggal_rups must
 *  be strictly AFTER 31 Dec of tahunLaporan. Violation ⇒ OCR misread or wrong tahun. */
export const tahunBukuOrderingRule: Rule<RupsTahunanCtx> = {
  code: "TAHUN_BUKU_ORDERING",
  label: "Tanggal RUPS Setelah Akhir Tahun Buku",
  run: (ctx) => {
    const L = "Tanggal RUPS Setelah Akhir Tahun Buku";
    if (ctx.tahunLaporan == null)
      return rr("TAHUN_BUKU_ORDERING", L, "SKIPPED", "Tahun laporan belum dipilih");
    const rups = parseFlexibleDate(field(ctx, "tanggal_rups"));
    if (!rups)
      return rr("TAHUN_BUKU_ORDERING", L, "SKIPPED", "Tanggal RUPS tidak terbaca dari akta");
    const yearEnd = Date.UTC(ctx.tahunLaporan, 11, 31);
    if (rups.getTime() <= yearEnd)
      return rr("TAHUN_BUKU_ORDERING", L, "FAIL",
        `Tanggal RUPS (${field(ctx, "tanggal_rups")}) tidak setelah akhir tahun buku ${ctx.tahunLaporan} — periksa hasil OCR atau pilihan tahun`);
    return rr("TAHUN_BUKU_ORDERING", L, "PASS", "Tanggal RUPS setelah akhir tahun buku");
  },
};

/** Conditional FAIL — UUPT Ps.68(1)+(3): an audited PT files the audited laporan
 *  keuangan; under jenisAudit=WAJIB_AUDIT the doc + nama/izin/tanggal-izin AP are
 *  mandatory. SKIPPED when NON_AUDIT / unattested. */
export const akuntanPublikRequiredRule: Rule<RupsTahunanCtx> = {
  code: "AKUNTAN_PUBLIK_REQUIRED",
  label: "Kelengkapan Akuntan Publik (Wajib Audit)",
  run: (ctx) => {
    const L = "Kelengkapan Akuntan Publik (Wajib Audit)";
    if (ctx.jenisAudit !== "WAJIB_AUDIT")
      return rr("AKUNTAN_PUBLIK_REQUIRED", L, "SKIPPED",
        "Perseroan tidak wajib diaudit (NON_AUDIT / belum diattestasi)");
    const missing: string[] = [];
    if (!ctx.hasLaporanKeuanganDoc) missing.push("dokumen LAPORAN_KEUANGAN");
    if (!ctx.akuntan.nama?.trim()) missing.push("nama_akuntan_publik");
    if (!ctx.akuntan.nomorIzin?.trim()) missing.push("nomor_izin_akuntan_publik");
    if (!ctx.akuntan.tanggalIzin?.trim()) missing.push("tanggal_izin_akuntan_publik");
    if (missing.length > 0)
      return rr("AKUNTAN_PUBLIK_REQUIRED", L, "FAIL",
        `Wajib audit (UUPT Ps.68) — belum lengkap: ${missing.join(", ")}`, { missing });
    return rr("AKUNTAN_PUBLIK_REQUIRED", L, "PASS", "Data akuntan publik lengkap");
  },
};

/** WARNING — NEVER FAIL. UUPT Ps.78(2) wants the annual RUPS ≤6 months after the
 *  tahun buku ends, but lateness does NOT invalidate the RUPS or the filing, and
 *  SABH itself accepts a 10-year backlog — a hard FAIL would block the exact
 *  backlog filings this flow exists to accept. */
export const rupsAnnualWindowRule: Rule<RupsTahunanCtx> = {
  code: "RUPS_ANNUAL_WINDOW",
  label: "RUPS Tahunan ≤6 Bulan Setelah Tahun Buku (Ps.78(2))",
  run: (ctx) => {
    const L = "RUPS Tahunan ≤6 Bulan Setelah Tahun Buku (Ps.78(2))";
    if (ctx.tahunLaporan == null)
      return rr("RUPS_ANNUAL_WINDOW", L, "SKIPPED", "Tahun laporan belum dipilih");
    const rups = parseFlexibleDate(field(ctx, "tanggal_rups"));
    if (!rups) return rr("RUPS_ANNUAL_WINDOW", L, "SKIPPED", "Tanggal RUPS tidak terbaca");
    const deadline = Date.UTC(ctx.tahunLaporan + 1, 5, 30); // 30 Jun tahun+1
    if (rups.getTime() > deadline)
      return rr("RUPS_ANNUAL_WINDOW", L, "WARNING",
        `RUPS tahunan melewati 6 bulan setelah tahun buku ${ctx.tahunLaporan} (Ps.78(2)) — sah untuk backlog, mohon dikonfirmasi`);
    return rr("RUPS_ANNUAL_WINDOW", L, "PASS", "RUPS dalam jendela 6 bulan Ps.78(2)");
  },
};

/** WARNING — NEVER FAIL. No authoritative on-prem AP-license registry exists
 *  (P2PK Kemenkeu is a cloud service; the full on-premise constraint forbids the
 *  call) — we can flag an odd-looking izin, never assert invalidity. */
export const akuntanIzinFormatRule: Rule<RupsTahunanCtx> = {
  code: "AKUNTAN_IZIN_FORMAT",
  label: "Format Nomor Izin Akuntan Publik",
  run: (ctx) => {
    const L = "Format Nomor Izin Akuntan Publik";
    const izin = ctx.akuntan.nomorIzin?.trim();
    if (!izin) return rr("AKUNTAN_IZIN_FORMAT", L, "SKIPPED", "Nomor izin akuntan publik belum terisi");
    if (/^AP[.\s-]?\d{3,5}$/i.test(izin))
      return rr("AKUNTAN_IZIN_FORMAT", L, "PASS", `Nomor izin ${izin} berbentuk wajar (AP.xxxx)`);
    return rr("AKUNTAN_IZIN_FORMAT", L, "WARNING",
      `Nomor izin "${izin}" tidak berbentuk AP.xxxx — mohon periksa (verifikasi registri P2PK tidak tersedia on-premise)`);
  },
};

/** WARNING — the cover's tahun buku vs the picked tahunLaporan; grounded
 *  extraction may legitimately miss → advisory only. */
export const laporanKeuanganTahunMatchRule: Rule<RupsTahunanCtx> = {
  code: "LAPORAN_KEUANGAN_TAHUN_MATCH",
  label: "Tahun Buku Laporan Keuangan vs Tahun Laporan",
  run: (ctx) => {
    const L = "Tahun Buku Laporan Keuangan vs Tahun Laporan";
    const m = ctx.akuntan.tahunBuku?.match(/(\d{4})/);
    if (ctx.tahunLaporan == null || !m)
      return rr("LAPORAN_KEUANGAN_TAHUN_MATCH", L, "SKIPPED", "Tahun buku atau tahun laporan belum tersedia");
    if (+m[1]! !== ctx.tahunLaporan)
      return rr("LAPORAN_KEUANGAN_TAHUN_MATCH", L, "WARNING",
        `Tahun buku laporan keuangan (${m[1]}) ≠ tahun laporan dipilih (${ctx.tahunLaporan})`);
    return rr("LAPORAN_KEUANGAN_TAHUN_MATCH", L, "PASS", `Tahun buku ${m[1]} sesuai`);
  },
};

/** WARNING — NEVER FAIL. Ps.66(2) letters c (TJSL — Ps.74 sectoral), d (rincian
 *  masalah — may be nil) and g are conditional; hard-requiring all six slots is
 *  legally wrong. Advisory nudge listing the empty slots. */
export const rupsLampiranCompletenessRule: Rule<RupsTahunanCtx> = {
  code: "RUPS_LAMPIRAN_COMPLETENESS",
  label: "Kelengkapan Lampiran Laporan Tahunan (Ps.66(2))",
  run: (ctx) => {
    const L = "Kelengkapan Lampiran Laporan Tahunan (Ps.66(2))";
    const empty = ctx.lampiranSlots.filter((s) => !s.filled).map((s) => s.key);
    if (empty.length === 0)
      return rr("RUPS_LAMPIRAN_COMPLETENESS", L, "PASS", "Semua slot lampiran terisi");
    return rr("RUPS_LAMPIRAN_COMPLETENESS", L, "WARNING",
      `Slot lampiran kosong (sebagian bersifat kondisional): ${empty.join(", ")}`, { empty });
  },
};

// ── the assembled tuned matrix ────────────────────────────────────────────────

/** Wrapped shared rules (bodies bit-for-bit in cross-validator.ts). The SABH
 *  round-trips for PERSEROAN_STATE / NOTARIS_TERAKHIR happen inside
 *  buildPtAktaContext (blokir state + notaris id pre-resolved into ctx.input),
 *  so these wrappers are sync — the spec's async:true note predates the wrappers. */
export const RUPS_TAHUNAN_SHARED_RULE_CODES = [
  "NAMA_PT_CONSISTENCY", "OLD_DATA_CONSISTENCY", "NOTARIS_TERAKHIR",
  "NPWP_PERSEROAN_FUZZY", "PERSEROAN_STATE",
] as const;

/**
 * THE tuned matrix (flow-spec §4.5). DELIBERATE EXCLUSIONS (do not "fix"):
 * AKTA_DATE_WINDOW (false-FAILs every 10-year backlog filing — replaced by
 * TAHUN_LAPORAN_VALID/TAHUN_BUKU_ORDERING/RUPS_ANNUAL_WINDOW) and the whole
 * identity/kontak/modal/saham/KBLI/jenis group (this filing registers nobody).
 * RUPS quorum rides the SHARED wrapper (default >1/2, Ps.86(1)) and emits the
 * shared code RUPS_ATTENDANCE_QUORUM.
 */
export const RUPS_TAHUNAN_RULE_SET: Rule<RupsTahunanCtx>[] = [
  rupsAktaFieldsPresentRule,
  tahunLaporanValidRule,
  tahunBukuOrderingRule,
  akuntanPublikRequiredRule,
  rupsAnnualWindowRule,
  akuntanIzinFormatRule,
  laporanKeuanganTahunMatchRule,
  rupsLampiranCompletenessRule,
  ...pickRules(PT_AKTA_RULE_SET, RUPS_TAHUNAN_SHARED_RULE_CODES),
  rupsQuorumRule(),
];

import { describe, it, expect, afterAll, afterEach } from "bun:test";
import { db } from "../../lib/db";
import { extractLaporanKeuanganAkuntan, detectTahunBuku, runLaporanKeuanganPass } from "../laporan-keuangan-extract";

const RAW =
  "LAPORAN KEUANGAN\nPT RUPS UJI\nuntuk tahun yang berakhir pada tanggal 31 Desember 2023\n" +
  "LAPORAN AUDITOR INDEPENDEN\nKAP Mulyoto & Rekan\nIzin Akuntan Publik AP.1234 tanggal 12 Januari 2020\nOPINI WAJAR TANPA PENGECUALIAN";

function mockLlm(content: object | null, status = 200) {
  const orig = globalThis.fetch;
  globalThis.fetch = (async () =>
    new Response(
      JSON.stringify({ choices: [{ message: { content: content ? JSON.stringify(content) : "" } }] }),
      { status },
    )) as typeof fetch;
  return () => { globalThis.fetch = orig; };
}

describe("detectTahunBuku", () => {
  it("reads the fiscal year off the cover", () => {
    expect(detectTahunBuku(RAW)).toBe("2023");
    expect(detectTahunBuku("tahun buku 2019 ...")).toBe("2019");
    expect(detectTahunBuku("no year here")).toBeNull();
  });
});

describe("extractLaporanKeuanganAkuntan (grounded 3B)", () => {
  const origEnv = process.env.CLEANUP_LLM_URL;
  afterEach(() => { process.env.CLEANUP_LLM_URL = origEnv; });

  it("grounds every value on rawText — a hallucinated AP name becomes null", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({
      nama_akuntan_publik: "KAP Halusinasi Sejahtera", // NOT in rawText → null
      nomor_izin_akuntan_publik: "AP.1234",
      tanggal_izin_akuntan_publik: "12 Januari 2020",
      tahun_buku: "2023",
    });
    try {
      const r = await extractLaporanKeuanganAkuntan(RAW);
      expect(r.nama_akuntan_publik).toBeNull();
      expect(r.nomor_izin_akuntan_publik).toBe("AP.1234");
      expect(r.tanggal_izin_akuntan_publik).toBe("12 Januari 2020");
      expect(r.tahun_buku).toBe("2023");
    } finally { restore(); }
  });

  it("falls back to detectTahunBuku when the LLM misses tahun_buku", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nama_akuntan_publik: null, nomor_izin_akuntan_publik: null, tanggal_izin_akuntan_publik: null, tahun_buku: null });
    try {
      const r = await extractLaporanKeuanganAkuntan(RAW);
      expect(r.tahun_buku).toBe("2023");
    } finally { restore(); }
  });

  it("returns all-null on empty rawText (visible warn path) and never throws on LLM outage", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm(null, 500);
    try {
      expect(await extractLaporanKeuanganAkuntan("")).toEqual({
        nama_akuntan_publik: null, nomor_izin_akuntan_publik: null, tanggal_izin_akuntan_publik: null, tahun_buku: null,
      });
      const r = await extractLaporanKeuanganAkuntan(RAW); // outage → deterministic tahun only
      expect(r.nama_akuntan_publik).toBeNull();
      expect(r.tahun_buku).toBe("2023");
    } finally { restore(); }
  });
});

describe("runLaporanKeuanganPass persistence", () => {
  const docIds: string[] = [];
  afterAll(async () => { await db.document.deleteMany({ where: { id: { in: docIds } } }); });

  async function seedDoc() {
    const doc = await db.document.create({
      data: { filename: "lk.pdf", originalName: "lk.pdf", fileSize: 0, filePath: "/tmp/lk.pdf", documentType: "LAPORAN_KEUANGAN", status: "VERIFICATION_READY", rawText: RAW },
    });
    docIds.push(doc.id);
    return doc.id;
  }

  it("persists the satellite + ExtractedField rows (grounded-tier 0.75 confidence)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nama_akuntan_publik: "KAP Mulyoto & Rekan", nomor_izin_akuntan_publik: "AP.1234", tanggal_izin_akuntan_publik: "12 Januari 2020", tahun_buku: "2023" });
    try {
      const documentId = await seedDoc();
      await runLaporanKeuanganPass({ submissionId: "s", documentId, rawText: RAW });
      const lk = await db.laporanKeuanganExtraction.findUnique({ where: { documentId } });
      expect(lk?.namaAkuntanPublik).toBe("KAP Mulyoto & Rekan");
      expect(lk?.confidence).toBe(0.75);
      const f = await db.extractedField.findUnique({ where: { documentId_fieldKey: { documentId, fieldKey: "nomor_izin_akuntan_publik" } } });
      expect(f?.value).toBe("AP.1234");
      expect(f?.status).toBe("EDITABLE");
    } finally { restore(); }
  });

  it("is idempotent-once: NEVER clobbers an existing satellite (manual entry survives resume)", async () => {
    process.env.CLEANUP_LLM_URL = "http://mock";
    const restore = mockLlm({ nama_akuntan_publik: "KAP Mulyoto & Rekan", nomor_izin_akuntan_publik: null, tanggal_izin_akuntan_publik: null, tahun_buku: null });
    try {
      const documentId = await seedDoc();
      await db.laporanKeuanganExtraction.create({ data: { documentId, namaAkuntanPublik: "ENTRI MANUAL OPERATOR" } });
      await runLaporanKeuanganPass({ submissionId: "s", documentId, rawText: RAW });
      const lk = await db.laporanKeuanganExtraction.findUnique({ where: { documentId } });
      expect(lk?.namaAkuntanPublik).toBe("ENTRI MANUAL OPERATOR");
    } finally { restore(); }
  });

  it("skips loudly (no satellite) on empty rawText", async () => {
    const documentId = await seedDoc();
    await runLaporanKeuanganPass({ submissionId: "s", documentId, rawText: "" });
    expect(await db.laporanKeuanganExtraction.findUnique({ where: { documentId } })).toBeNull();
  });
});