General Ledger Entry Consolidation for DATEV Export

Original Entries (100 entries total):
- 2024-01-01 to 2024-01-31: Daily sales entries, same accounts (1000→4000)
- Each day has 3-5 transactions
- Mix of positive amounts (+100, +150, +200) and negative amounts (-50 for credit notes)

❌ Alternative Approach (NOT used): With Date Grouping
100 entries → 31 consolidated entries (one per day) = 69% reduction
↑ NOT what we're doing

✅ This RFC Approach: WITHOUT Date Grouping (consolidate across all dates)
100 entries → 1 consolidated entry (all dates combined) = 99% reduction
↑ This is what we implement

Consolidation Rules (what we DO consolidate across):
  ✅ Transaction dates (Jan 1, Jan 5, Jan 20 → all combine)
  ✅ Amount signs (positive + negative → algebraic sum)
     - Example: +100, +150, -50, +200 = 400 total
     - Soll/Haben indicator set based on final sign (positive = S, negative = H)

What we DON'T consolidate across (must match):
  ❌ Accounts (debit/credit must be same)
  ❌ Tax rates (19% vs 7% stay separate)
  ❌ Dimensions (different cost centers stay separate)

Why? Consolidating across dates AND signs provides maximum reduction while
maintaining accounting accuracy. The date range (Jan 1-31) is preserved in
metadata and the Sammelbeleg PDF shows all individual transaction dates and amounts.

-- Migration: 20241023_add_consolidation_tracking.sql

ALTER TABLE "general_ledger"
  ADD COLUMN "consolidation_id" TEXT,
  ADD COLUMN "is_consolidated" BOOLEAN DEFAULT false,
  ADD COLUMN "consolidated_from_ids" JSONB,
  ADD COLUMN "consolidation_metadata" JSONB,
  ADD COLUMN "sammelbeleg_document_id" TEXT; -- References documents table

-- Foreign key to documents table
ALTER TABLE "general_ledger"
  ADD CONSTRAINT "general_ledger_sammelbeleg_document_fkey"
  FOREIGN KEY ("sammelbeleg_document_id") REFERENCES "documents"("id")
  ON DELETE SET NULL;

-- Indexes for performance
CREATE INDEX "general_ledger_consolidation_id_idx"
  ON "general_ledger"("consolidation_id");

CREATE INDEX "general_ledger_is_consolidated_org_idx"
  ON "general_ledger"("is_consolidated", "org_id");

CREATE INDEX "general_ledger_sammelbeleg_document_id_idx"
  ON "general_ledger"("sammelbeleg_document_id");

-- Add composite index for consolidation grouping (excludes transaction_date, includes tax_rate)
CREATE INDEX "general_ledger_consolidation_key_idx"
  ON "general_ledger"(
    "org_id",
    "accounting_period_id",
    "debit_account_id",
    "credit_account_id",
    "tax_rate",
    "is_deleted"
  ) WHERE "is_deleted" = false;

CREATE TABLE "consolidation_logs" (
    "id" TEXT NOT NULL,
    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    "period_id" TEXT NOT NULL,
    "org_id" TEXT NOT NULL,
    "actor_id" TEXT,
    "export_type" TEXT NOT NULL, -- 'test' or 'period_close'
    "consolidation_count" INTEGER NOT NULL,
    "original_entry_count" INTEGER NOT NULL,
    "reduction_percentage" DOUBLE PRECISION NOT NULL,
    "consolidation_rules" JSONB NOT NULL,
    "csv_export_path" TEXT,
    "is_virtual" BOOLEAN NOT NULL DEFAULT false,

    CONSTRAINT "consolidation_logs_pkey" PRIMARY KEY ("id")
);

CREATE INDEX "consolidation_logs_period_id_idx"
  ON "consolidation_logs"("period_id");

CREATE INDEX "consolidation_logs_org_created_idx"
  ON "consolidation_logs"("org_id", "created_at");

-- Create dedicated object_type for Sammelbeleg documents
-- This allows easy filtering and identification of consolidation documents

INSERT INTO "object_types" ("id", "label", "category")
VALUES ('SAMMELBELEG', 'Sammelbeleg', 'INTERNAL');

-- Note: This creates a distinct document type that can be:
-- - Filtered from normal document lists
-- - Queried separately for consolidation reports
-- - Clearly identified in document management UI

// Get only business documents (exclude Sammelbeleg)
const businessDocuments = await prisma.documents.findMany({
  where: {
    org_id: organizationId,
    object_type_id: { not: "SAMMELBELEG" },
    is_deleted: false,
  },
});

// Get only Sammelbeleg documents
const sammelbelegDocuments = await prisma.documents.findMany({
  where: {
    org_id: organizationId,
    object_type_id: "SAMMELBELEG",
    is_deleted: false,
  },
});

// Get all documents (including Sammelbeleg)
const allDocuments = await prisma.documents.findMany({
  where: {
    org_id: organizationId,
    is_deleted: false,
  },
});

interface ConsolidationGroupKey {
  debitAccountId: string;
  creditAccountId: string;
  dimensionsHash: string; // Deterministic hash of sorted dimensions
  currency: string;
  taxRate: string; // Tax rate as string (null becomes 'null')
  // NOTE: Transaction date is NOT part of the consolidation key
  // NOTE: Amount sign is NOT part of the consolidation key (amounts sum algebraically)
}

function generateConsolidationKey(entry: GeneralLedgerEntry): string {
  // Sort dimensions for consistent hashing
  const sortedDimensions = entry.dimensions
    ? Object.entries(entry.dimensions)
        .sort(([a], [b]) => a.localeCompare(b))
        .map(([key, value]) => `${key}:${value}`)
        .join("|")
    : "null";

  // Tax rate as string (null becomes 'null')
  const taxRateKey = entry.tax_rate !== null ? entry.tax_rate.toString() : "null";

  // NOTE: Date is NOT included in consolidation key
  // This allows entries from different dates to be consolidated together
  // NOTE: Amount sign is NOT included - amounts sum algebraically (e.g., 100 + (-50) = 50)
  return [
    entry.debit_account_id,
    entry.credit_account_id,
    sortedDimensions,
    entry.currency,
    taxRateKey,
  ].join("::");
}

interface ConsolidatedEntry {
  consolidationId: string; // CUID for the consolidated entry
  originalEntryIds: string[]; // Array of original GL entry IDs
  transactionDateRange: {
    earliest: Date; // Earliest transaction date from consolidated entries
    latest: Date; // Latest transaction date from consolidated entries
  };
  debitAccountId: string;
  creditAccountId: string;
  dimensions: Record<string, any>;
  consolidatedAmount: number; // Sum of all amounts
  currency: string;
  taxRate: number | null; // Consolidated tax rate (all entries must have same rate)

  // New Belegfeld 1 for consolidated entry (DATEV compliant: max 36 chars)
  consolidatedBelegfeld1: string; // Format: CONS-{cuid} (e.g., "CONS-clh5z1234567890abcdef")

  // Original reconciliation data (for audit trail)
  originalReconciliationGroups: Array<{
    id: string;
    reconciledOn: string | null; // Original Belegfeld 1 value
    reconciledAt: Date | null; // When reconciliation was completed
    amount: number; // Amount from this group
    entryIds: string[]; // Which original entries used this group
  }>;

  // Metadata
  entryCount: number;
  taxRates: Array<{ rate: number; amount: number }>; // Multiple tax rates
  documents: Array<{ id: string; number: string; date: Date }>; // Source documents with dates
  allReconciledWithinPeriod: boolean; // Validation flag

  // Sammelbeleg (Collective Receipt) PDF
  sammelbelegDocumentId?: string; // ID of the Sammelbeleg document in documents table
  sammelbelegPdfUrl?: string; // URL to the generated PDF
}

Original Entries (Note: Different dates, same tax rate, all recon groups complete):
1. Date: 2024-01-10, 1000 → 4000, Amount: 100 EUR, Tax: 19%, Recon: Group-A (Reconciled: 2024-01-12)
2. Date: 2024-01-15, 1000 → 4000, Amount: 150 EUR, Tax: 19%, Recon: Group-B (Reconciled: 2024-01-18)
3. Date: 2024-01-20, 1000 → 4000, Amount: 200 EUR, Tax: 19%, Recon: Group-C (Reconciled: 2024-01-22)
4. Date: 2024-01-25, 1000 → 4000, Amount:  50 EUR, Tax: 19%, Recon: Group-D (Reconciled: 2024-01-28)

Exported Period: 2024-01-01 to 2024-01-31
✅ Same accounts + dimensions + tax rate (19%)
✅ All reconciliation groups reconciled within period
→ Can consolidate

Consolidated Entry:
- Amount: 450 EUR (100+150+200+50)
- Tax Rate: 19%
- Date Range: 2024-01-10 to 2024-01-25 (earliest to latest)
- New Belegfeld 1: "CONS-clh5z1234567890abc" (NEW reconciliation ID for consolidated entry)
- Original Reconciliation Groups: [Group-A, Group-B, Group-C, Group-D] (stored in metadata)
- Entry Count: 4 entries

Entry 1: Reconciled 2024-01-28 ✅ (within period Jan 2024)
Entry 2: Reconciled 2024-02-05 ❌ (outside period, in Feb 2024)
→ These entries would NOT be consolidated together in Jan 2024 export

Why? Entry 2's reconciliation is not complete in January, so it would appear
as "unreconciled" in the January export. Consolidating would create an
incomplete reconciliation unit.

Solution: Entry 1 exports individually in Jan with its original Belegfeld 1.
          Entry 2 exports individually in Feb with its original Belegfeld 1.

Entry 1: Tax Rate: 19%, Account: 1000 → 4000, Dimensions: {}, Reconciled ✅
Entry 2: Tax Rate: 7%,  Account: 1000 → 4000, Dimensions: {}, Reconciled ✅
→ These entries would NOT be consolidated together

Why? Different tax rates represent different tax treatment and must be
reported separately for tax compliance.

Solution: Each exports as separate line (or consolidates with entries of same tax rate)

Entry 1: Amount: +100 EUR, Account: 1000 → 4000, Tax: 19%, Reconciled ✅ (Invoice)
Entry 2: Amount: -50 EUR,  Account: 1000 → 4000, Tax: 19%, Reconciled ✅ (Credit Note)
→ These entries WOULD be consolidated together ✅

Why? Amounts sum algebraically in consolidation (100 + (-50) = 50).
In DATEV export, the amount is always absolute with a Soll/Haben indicator.

Result:
  - Consolidated Amount: 50 EUR
  - DATEV Export: Umsatz=50,00, Soll/Haben=S (if result is positive)

This is correct because the net effect is +50 EUR on the accounts.

# One consolidated entry with new reconciliation ID
Umsatz,Konto,Gegenkonto,Belegfeld 1,...
450.00,1000,4000,CONS-clh5z1234567890,...  # New Belegfeld 1 for consolidated entry

// packages/core/src/general_ledger/consolidate-entries.ts
import { createId } from "@paralleldrive/cuid2";

interface ConsolidateGLEntriesParams {
  periodId: string;
  organizationId: string;
  actorId?: string;
  isPersistent: boolean; // true for period close, false for test export
}

interface ConsolidationResult {
  consolidatedEntries: ConsolidatedEntry[];
  consolidationMap: Map<string, string[]>; // consolidationId → originalEntryIds
  originalCount: number;
  consolidatedCount: number;
  reductionPercentage: number;
  csvData: ConsolidationCSVRow[];
}

export async function consolidateGLEntries({
  periodId,
  organizationId,
  actorId,
  isPersistent,
}: ConsolidateGLEntriesParams): Promise<ActionResponse<ConsolidationResult>> {
  try {
    // 0. Get period date range for reconciliation validation
    const period = await prisma.accounting_periods.findUnique({
      where: { id: periodId },
      select: { start_date: true, end_date: true },
    });

    if (!period) {
      throw new Error("Accounting period not found");
    }

    // 1. Fetch all GL entries for the period
    const entries = await prisma.general_ledger.findMany({
      where: {
        accounting_period_id: periodId,
        org_id: organizationId,
        is_deleted: false,
      },
      include: {
        debit_account: { select: { account_nr: true } },
        credit_account: { select: { account_nr: true } },
        document: { select: { id: true, nr: true } },
        debit_reconciliation_group: {
          select: {
            id: true,
            reconciled_on: true,
            reconciled_at: true, // CRITICAL: Need this to check if reconciled within period
          },
        },
        credit_reconciliation_group: {
          select: {
            id: true,
            reconciled_on: true,
            reconciled_at: true, // CRITICAL: Need this to check if reconciled within period
          },
        },
      },
    });

    // 2. Group entries by consolidation key
    const groups = new Map<string, GeneralLedgerEntry[]>();

    for (const entry of entries) {
      const key = generateConsolidationKey(entry);
      if (!groups.has(key)) {
        groups.set(key, []);
      }
      groups.get(key)!.push(entry);
    }

    // 3. Create consolidated entries
    const consolidatedEntries: ConsolidatedEntry[] = [];
    const consolidationMap = new Map<string, string[]>();
    const csvData: ConsolidationCSVRow[] = [];

    for (const [key, groupEntries] of groups.entries()) {
      if (groupEntries.length === 1) {
        // Don't consolidate single entries
        continue;
      }

      // CRITICAL: Check if ALL reconciliation groups are complete within period
      const allReconciledWithinPeriod = groupEntries.every((entry) => {
        const debitReconDate = entry.debit_reconciliation_group?.reconciled_at;
        const creditReconDate = entry.credit_reconciliation_group?.reconciled_at;

        // If entry has reconciliation, it must be reconciled within period
        const debitOk =
          !entry.debit_reconciliation_group_id ||
          (debitReconDate &&
            debitReconDate >= period.start_date &&
            debitReconDate <= period.end_date);

        const creditOk =
          !entry.credit_reconciliation_group_id ||
          (creditReconDate &&
            creditReconDate >= period.start_date &&
            creditReconDate <= period.end_date);

        return debitOk && creditOk;
      });

      if (!allReconciledWithinPeriod) {
        // Skip consolidation if not all reconciliation groups are complete in period
        continue;
      }

      const consolidationId = createId(); // CUID for tracking/database
      const originalIds = groupEntries.map((e) => e.id);

      // Aggregate amounts
      const consolidatedAmount = groupEntries.reduce((sum, e) => sum + e.amount, 0);

      // Collect original reconciliation groups for audit trail
      const originalReconGroups = new Map<
        string,
        {
          id: string;
          reconciledOn: string | null;
          reconciledAt: Date | null;
          amount: number;
          entryIds: string[];
        }
      >();

      for (const entry of groupEntries) {
        // Collect credit reconciliation groups
        if (entry.credit_reconciliation_group_id) {
          const reconId = entry.credit_reconciliation_group_id;
          if (!originalReconGroups.has(reconId)) {
            originalReconGroups.set(reconId, {
              id: reconId,
              reconciledOn: entry.credit_reconciliation_group?.reconciled_on || null,
              reconciledAt: entry.credit_reconciliation_group?.reconciled_at || null,
              amount: entry.amount,
              entryIds: [entry.id],
            });
          } else {
            const existing = originalReconGroups.get(reconId)!;
            existing.amount += entry.amount;
            existing.entryIds.push(entry.id);
          }
        }
      }

      // Calculate date range from all entries
      const dates = groupEntries.map((e) => e.transaction_date);
      const earliestDate = new Date(Math.min(...dates.map((d) => d.getTime())));
      const latestDate = new Date(Math.max(...dates.map((d) => d.getTime())));

      // Build consolidated entry
      const consolidated: ConsolidatedEntry = {
        consolidationId,
        originalEntryIds: originalIds,
        transactionDateRange: {
          earliest: earliestDate,
          latest: latestDate,
        },
        debitAccountId: groupEntries[0].debit_account_id,
        creditAccountId: groupEntries[0].credit_account_id,
        dimensions: groupEntries[0].dimensions as Record<string, any>,
        consolidatedAmount,
        currency: groupEntries[0].currency,
        taxRate: groupEntries[0].tax_rate, // All entries have same tax rate (validated by grouping key)

        // NEW: Generate new Belegfeld 1 for consolidated entry (DATEV compliant: max 36 chars)
        // Format: CONS-{cuid} = 5 + 25 = 30 characters total (well within 36 char limit)
        consolidatedBelegfeld1: `CONS-${consolidationId}`,

        // Store original reconciliation groups for audit trail
        originalReconciliationGroups: Array.from(originalReconGroups.values()),

        allReconciledWithinPeriod: true, // Already validated above
        entryCount: groupEntries.length,
        taxRates: extractTaxRates(groupEntries),
        documents: groupEntries.map((e) => ({
          id: e.document_id || "",
          number: e.document?.nr || "",
          date: e.transaction_date,
        })),
      };

      consolidatedEntries.push(consolidated);
      consolidationMap.set(consolidationId, originalIds);

      // Build CSV data
      for (const entry of groupEntries) {
        csvData.push({
          consolidation_id: consolidationId,
          original_entry_id: entry.id,
          document_id: entry.document_id || "",
          document_number: entry.document?.nr || "",
          transaction_date: entry.transaction_date.toISOString().split("T")[0],
          debit_account: entry.debit_account?.account_nr || "",
          credit_account: entry.credit_account?.account_nr || "",
          amount: entry.amount,
          currency: entry.currency,
          reconciled_on:
            entry.debit_reconciliation_group?.reconciled_on ||
            entry.credit_reconciliation_group?.reconciled_on ||
            "",
          dimensions: JSON.stringify(entry.dimensions),
          consolidated_amount: consolidatedAmount,
          entries_in_group: groupEntries.length,
        });
      }
    }

    // 4. Persist if required (period close)
    if (isPersistent && consolidatedEntries.length > 0) {
      await persistConsolidation({
        consolidatedEntries,
        periodId,
        organizationId,
        actorId,
      });
    }

    const reductionPercentage =
      ((entries.length - consolidatedEntries.length) / entries.length) * 100;

    return {
      success: true,
      message: `Consolidated ${entries.length} entries into ${consolidatedEntries.length}`,
      data: {
        consolidatedEntries,
        consolidationMap,
        originalCount: entries.length,
        consolidatedCount: consolidatedEntries.length,
        reductionPercentage,
        csvData,
      },
    };
  } catch (error) {
    return {
      success: false,
      message: "Failed to consolidate GL entries",
      error: error instanceof Error ? error.message : "Unknown error",
    };
  }
}

┌─────────────────────────────────────────────────────────────┐
│       SAMMELBELEG / COLLECTIVE POSTING DOCUMENT             │
│                                                              │
│  Beleg-Nr: CONS-clh5z1234567890                             │
│  Datum: 31.01.2024                                           │
│  Zeitraum: 01.01.2024 - 31.01.2024                          │
│  Organisation: Example GmbH                                  │
│  Buchungskreis: 2024-01                                      │
│  Erstellt: 31.01.2024 15:30:00 UTC                          │
├─────────────────────────────────────────────────────────────┤
│  ZUSAMMENFASSUNG / SUMMARY                                  │
│  ──────────────────────────────────────────────────────     │
│  Konto (Soll):    1000 - Bank Account EUR                   │
│  Konto (Haben):   4000 - Sales Revenue                      │
│  Gesamtbetrag:    450,00 EUR                                │
│  Steuersatz:      19%                                        │
│  Anzahl Posten:   4 Einzelbuchungen                         │
├─────────────────────────────────────────────────────────────┤
│  EINZELBUCHUNGEN / INDIVIDUAL POSTINGS                      │
├───────┬──────────┬──────────┬──────────┬────────────────────┤
│ Pos.  │  Datum   │ Beleg-Nr │  Betrag  │ Dokument           │
├───────┼──────────┼──────────┼──────────┼────────────────────┤
│   1   │ 10.01.24 │ INV-001  │  100,00  │ Invoice #001       │
│   2   │ 15.01.24 │ INV-002  │  150,00  │ Invoice #002       │
│   3   │ 20.01.24 │ INV-003  │  200,00  │ Invoice #003       │
│   4   │ 25.01.24 │ INV-004  │   50,00  │ Invoice #004       │
├───────┴──────────┴──────────┼──────────┼────────────────────┤
│             GESAMT / TOTAL   │  450,00  │                    │
└──────────────────────────────┴──────────┴────────────────────┘

  ORIGINAL RECONCILIATION GROUPS
  ──────────────────────────────────────────────────────────
  • Group-A (REC-001): Reconciled 12.01.2024
  • Group-B (REC-002): Reconciled 18.01.2024
  • Group-C (REC-003): Reconciled 22.01.2024
  • Group-D (REC-004): Reconciled 28.01.2024

  DIMENSIONEN / DIMENSIONS
  ──────────────────────────────────────────────────────────
  • Kostenstelle: CC-001
  • Projekt: PRJ-2024-Q1
  • Abteilung: Vertrieb

  VERIFICATION / PRÜFUNG
  ──────────────────────────────────────────────────────────
  Generiert: 2024-01-31 15:30:00 UTC
  Erstellt von: Max Mustermann (max@example.com)
  Digitale Signatur: SHA256:abc123def456...

  Dieses Dokument dient als Belegnachweis für die
  konsolidierte Hauptbuchbuchung im Zeitraum Jan 2024.
  Alle Einzeltransaktionen bleiben im System nachvollziehbar.

// packages/core/src/general_ledger/generate-sammelbeleg-pdf.ts

import PDFDocument from "pdfkit";
import type { ConsolidatedEntry } from "./consolidate-entries";

interface GenerateSammelbelegParams {
  consolidatedEntry: ConsolidatedEntry;
  organizationName: string;
  periodName: string;
  createdBy: {
    name: string;
    email: string;
  };
  locale?: string; // 'de' or 'en', default 'de'
}

export async function generateSammelbelegPDF({
  consolidatedEntry,
  organizationName,
  periodName,
  createdBy,
  locale = "de",
}: GenerateSammelbelegParams): Promise<Buffer> {
  const doc = new PDFDocument({
    size: "A4",
    margin: 50,
    info: {
      Title: `Sammelbeleg ${consolidatedEntry.consolidatedBelegfeld1}`,
      Author: createdBy.name,
      Subject: "Collective Posting Document",
      Keywords: "sammelbeleg, consolidation, accounting",
    },
  });

  const chunks: Buffer[] = [];
  doc.on("data", (chunk) => chunks.push(chunk));

  // === HEADER ===
  doc.fontSize(16).font("Helvetica-Bold");
  doc.text("SAMMELBELEG / COLLECTIVE POSTING DOCUMENT", {
    align: "center",
  });
  doc.moveDown(1.5);

  // === METADATA SECTION ===
  doc.fontSize(10).font("Helvetica");
  const metadataStartY = doc.y;

  doc.text(`Beleg-Nr: ${consolidatedEntry.consolidatedBelegfeld1}`, 50, metadataStartY);
  doc.text(`Datum: ${formatDateGerman(consolidatedEntry.transactionDateRange.latest)}`);
  doc.text(
    `Zeitraum: ${formatDateGerman(consolidatedEntry.transactionDateRange.earliest)} - ${formatDateGerman(consolidatedEntry.transactionDateRange.latest)}`
  );
  doc.text(`Organisation: ${organizationName}`);
  doc.text(`Buchungskreis: ${periodName}`);
  doc.text(`Erstellt: ${new Date().toISOString().replace("T", " ").substring(0, 19)} UTC`);
  doc.moveDown(1.5);

  // Horizontal line
  doc.moveTo(50, doc.y).lineTo(550, doc.y).stroke();
  doc.moveDown(0.5);

  // === SUMMARY SECTION ===
  doc.fontSize(12).font("Helvetica-Bold");
  doc.text("ZUSAMMENFASSUNG / SUMMARY");
  doc.moveDown(0.5);

  doc.fontSize(10).font("Helvetica");
  doc.text(
    `Konto (Soll):    ${consolidatedEntry.debitAccount?.account_nr || "N/A"} - ${consolidatedEntry.debitAccount?.name || ""}`
  );
  doc.text(
    `Konto (Haben):   ${consolidatedEntry.creditAccount?.account_nr || "N/A"} - ${consolidatedEntry.creditAccount?.name || ""}`
  );
  doc.text(
    `Gesamtbetrag:    ${formatCurrency(consolidatedEntry.consolidatedAmount)} ${consolidatedEntry.currency}`
  );
  doc.text(
    `Steuersatz:      ${consolidatedEntry.taxRate !== null ? consolidatedEntry.taxRate + "%" : "N/A"}`
  );
  doc.text(`Anzahl Posten:   ${consolidatedEntry.entryCount} Einzelbuchungen`);
  doc.moveDown(1.5);

  // Horizontal line
  doc.moveTo(50, doc.y).lineTo(550, doc.y).stroke();
  doc.moveDown(0.5);

  // === INDIVIDUAL POSTINGS TABLE ===
  doc.fontSize(12).font("Helvetica-Bold");
  doc.text("EINZELBUCHUNGEN / INDIVIDUAL POSTINGS");
  doc.moveDown(0.5);

  // Table header
  const tableTop = doc.y;
  const col1 = 50; // Pos
  const col2 = 90; // Datum
  const col3 = 160; // Beleg-Nr
  const col4 = 270; // Betrag
  const col5 = 350; // Dokument

  doc.fontSize(9).font("Helvetica-Bold");
  doc.text("Pos.", col1, tableTop);
  doc.text("Datum", col2, tableTop);
  doc.text("Beleg-Nr", col3, tableTop);
  doc.text("Betrag", col4, tableTop);
  doc.text("Dokument", col5, tableTop);

  // Header underline
  doc
    .moveTo(col1, tableTop + 15)
    .lineTo(550, tableTop + 15)
    .stroke();

  // Table rows
  doc.font("Helvetica");
  let rowY = tableTop + 20;

  for (let i = 0; i < consolidatedEntry.documents.length; i++) {
    const docInfo = consolidatedEntry.documents[i];

    // Check if we need a new page
    if (rowY > 700) {
      doc.addPage();
      rowY = 50;
    }

    doc.text((i + 1).toString(), col1, rowY);
    doc.text(formatDateGerman(docInfo.date), col2, rowY);
    doc.text(docInfo.number, col3, rowY);
    doc.text(formatCurrency(docInfo.amount || 0), col4, rowY);
    doc.text(docInfo.description || "-", col5, rowY, { width: 180 });

    rowY += 20;
  }

  // Total line
  doc.moveTo(col1, rowY).lineTo(550, rowY).stroke();
  rowY += 10;

  doc.font("Helvetica-Bold");
  doc.text("GESAMT / TOTAL", col3, rowY);
  doc.text(formatCurrency(consolidatedEntry.consolidatedAmount), col4, rowY);

  doc.moveDown(2);

  // === RECONCILIATION GROUPS ===
  if (consolidatedEntry.originalReconciliationGroups.length > 0) {
    doc.fontSize(10).font("Helvetica-Bold");
    doc.text("ORIGINAL RECONCILIATION GROUPS");
    doc.moveDown(0.3);

    doc.font("Helvetica");
    for (const group of consolidatedEntry.originalReconciliationGroups) {
      doc.text(
        `• ${group.reconciledOn || "N/A"}: Reconciled ${formatDateTimeGerman(group.reconciledAt)}`
      );
    }
    doc.moveDown(1);
  }

  // === DIMENSIONS ===
  if (consolidatedEntry.dimensions && Object.keys(consolidatedEntry.dimensions).length > 0) {
    doc.fontSize(10).font("Helvetica-Bold");
    doc.text("DIMENSIONEN / DIMENSIONS");
    doc.moveDown(0.3);

    doc.font("Helvetica");
    for (const [key, value] of Object.entries(consolidatedEntry.dimensions)) {
      doc.text(`• ${key}: ${value}`);
    }
    doc.moveDown(1);
  }

  // === VERIFICATION ===
  doc.fontSize(9).font("Helvetica-Bold");
  doc.text("VERIFICATION / PRÜFUNG");
  doc.moveDown(0.3);

  doc.font("Helvetica");
  doc.text(`Generiert: ${new Date().toISOString()}`);
  doc.text(`Erstellt von: ${createdBy.name} (${createdBy.email})`);
  doc.text(`Digitale Signatur: SHA256:${generateSignature(consolidatedEntry)}`);
  doc.moveDown(1);

  // === FOOTER ===
  doc.fontSize(7).font("Helvetica");
  doc.text(
    "Dieses Dokument dient als Belegnachweis für die konsolidierte Hauptbuchbuchung. " +
      "Alle Einzeltransaktionen bleiben im System nachvollziehbar und können jederzeit " +
      "eingesehen werden. Dieses Sammelbeleg erfüllt die Anforderungen der GoBD.",
    50,
    doc.y,
    {
      align: "center",
      width: 500,
    }
  );

  doc.end();

  return new Promise((resolve) => {
    doc.on("end", () => resolve(Buffer.concat(chunks)));
  });
}

// Helper functions
function formatDateGerman(date: Date | null): string {
  if (!date) return "N/A";
  return new Intl.DateTimeFormat("de-DE", {
    day: "2-digit",
    month: "2-digit",
    year: "numeric",
  }).format(new Date(date));
}

function formatDateTimeGerman(date: Date | null): string {
  if (!date) return "N/A";
  return new Intl.DateTimeFormat("de-DE", {
    day: "2-digit",
    month: "2-digit",
    year: "numeric",
    hour: "2-digit",
    minute: "2-digit",
  }).format(new Date(date));
}

function formatCurrency(amount: number): string {
  return new Intl.NumberFormat("de-DE", {
    minimumFractionDigits: 2,
    maximumFractionDigits: 2,
  }).format(amount);
}

function generateSignature(entry: ConsolidatedEntry): string {
  // Generate SHA256 hash of consolidation data for verification
  const crypto = require("crypto");
  const data = JSON.stringify({
    id: entry.consolidationId,
    amount: entry.consolidatedAmount,
    entries: entry.originalEntryIds,
  });
  return crypto.createHash("sha256").update(data).digest("hex").substring(0, 16);
}

// packages/core/src/general_ledger/create-sammelbeleg-document.ts

interface CreateSammelbelegDocumentParams {
  consolidatedEntry: ConsolidatedEntry;
  organizationId: string;
  periodId: string;
  pdfBuffer: Buffer;
  actorId?: string;
}

export async function createSammelbelegDocument({
  consolidatedEntry,
  organizationId,
  periodId,
  pdfBuffer,
  actorId,
}: CreateSammelbelegDocumentParams): Promise<ActionResponse<documents>> {
  try {
    // 1. Upload PDF to storage (UploadThing, S3, or local storage)
    const pdfUrl = await uploadSammelbelegPDF({
      file: pdfBuffer,
      filename: `${consolidatedEntry.consolidatedBelegfeld1}.pdf`,
      organizationId,
      periodId,
    });

    // 2. Create document record for the Sammelbeleg
    const sammelbelegDocument = await prisma.documents.create({
      data: {
        id: createId(),
        org_id: organizationId,
        nr: consolidatedEntry.consolidatedBelegfeld1, // "CONS-clh5z1234..."
        object_type_id: "SAMMELBELEG", // Dedicated object type for consolidation documents
        date: consolidatedEntry.transactionDateRange.latest,
        accounting_period_id: periodId,
        modified_by_actor_id: actorId,
        custom_properties: {
          cona_sammelbeleg: {
            label: "Sammelbeleg Information",
            value: {
              type: "sammelbeleg",
              consolidation_id: consolidatedEntry.consolidationId,
              entry_count: consolidatedEntry.entryCount,
              date_range: {
                start: consolidatedEntry.transactionDateRange.earliest.toISOString(),
                end: consolidatedEntry.transactionDateRange.latest.toISOString(),
              },
              consolidated_amount: consolidatedEntry.consolidatedAmount,
              currency: consolidatedEntry.currency,
              tax_rate: consolidatedEntry.taxRate,
              original_documents: consolidatedEntry.documents.map((d) => ({
                id: d.id,
                number: d.number,
                date: d.date.toISOString(),
              })),
              original_entry_ids: consolidatedEntry.originalEntryIds,
              reconciliation_groups: consolidatedEntry.originalReconciliationGroups.map(
                (g) => g.id
              ),
            },
          },
        },
        // Additional metadata
        description: `Sammelbeleg for ${consolidatedEntry.entryCount} consolidated entries`,
      },
    });

    return {
      success: true,
      message: "Sammelbeleg document created",
      data: sammelbelegDocument,
    };
  } catch (error) {
    return {
      success: false,
      message: "Failed to create Sammelbeleg document",
      error: error instanceof Error ? error.message : "Unknown error",
    };
  }
}

// Helper function to upload PDF
async function uploadSammelbelegPDF({
  file,
  filename,
  organizationId,
  periodId,
}: {
  file: Buffer;
  filename: string;
  organizationId: string;
  periodId: string;
}): Promise<string> {
  // Implementation depends on your storage solution:
  // - UploadThing
  // - AWS S3
  // - Local file system
  // - Supabase Storage

  // Example with S3:
  const key = `organizations/${organizationId}/periods/${periodId}/sammelbeleg/${filename}`;
  await s3Client.putObject({
    Bucket: process.env.S3_BUCKET,
    Key: key,
    Body: file,
    ContentType: "application/pdf",
    Metadata: {
      organizationId,
      periodId,
      documentType: "sammelbeleg",
    },
  });

  return `https://${process.env.S3_BUCKET}.s3.amazonaws.com/${key}`;
}

// packages/core/src/general_ledger/create-sammelbeleg-document.ts

export async function createSammelbelegDocument({
  consolidatedEntry,
  organizationId,
  periodId,
  pdfBuffer,
  actorId,
}: CreateSammelbelegDocumentParams): Promise<ActionResponse<documents>> {
  try {
    // 1. Upload PDF and create Sammelbeleg document (as shown above)
    const pdfUrl = await uploadSammelbelegPDF({
      file: pdfBuffer,
      filename: `${consolidatedEntry.consolidatedBelegfeld1}.pdf`,
      organizationId,
      periodId,
    });

    const sammelbelegDoc = await prisma.documents.create({
      data: {
        id: createId(),
        org_id: organizationId,
        nr: consolidatedEntry.consolidatedBelegfeld1,
        object_type_id: "SAMMELBELEG",
        date: consolidatedEntry.transactionDateRange.latest,
        accounting_period_id: periodId,
        modified_by_actor_id: actorId,
        custom_properties: {
          cona_sammelbeleg: {
            label: "Sammelbeleg Information",
            value: {
              type: "sammelbeleg",
              consolidation_id: consolidatedEntry.consolidationId,
              entry_count: consolidatedEntry.entryCount,
              date_range: {
                start: consolidatedEntry.transactionDateRange.earliest.toISOString(),
                end: consolidatedEntry.transactionDateRange.latest.toISOString(),
              },
              consolidated_amount: consolidatedEntry.consolidatedAmount,
              currency: consolidatedEntry.currency,
              tax_rate: consolidatedEntry.taxRate,
              // Store GL entry details for traceability
              gl_entries: consolidatedEntry.originalEntryIds.map((glId) => {
                const gl = allGlEntries.find((g) => g.id === glId);
                return {
                  gl_entry_id: glId,
                  document_id: gl.document_id,
                  document_nr: gl.document?.nr,
                  amount: gl.amount,
                  transaction_date: gl.transaction_date,
                };
              }),
            },
          },
        },
        description: `Sammelbeleg for ${consolidatedEntry.entryCount} consolidated entries`,
      },
    });

    // 2. Create attachment for the PDF
    await prisma.attachments.create({
      data: {
        id: createId(),
        org_id: organizationId,
        documents_id: sammelbelegDoc.id,
        file_name: `${consolidatedEntry.consolidatedBelegfeld1}.pdf`,
        file_url: pdfUrl,
        file_type: "application/pdf",
        file_size: pdfBuffer.length,
        role: "sammelbeleg_pdf", // Special role for easy identification
        modified_by_actor_id: actorId,
      },
    });

    // 3. Update GL entries to reference the Sammelbeleg document
    // This is the SINGLE SOURCE OF TRUTH for the relationship
    await prisma.general_ledger.updateMany({
      where: {
        id: { in: consolidatedEntry.originalEntryIds },
      },
      data: {
        sammelbeleg_document_id: sammelbelegDoc.id,
        consolidation_id: consolidatedEntry.consolidationId,
        is_consolidated: true,
        consolidation_metadata: {
          sammelbeleg_nr: consolidatedEntry.consolidatedBelegfeld1,
          sammelbeleg_document_id: sammelbelegDoc.id,
          consolidated_at: new Date().toISOString(),
        },
      },
    });

    return {
      success: true,
      message: "Sammelbeleg document created",
      data: sammelbelegDoc,
    };
  } catch (error) {
    return {
      success: false,
      message: "Failed to create Sammelbeleg document",
      error: error instanceof Error ? error.message : "Unknown error",
    };
  }
}

// Get Sammelbeleg with all related original documents (via GL entries)
const sammelbeleg = await prisma.documents.findUnique({
  where: { id: sammelbelegId },
  include: {
    attachments: {
      where: { role: "sammelbeleg_pdf" },
    },
  },
});

// Get related GL entries and their documents
const relatedGlEntries = await prisma.general_ledger.findMany({
  where: {
    sammelbeleg_document_id: sammelbelegId,
  },
  include: {
    document: {
      include: {
        entity: true, // Customer/supplier
      },
    },
    debit_account: true,
    credit_account: true,
  },
});

// Extract unique original documents
const originalDocuments = [...new Set(relatedGlEntries.map((gl) => gl.document))].filter(Boolean);

// Get original document and check if any GL entries are in a Sammelbeleg
const originalDoc = await prisma.documents.findUnique({
  where: { id: originalDocId },
  include: {
    general_ledger: {
      include: {
        sammelbeleg_document: {
          select: {
            id: true,
            nr: true,
            date: true,
          },
        },
      },
    },
  },
});

// Group GL entries by Sammelbeleg
const glBySammelbeleg = originalDoc.general_ledger.reduce((acc, gl) => {
  const sammelbelegId = gl.sammelbeleg_document_id;
  if (sammelbelegId) {
    if (!acc[sammelbelegId]) {
      acc[sammelbelegId] = {
        sammelbeleg: gl.sammelbeleg_document,
        gl_entries: [],
      };
    }
    acc[sammelbelegId].gl_entries.push(gl);
  }
  return acc;
}, {});

┌────────────────────────────────────────────────────────────┐
│              documents (Sammelbeleg)                       │
│  id: "sammel-123"                                          │
│  object_type_id: "SAMMELBELEG"  ← Distinct type           │
│  nr: "CONS-clh5z1234..."                                   │
│  custom_properties: {                                      │
│    cona_sammelbeleg: {                                     │
│      gl_entries: [...],  ← Stores GL entry details        │
│      consolidation_id: "...",                              │
│      ...                                                   │
│    }                                                       │
│  }                                                         │
└──────────────────────┬─────────────────────────────────────┘
                       │
                       │ (has attachment)
                       ▼
              ┌──────────────────┐
              │   attachments    │
              │ role: "sammelbeleg_pdf" │
              │ file_url: PDF    │
              └──────────────────┘

┌───────────────────────────────────────────────────────────┐
│            general_ledger (GL Entries)                    │
│                                                           │
│  GL Entry 1:                                              │
│    id: "gl-1"                                             │
│    document_id: "inv-1"                                   │
│    sammelbeleg_document_id: "sammel-123"  ← Single source │
│    amount: 100                                            │
│    ...                                                    │
│                                                           │
│  GL Entry 2:                                              │
│    id: "gl-2"                                             │
│    document_id: "inv-2"                                   │
│    sammelbeleg_document_id: "sammel-123"  ← Single source │
│    amount: 150                                            │
│    ...                                                    │
│                                                           │
│  GL Entry 3:                                              │
│    id: "gl-3"                                             │
│    document_id: "inv-3"                                   │
│    sammelbeleg_document_id: "sammel-123"  ← Single source │
│    amount: 200                                            │
│    ...                                                    │
└─────┬──────────┬──────────┬─────────────────────────────┘
      │          │          │
      ▼          ▼          ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│documents │ │documents │ │documents │
│id: inv-1 │ │id: inv-2 │ │id: inv-3 │
│object_   │ │object_   │ │object_   │
│type: SALES│ │type: SALES│ │type: SALES│
└──────────┘ └──────────┘ └──────────┘

Key Points:
✅ GL entries are the SINGLE SOURCE OF TRUTH
✅ No document_relations table needed
✅ Query original documents via GL entries
✅ Simpler architecture, less maintenance

// Document INV-001 has two GL entries
GL Entry 1: 1000 → 4000, Tax: 19%, Project: A → Sammelbeleg-1
GL Entry 2: 1000 → 4100, Tax:  7%, Project: B → Sammelbeleg-2

// With document_relations:
document_relations:
  - Sammelbeleg-1 → INV-001  (because of GL Entry 1)
  - Sammelbeleg-2 → INV-001  (because of GL Entry 2)

// Problem: UI shows "INV-001 is in 2 Sammelbelegs?"
// Confusing! Which entries? How much from each?

// Without document_relations (query GL directly):
SELECT * FROM general_ledger WHERE document_id = 'inv-001'
// Shows exactly which GL entries → which Sammelbeleg
// Clear and precise!

// apps/webapp/app/lib/utils/export-datev.ts

export async function exportDatevCSV({
  settings,
  periodId,
  exportType = "test", // 'test' | 'period_close'
}: DatevTransformOptions) {
  const organizationId = await getOrganizationId();

  // 1. Get journal entries for the period
  const entriesResult = await getJournalEntriesByPeriod({ periodId });

  if (!entriesResult.success || !entriesResult.data) {
    throw new Error("Failed to fetch journal entries");
  }

  let entriesToExport = entriesResult.data;
  let sammelbelegPdfs: Array<{ filename: string; buffer: Buffer }> = [];

  // 2. Consolidate if enabled
  if (settings.datevSettings.aggregateJournalEntries) {
    const consolidationResult = await consolidateGLEntries({
      periodId,
      organizationId,
      actorId: await getActorId(),
      isPersistent: exportType === "period_close",
    });

    if (consolidationResult.success && consolidationResult.data) {
      const { consolidatedEntries } = consolidationResult.data;

      // Transform consolidated entries to DATEV format
      entriesToExport = transformConsolidatedEntriesToDatevFormat(consolidatedEntries, settings);

      // Generate Sammelbeleg PDFs for each consolidated entry
      const actorInfo = await getActorInfo(await getActorId());
      const orgName = await getOrganizationName(organizationId);
      const periodName = await getPeriodName(periodId);

      for (const consolidated of consolidatedEntries) {
        const pdfBuffer = await generateSammelbelegPDF({
          consolidatedEntry: consolidated,
          organizationName: orgName,
          periodName,
          createdBy: {
            name: actorInfo.name,
            email: actorInfo.email,
          },
        });

        sammelbelegPdfs.push({
          filename: `${consolidated.consolidatedBelegfeld1}.pdf`,
          buffer: pdfBuffer,
        });

        // For persistent consolidation (period close), store PDFs as documents
        if (exportType === "period_close") {
          const docResult = await createSammelbelegDocument({
            consolidatedEntry: consolidated,
            organizationId,
            periodId,
            pdfBuffer,
            actorId: await getActorId(),
          });

          // Update GL entries to reference the Sammelbeleg document
          if (docResult.success && docResult.data) {
            await prisma.general_ledger.updateMany({
              where: {
                id: { in: consolidated.originalEntryIds },
              },
              data: {
                sammelbeleg_document_id: docResult.data.id,
              },
            });
          }
        }
      }
    }
  }

  // 3. Generate DATEV CSV (existing logic)
  const datevCSV = await generateDatevCSV({
    entries: entriesToExport,
    settings,
    periodId,
    // ... other params
  });

  // 4. Return DATEV CSV and Sammelbeleg PDFs
  return {
    datevCSV,
    sammelbelegPdfs, // Array of PDF buffers with filenames
  };
}

/**
 * Transform consolidated entries to DATEV format
 * Each consolidated entry becomes ONE DATEV row with new Belegfeld 1
 */
function transformConsolidatedEntriesToDatevFormat(
  consolidatedEntries: ConsolidatedEntry[],
  settings: DATEVExportSettings
): DatevExportRow[] {
  const datevRows: DatevExportRow[] = [];

  for (const consolidated of consolidatedEntries) {
    datevRows.push({
      Umsatz: formatAmountToDatevFormat(consolidated.consolidatedAmount),
      "Soll-/Haben-Kennzeichen": consolidated.consolidatedAmount > 0 ? "S" : "H",
      "WKZ Umsatz": consolidated.currency,
      Konto: consolidated.debitAccount.account_nr,
      "Gegenkonto (ohne BU-Schlüssel)": consolidated.creditAccount.account_nr,
      "BU-Schlüssel": getMappedGLDimensionValue(
        consolidated.dimensions,
        settings.dimensionMappings,
        "BU"
      ),
      Belegdatum: formatDateTTMM(consolidated.transactionDateRange.latest), // Use latest date
      "Belegfeld 1": consolidated.consolidatedBelegfeld1, // NEW: CONS-{cuid} (e.g., "CONS-clh5z1234567890abcdef")
      Buchungstext: `Consolidated entry (${consolidated.entryCount} entries, ${consolidated.originalReconciliationGroups.length} recon groups)`,
      // ... other DATEV fields
      Festschreibung: "0",
    });
  }

  return datevRows;
}

// apps/webapp/app/lib/actions/datev/export-datev-csv.ts

import JSZip from "jszip";

export async function exportDatevCsvAction({
  settings,
  periodId,
  exportType = "test",
}: ExportDatevCsvParams): Promise<ActionResponse<{ base64: string; isZip: boolean }>> {
  await requireAuth();

  try {
    const { datevCSV, sammelbelegPdfs } = await exportDatevCSV({
      settings,
      periodId,
      exportType,
    });

    // If consolidation is enabled and we have Sammelbeleg PDFs
    if (settings.datevSettings.aggregateJournalEntries && sammelbelegPdfs.length > 0) {
      // Create ZIP file
      const zip = new JSZip();

      // Add DATEV export
      zip.file("EXTF_CONA_datev_export.csv", datevCSV, {
        binary: true,
      });

      // Add Sammelbeleg PDFs
      for (const pdf of sammelbelegPdfs) {
        zip.file(`sammelbeleg/${pdf.filename}`, pdf.buffer, {
          binary: true,
        });
      }

      // Add README explaining the Sammelbeleg documents
      const readme = generateSammelbelegReadme(sammelbelegPdfs.length);
      zip.file("README_SAMMELBELEG.txt", readme);

      // Generate ZIP
      const zipBuffer = await zip.generateAsync({
        type: "nodebuffer",
        compression: "DEFLATE",
        compressionOptions: { level: 9 },
      });

      const base64 = zipBuffer.toString("base64");

      return {
        success: true,
        message: `DATEV export with ${sammelbelegPdfs.length} Sammelbeleg documents generated`,
        data: { base64, isZip: true },
      };
    } else {
      // Single CSV file (no consolidation)
      const base64 = Buffer.from(datevCSV, "latin1").toString("base64");

      return {
        success: true,
        message: "DATEV CSV generated",
        data: { base64, isZip: false },
      };
    }
  } catch (error) {
    return {
      success: false,
      message: "Failed to generate DATEV export",
      error: error instanceof Error ? error.message : "Unknown error",
    };
  }
}

function generateSammelbelegReadme(pdfCount: number): string {
  return `
SAMMELBELEG (COLLECTIVE RECEIPT) DOCUMENTS
==========================================

This ZIP file contains ${pdfCount} Sammelbeleg PDF document(s) that serve as
supporting documentation for consolidated general ledger entries in the
DATEV export.

What is a Sammelbeleg?
----------------------
A Sammelbeleg (collective receipt) is a recognized German accounting practice
where multiple similar transactions are documented on a single supporting
document. This maintains the GoBD principle of "Belegprinzip" (document principle).

Structure:
----------
- EXTF_CONA_datev_export.csv: Main DATEV export with consolidated entries
- sammelbeleg/*.pdf: Individual Sammelbeleg PDFs (one per consolidation)

Each Sammelbeleg PDF contains:
- Summary of the consolidated entry
- Complete list of all individual transactions
- Original document references and dates
- Reconciliation information
- Digital signature for verification

GoBD Compliance:
----------------
The Sammelbeleg PDFs provide the complete audit trail required by GoBD:
- Einzelaufzeichnungspflicht: All individual transactions are documented
- Belegprinzip: Each consolidated entry has a proper source document (Beleg)
- Nachvollziehbarkeit: Full traceability from DATEV entry to original documents
- Unveränderbarkeit: PDFs are immutable and digitally signed

For period close exports, these PDFs are also stored in the document management
system and can be accessed at any time.

Generated: ${new Date().toISOString()}
`;
}

// apps/webapp/app/ui/modals/datev-export-settings-dialog.tsx

<FormField
  control={form.control}
  name="datevSettings.aggregateJournalEntries"
  render={({ field }) => (
    <FormItem className="flex flex-row items-start space-x-3 space-y-0">
      <FormControl>
        <Switch
          checked={field.value}
          onCheckedChange={field.onChange}
          // Remove disabled prop to enable toggle
        />
      </FormControl>
      <div className="space-y-1 leading-none">
        <FormLabel>Aggregate Journal Entries</FormLabel>
        <FormDescription>
          Consolidate entries with matching accounts and dimensions (across dates).
          This reduces the number of lines in the DATEV export while maintaining GoBD compliance.
          <br /><br />
          For each consolidated entry, a <strong>Sammelbeleg (Collective Receipt) PDF</strong> is
          generated containing all individual transaction details. These PDFs serve as proper
          source documents (Beleg) and are included in the export ZIP file.
          <br /><br />
          For period close exports, Sammelbeleg PDFs are also stored in your document
          management system for long-term archival.
        </FormDescription>
      </div>
    </FormItem>
  )}
/>

// apps/webapp/app/ui/cards/datev-export-main-card.tsx

const handleDownloadDatevFileBase64 = (base64: string, isZip: boolean) => {
  const link = document.createElement("a");

  if (isZip) {
    link.href = `data:application/zip;base64,${base64}`;
    const timestamp = new Date().toISOString().split("T")[0];
    const companyPart = organizationSlug ? `_${organizationSlug}` : "";
    const periodPart = accountingPeriodName
      ? `_${accountingPeriodName.replace(/[^a-zA-Z0-9]/g, "_")}`
      : "";
    link.download = `DATEV_Export${companyPart}${periodPart}_${timestamp}.zip`;
  } else {
    link.href = `data:text/csv;charset=iso-8859-1;base64,${base64}`;
    const timestamp = new Date().toISOString().split("T")[0];
    const companyPart = organizationSlug ? `_${organizationSlug}` : "";
    const periodPart = accountingPeriodName
      ? `_${accountingPeriodName.replace(/[^a-zA-Z0-9]/g, "_")}`
      : "";
    link.download = `EXTF_CONA${companyPart}${periodPart}_${timestamp}.csv`;
  }

  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
};

const handleTestFileExport = async () => {
  setIsExportingTestFile(true);
  try {
    const result = await exportDatevCsvAction({
      settings: form.getValues(),
      periodId: selectedPeriod,
      exportType: "test", // Virtual consolidation
    });
    if (!result.success || !result.data) throw new Error(result.error || result.message);
    handleDownloadDatevFileBase64(result.data.base64, result.data.isZip);

    if (result.data.isZip) {
      toast.success("DATEV export with Sammelbeleg documents downloaded");
    } else {
      toast.success("DATEV file exported successfully");
    }
  } catch (error) {
    toast.error(error instanceof Error ? error.message : "Failed to export DATEV file");
  } finally {
    setIsExportingTestFile(false);
  }
};

const handleClosePeriodExport = async () => {
  setIsExportingClosePeriod(true);
  try {
    // ... existing reconciliation logic ...

    const result = await exportDatevCsvAction({
      settings: form.getValues(),
      periodId: selectedPeriod,
      exportType: "period_close", // Persistent consolidation
    });

    if (!result.success || !result.data) {
      throw new Error(result.error || result.message);
    }

    // Only close the period after successful export
    const closeResult = await closeAccountingPeriod({
      periodId: selectedPeriod,
    });

    if (!closeResult.success || !closeResult.data) {
      throw new Error(closeResult.error || closeResult.message);
    }

    handleDownloadDatevFileBase64(result.data.base64, result.data.isZip);

    if (result.data.isZip) {
      toast.success("Period closed and exported with Sammelbeleg documents");
    } else {
      toast.success("Period closed and exported successfully");
    }
  } catch (error) {
    toast.error(error instanceof Error ? error.message : "Failed to close period and export");
  } finally {
    setIsExportingClosePeriod(false);
  }
};