@spaceinvoices/react-ui 0.4.11 → 0.4.31

package/src/components/advance-invoices/create/create-advance-invoice-form.tsx

@@ -1,22 +1,33 @@
 import { zodResolver } from "@hookform/resolvers/zod";
-import type { AdvanceInvoice, CreateAdvanceInvoiceRequest } from "@spaceinvoices/js-sdk";
+import type { AdvanceInvoice, CreateAdvanceInvoiceRequest, UpdateAdvanceInvoice } from "@spaceinvoices/js-sdk";
 import { AlertCircle, Check, FileCode2, X } from "lucide-react";
 import type { ReactNode } from "react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { Resolver } from "react-hook-form";
 import { useForm, useWatch } from "react-hook-form";
+import type { z } from "zod";
 import { Alert, AlertDescription, AlertTitle } from "@/ui/components/ui/alert";
 import { Button } from "@/ui/components/ui/button";
-import { Form } from "@/ui/components/ui/form";
+import { Form, FormRoot } from "@/ui/components/ui/form";
 import { Skeleton } from "@/ui/components/ui/skeleton";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/ui/components/ui/tooltip";
-import type { CreateAdvanceInvoiceSchema } from "@/ui/generated/schemas";
 import { createAdvanceInvoiceSchema } from "@/ui/generated/schemas";
 import { useEslogValidation } from "@/ui/hooks/use-eslog-validation";
 import { useNextDocumentNumber } from "@/ui/hooks/use-next-document-number";
 import { usePremiseSelection } from "@/ui/hooks/use-premise-selection";
 import { useTransactionTypeCheck } from "@/ui/hooks/use-transaction-type-check";
-import { buildEslogOptions, buildFinaOptions, buildFursOptions } from "@/ui/lib/fiscalization-options";
+import {
+  buildEslogOptions,
+  buildFinaOptions,
+  buildFursOptions,
+  type FiscalizationOperatorOverride,
+} from "@/ui/lib/fiscalization-options";
+import {
+  normalizePtDocumentInput,
+  type PtDocumentInputForm,
+  ptDocumentInputFormSchema,
+} from "@/ui/lib/pt-document-input";
+import { normalizeLineItemDiscountsForForm } from "@/ui/lib/schemas/shared";
 import type { ComponentTranslationProps } from "@/ui/lib/translation";
 import { createTranslation } from "@/ui/lib/translation";
 import { cn } from "@/ui/lib/utils";
@@ -29,13 +40,43 @@ import {
   DocumentSignatureField,
   DocumentTaxClauseField,
 } from "../../documents/create/document-details-section";
+import { withRequiredDocumentItemFields } from "../../documents/create/document-item-validation";
 import { DocumentItemsSection, type PriceModesMap } from "../../documents/create/document-items-section";
 import { DocumentRecipientSection } from "../../documents/create/document-recipient-section";
 import { MarkAsPaidSection } from "../../documents/create/mark-as-paid-section";
+import {
+  calculateDocumentTotal,
+  coercePaymentRowsToType,
+  createEmptyPaymentRow,
+  type DraftPaymentRow,
+  getFirstValidPaymentType,
+  serializePaymentRowsForApi,
+  validatePaymentRows,
+} from "../../documents/create/payment-rows";
+import { prepareDocumentItems } from "../../documents/create/prepare-document-submission";
+import { applyCustomCreateTemplate } from "../../documents/create/custom-create-template";
+import { financialInputsMatchInitial, resolvePreservedExpectedTotal } from "../../documents/create/preserved-expected-total";
+import { scrollToFirstInvalidField } from "../../documents/create/scroll-to-first-invalid-field";
 import { useDocumentCustomerForm } from "../../documents/create/use-document-customer-form";
 import type { DocumentTypes } from "../../documents/types";
-import { getEntityErrors, getFormFieldErrors, validateEslogForm } from "../../invoices/create/eslog-validation";
-import { useCreateAdvanceInvoice } from "../advance-invoices.hooks";
+import {
+  buildEslogFieldErrors,
+  getEntityErrors,
+  getFormFieldErrors,
+  mergeFieldErrors,
+  translateEslogValidationError,
+  validateEslogForm,
+} from "../../invoices/create/eslog-validation";
+import invoiceDe from "../../invoices/create/locales/de";
+import invoiceEs from "../../invoices/create/locales/es";
+import invoiceFr from "../../invoices/create/locales/fr";
+import invoiceHr from "../../invoices/create/locales/hr";
+import invoiceIt from "../../invoices/create/locales/it";
+import invoiceNl from "../../invoices/create/locales/nl";
+import invoicePl from "../../invoices/create/locales/pl";
+import invoicePt from "../../invoices/create/locales/pt";
+import invoiceSl from "../../invoices/create/locales/sl";
+import { useCreateAdvanceInvoice, useCreateCustomAdvanceInvoice, useUpdateAdvanceInvoice } from "../advance-invoices.hooks";
 import de from "./locales/de";
 import es from "./locales/es";
 import fr from "./locales/fr";
@@ -45,27 +86,39 @@ import nl from "./locales/nl";
 import pl from "./locales/pl";
 import pt from "./locales/pt";
 import sl from "./locales/sl";
-import { prepareAdvanceInvoiceSubmission } from "./prepare-advance-invoice-submission";
+import {
+  prepareAdvanceInvoiceSubmission,
+  prepareAdvanceInvoiceUpdateSubmission,
+} from "./prepare-advance-invoice-submission";
 
 const translations = {
-  sl,
-  de,
-  it,
-  fr,
-  es,
-  pt,
-  nl,
-  pl,
-  hr,
+  sl: { ...invoiceSl, ...sl },
+  de: { ...invoiceDe, ...de },
+  it: { ...invoiceIt, ...it },
+  fr: { ...invoiceFr, ...fr },
+  es: { ...invoiceEs, ...es },
+  pt: { ...invoicePt, ...pt },
+  nl: { ...invoiceNl, ...nl },
+  pl: { ...invoicePl, ...pl },
+  hr: { ...invoiceHr, ...hr },
 } as const;
+const FORM_ID = "create-advance-invoice-form";
+const createAdvanceInvoiceFormSchema = withRequiredDocumentItemFields(
+  createAdvanceInvoiceSchema.extend({
+    pt: ptDocumentInputFormSchema.optional(),
+  }),
+);
 
 // Form values: extend schema with local-only fields (number is for display, not sent to API)
-type CreateAdvanceInvoiceFormValues = CreateAdvanceInvoiceSchema & {
+type CreateAdvanceInvoiceFormValues = z.infer<typeof createAdvanceInvoiceFormSchema> & {
   number?: string;
 };
 
 /** Preview payload extends request with display-only fields */
-type AdvanceInvoicePreviewPayload = Partial<CreateAdvanceInvoiceRequest> & { number?: string };
+type AdvanceInvoicePreviewPayload = Partial<CreateAdvanceInvoiceRequest> & {
+  number?: string;
+  pt?: PtDocumentInputForm;
+};
 
 type CreateAdvanceInvoiceFormProps = {
   type: DocumentTypes;
@@ -77,6 +130,15 @@ type CreateAdvanceInvoiceFormProps = {
   onHeaderActionChange?: (action: ReactNode) => void;
   /** Initial values for form fields (used for document duplication) */
   initialValues?: Partial<CreateAdvanceInvoiceRequest>;
+  /** Whether draft actions should be available in the UI */
+  allowDrafts?: boolean;
+  mode?: "create" | "edit";
+  documentId?: string;
+  /** Optional app-level content rendered inside the details section. */
+  detailsExtras?: ReactNode;
+  /** Request-scoped operator override for embed fiscalization flows. */
+  operatorPrefill?: FiscalizationOperatorOverride;
+  translationLocale?: string;
 } & ComponentTranslationProps;
 
 export default function CreateAdvanceInvoiceForm({
@@ -88,6 +150,12 @@ export default function CreateAdvanceInvoiceForm({
   onAddNewTax,
   onHeaderActionChange,
   initialValues,
+  allowDrafts = true,
+  mode = "create",
+  documentId,
+  detailsExtras,
+  operatorPrefill,
+  translationLocale,
   t: translateProp,
   namespace,
   locale,
@@ -96,14 +164,19 @@ export default function CreateAdvanceInvoiceForm({
     t: translateProp,
     namespace,
     locale,
+    translationLocale,
     translations,
   });
 
   const { activeEntity } = useEntities();
+  const isEditMode = mode === "edit";
 
-  // Get default note from entity settings (use invoice defaults)
-  // Note: Advance invoices don't have payment terms - they are documents requesting payment
-  const defaultNote = (activeEntity?.settings as any)?.default_invoice_note || "";
+  // Advance invoices have their own default note setting.
+  // Note: Advance invoices don't have payment terms - they are documents requesting payment.
+  const defaultNote =
+    (activeEntity?.settings as any)?.default_advance_invoice_note ||
+    (activeEntity?.settings as any)?.default_invoice_note ||
+    "";
   const defaultFooter = (activeEntity?.settings as any)?.document_footer || "";
 
   // ============================================================================
@@ -112,11 +185,15 @@ export default function CreateAdvanceInvoiceForm({
   const furs = usePremiseSelection({ entityId, type: "furs" });
   const fina = usePremiseSelection({ entityId, type: "fina" });
   const eslog = useEslogValidation(activeEntity);
+  const eslogValidationModeRef = useRef<"submit" | "draft">("submit");
+  const eslogEntityErrorsRef = useRef(eslog.entityErrors);
+  eslogEntityErrorsRef.current = eslog.entityErrors;
   const [skipFiscalization, setSkipFiscalization] = useState(false);
 
   // UI-only state (not part of API schema)
   const [markAsPaid, setMarkAsPaid] = useState(true);
-  const [paymentTypes, setPaymentTypes] = useState<string[]>(["bank_transfer"]);
+  const [paymentRows, setPaymentRows] = useState<DraftPaymentRow[]>([createEmptyPaymentRow()]);
+  const [paymentValidationMessage, setPaymentValidationMessage] = useState<string | undefined>();
   const [isDraftPending, setIsDraftPending] = useState(false);
 
   // Price modes per item (gross vs net) - collected from component state at submit
@@ -128,27 +205,113 @@ export default function CreateAdvanceInvoiceForm({
     }, {} as PriceModesMap);
   }, [initialValues?.items]);
   const priceModesRef = useRef<PriceModesMap>(initialPriceModes);
+  const customCreateTemplate = (initialValues as any)?._custom_create_template;
+  const financialInputsMatchSource = useCallback(
+    (values: { items?: any[]; currency_code?: string; calculation_mode?: string | null }) =>
+      financialInputsMatchInitial({
+        initialItems: initialValues?.items,
+        currentItems: values.items,
+        initialCurrencyCode: initialValues?.currency_code,
+        currentCurrencyCode: values.currency_code,
+        initialCalculationMode: (initialValues as any)?.calculation_mode ?? null,
+        currentCalculationMode: values.calculation_mode ?? null,
+        initialPriceModes,
+        currentPriceModes: priceModesRef.current,
+      }),
+    [initialPriceModes, initialValues],
+  );
+  const getPreservedExpectedTotalWithTax = useCallback(
+    (values: { items?: any[]; currency_code?: string; calculation_mode?: string | null }) =>
+      resolvePreservedExpectedTotal({
+        initialExpectedTotalWithTax: (initialValues as any)?._preserved_expected_total_with_tax,
+        initialItems: initialValues?.items,
+        currentItems: values.items,
+        initialCurrencyCode: initialValues?.currency_code,
+        currentCurrencyCode: values.currency_code,
+        initialCalculationMode: (initialValues as any)?.calculation_mode ?? null,
+        currentCalculationMode: values.calculation_mode ?? null,
+        initialPriceModes,
+        currentPriceModes: priceModesRef.current,
+      }),
+    [initialPriceModes, initialValues],
+  );
+
+  const baseResolver = useMemo(
+    () => zodResolver(createAdvanceInvoiceFormSchema) as Resolver<CreateAdvanceInvoiceFormValues>,
+    [],
+  );
+  const eslogResolverStateRef = useRef({
+    activeEntity,
+    isEditMode,
+    isEnabled: eslog.isEnabled === true,
+    translate: t,
+    setEntityErrors: eslog.setEntityErrors,
+  });
+  eslogResolverStateRef.current = {
+    activeEntity,
+    isEditMode,
+    isEnabled: eslog.isEnabled === true,
+    translate: t,
+    setEntityErrors: eslog.setEntityErrors,
+  };
+  const resolver = useMemo<Resolver<CreateAdvanceInvoiceFormValues>>(
+    () => async (values, context, options) => {
+      const result = await baseResolver(values, context, options);
+      const resolverState = eslogResolverStateRef.current;
+      const shouldValidateEslog =
+        eslogValidationModeRef.current === "submit" && !resolverState.isEditMode && resolverState.isEnabled;
+
+      if (!shouldValidateEslog) {
+        eslogEntityErrorsRef.current = [];
+        resolverState.setEntityErrors([]);
+        return result;
+      }
+
+      const validationErrors = validateEslogForm(values as any, resolverState.activeEntity);
+      const entityErrors = getEntityErrors(validationErrors);
+      eslogEntityErrorsRef.current = entityErrors;
+      resolverState.setEntityErrors(entityErrors);
+
+      const fieldErrors = getFormFieldErrors(validationErrors);
+      if (fieldErrors.length === 0) {
+        return result;
+      }
+
+      return {
+        values: {},
+        errors: mergeFieldErrors(
+          result.errors,
+          buildEslogFieldErrors<CreateAdvanceInvoiceFormValues>(fieldErrors, resolverState.translate),
+        ),
+      };
+    },
+    [baseResolver],
+  );
 
   const form = useForm<CreateAdvanceInvoiceFormValues>({
-    // Cast resolver to accept extended form type (includes UI-only fields)
-    resolver: zodResolver(createAdvanceInvoiceSchema) as Resolver<CreateAdvanceInvoiceFormValues>,
+    resolver,
     defaultValues: {
-      number: "", // Will be set by useNextAdvanceInvoiceNumber
+      number: (initialValues as any)?.number ?? "",
+      calculation_mode: (initialValues as any)?.calculation_mode ?? undefined,
       date: initialValues?.date || new Date().toISOString(),
       customer_id: initialValues?.customer_id ?? undefined,
       // Cast customer to form schema type (API type may have additional fields)
       customer: (initialValues?.customer as CreateAdvanceInvoiceFormValues["customer"]) ?? undefined,
       items: initialValues?.items?.length
         ? initialValues.items.map((item: any) => ({
-            type: item.type,
+            type: item.type ?? undefined,
             name: item.name || "",
             description: item.description || "",
             ...(item.type !== "separator"
               ? {
+                  item_id: item.item_id ?? undefined,
                   quantity: item.quantity ?? 1,
-                  // Use gross_price if set, otherwise use price
                   price: item.gross_price ?? item.price,
+                  gross_price: item.gross_price ?? undefined,
+                  unit: item.unit ?? undefined,
+                  classification: item.classification ?? undefined,
                   taxes: item.taxes || [],
+                  discounts: normalizeLineItemDiscountsForForm(item.discounts),
                 }
               : {}),
           }))
@@ -163,21 +326,71 @@ export default function CreateAdvanceInvoiceForm({
           ],
       currency_code: initialValues?.currency_code || activeEntity?.currency_code || "EUR",
       reference: (initialValues as any)?.reference ?? "",
-      note: initialValues?.note ?? defaultNote,
-      tax_clause: "",
-      footer: (initialValues as any)?.footer ?? defaultFooter,
+      note: initialValues?.note ?? (isEditMode ? "" : defaultNote),
+      tax_clause: (initialValues as any)?.tax_clause ?? "",
+      footer: (initialValues as any)?.footer ?? (isEditMode ? "" : defaultFooter),
+      signature:
+        (initialValues as any)?.signature ??
+        (isEditMode ? "" : (activeEntity?.settings as any)?.default_document_signature || ""),
+      pt: ((initialValues as any)?.pt as PtDocumentInputForm | undefined) ?? undefined,
     },
   });
 
-  // Skip fiscalization is only allowed for bank transfers or unpaid invoices
-  const canSkipFiscalization = !markAsPaid || paymentTypes.every((type) => type === "bank_transfer");
+  const watchedItems = useWatch({ control: form.control, name: "items" });
+  const paymentDocumentTotal = useMemo(
+    () => calculateDocumentTotal((watchedItems as any[]) ?? [], priceModesRef.current),
+    [watchedItems],
+  );
+  const hasExplicitNonBankTransferPayment =
+    markAsPaid && paymentRows.some((row) => row.type != null && row.type !== "bank_transfer");
+  const skipPreferenceInitializedRef = useRef(false);
+  const skipPaymentCoercionPendingRef = useRef(false);
+  const previousSkipFiscalizationRef = useRef(skipFiscalization);
+  const previousMarkAsPaidRef = useRef(markAsPaid);
 
-  // Auto-disable skip when it becomes invalid (e.g., user changes payment type to cash)
   useEffect(() => {
-    if (!canSkipFiscalization && skipFiscalization) {
+    if (skipPreferenceInitializedRef.current || furs.isLoading || isEditMode) return;
+
+    skipPreferenceInitializedRef.current = true;
+    if (furs.settings?.default_skip_fiscalization === true) {
+      setSkipFiscalization(true);
+    }
+  }, [furs.isLoading, furs.settings?.default_skip_fiscalization, isEditMode]);
+
+  useEffect(() => {
+    const skipJustEnabled = skipFiscalization && !previousSkipFiscalizationRef.current;
+    const paidJustEnabled = markAsPaid && !previousMarkAsPaidRef.current;
+
+    if (skipFiscalization && markAsPaid && (skipJustEnabled || paidJustEnabled)) {
+      const nextPaymentRows = coercePaymentRowsToType(paymentRows, "bank_transfer");
+      const hasChanged = nextPaymentRows.some((row, index) => row.type !== paymentRows[index]?.type);
+
+      if (hasChanged) {
+        skipPaymentCoercionPendingRef.current = true;
+        setPaymentRows(nextPaymentRows);
+      }
+    }
+
+    previousSkipFiscalizationRef.current = skipFiscalization;
+    previousMarkAsPaidRef.current = markAsPaid;
+  }, [markAsPaid, paymentRows, skipFiscalization]);
+
+  // Auto-disable skip when the user explicitly changes payment away from bank transfer.
+  useEffect(() => {
+    if (skipPaymentCoercionPendingRef.current) return;
+
+    if (hasExplicitNonBankTransferPayment && skipFiscalization) {
       setSkipFiscalization(false);
     }
-  }, [canSkipFiscalization, skipFiscalization]);
+  }, [hasExplicitNonBankTransferPayment, skipFiscalization]);
+
+  useEffect(() => {
+    if (!skipPaymentCoercionPendingRef.current) return;
+
+    if (!markAsPaid || paymentRows.every((row) => row.type === "bank_transfer")) {
+      skipPaymentCoercionPendingRef.current = false;
+    }
+  }, [markAsPaid, paymentRows]);
 
   // FURS is "active" for this advance invoice if enabled and we have a valid selection (and not skipped)
   const isFursActive = furs.isActive && !skipFiscalization;
@@ -185,6 +398,10 @@ export default function CreateAdvanceInvoiceForm({
   // Update header action with FURS and e-SLOG toggle buttons
   useEffect(() => {
     if (!onHeaderActionChange) return;
+    if (isEditMode) {
+      onHeaderActionChange(null);
+      return;
+    }
 
     if (furs.isLoading || fina.isLoading) {
       onHeaderActionChange(null);
@@ -245,10 +462,9 @@ export default function CreateAdvanceInvoiceForm({
                     size="sm"
                     className={cn(
                       "h-8 cursor-pointer gap-2",
-                      !canSkipFiscalization && "cursor-not-allowed opacity-50",
                       !isFursChecked && "text-destructive hover:text-destructive",
                     )}
-                    onClick={() => canSkipFiscalization && setSkipFiscalization(!skipFiscalization)}
+                    onClick={() => setSkipFiscalization(!skipFiscalization)}
                   >
                     <div
                       className={cn(
@@ -264,11 +480,9 @@ export default function CreateAdvanceInvoiceForm({
                   </Button>
                 </TooltipTrigger>
                 <TooltipContent side="bottom" className="max-w-xs">
-                  {canSkipFiscalization
-                    ? isFursChecked
-                      ? t("Click to skip fiscalization for this advance invoice")
-                      : t("Click to enable fiscalization")
-                    : t("Cannot skip fiscalization for cash payments")}
+                  {isFursChecked
+                    ? t("Click to skip fiscalization for this advance invoice")
+                    : t("Click to enable fiscalization")}
                 </TooltipContent>
               </Tooltip>
             </TooltipProvider>
@@ -284,10 +498,10 @@ export default function CreateAdvanceInvoiceForm({
     furs.isEnabled,
     furs.hasPremises,
     skipFiscalization,
-    canSkipFiscalization,
     eslog.isAvailable,
     eslog.isEnabled,
     eslog.setEnabled,
+    isEditMode,
     onHeaderActionChange,
     t,
   ]);
@@ -295,6 +509,47 @@ export default function CreateAdvanceInvoiceForm({
   const formValues = useWatch({
     control: form.control,
   });
+  const watchedValidationSnapshot = useMemo(
+    () =>
+      JSON.stringify({
+        date: formValues.date,
+        currency_code: formValues.currency_code,
+        customer: formValues.customer,
+        items: formValues.items,
+      }),
+    [formValues.customer, formValues.currency_code, formValues.date, formValues.items],
+  );
+  const lastRevalidatedSnapshotRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (!form.formState.isSubmitted || form.formState.isSubmitting) {
+      return;
+    }
+
+    const hasErrors = Object.keys(form.formState.errors).length > 0 || eslog.entityErrors.length > 0;
+    if (!hasErrors) {
+      lastRevalidatedSnapshotRef.current = watchedValidationSnapshot;
+      return;
+    }
+
+    if (lastRevalidatedSnapshotRef.current === watchedValidationSnapshot) {
+      return;
+    }
+
+    lastRevalidatedSnapshotRef.current = watchedValidationSnapshot;
+    const timeoutId = window.setTimeout(() => {
+      void form.trigger();
+    }, 0);
+
+    return () => window.clearTimeout(timeoutId);
+  }, [
+    eslog.entityErrors.length,
+    form,
+    form.formState.errors,
+    form.formState.isSubmitted,
+    form.formState.isSubmitting,
+    watchedValidationSnapshot,
+  ]);
   const onChangeRef = useRef(onChange);
   onChangeRef.current = onChange;
   const prevPayloadRef = useRef("");
@@ -341,19 +596,22 @@ export default function CreateAdvanceInvoiceForm({
   const { data: nextNumberData, isLoading: isNextNumberLoading } = useNextDocumentNumber(entityId, "advance_invoice", {
     businessPremiseName: activePremiseNameForNumber,
     electronicDeviceName: activeDeviceNameForNumber,
-    enabled: !!entityId && !furs.isLoading && furs.isSelectionReady && !fina.isLoading && fina.isSelectionReady,
+    enabled:
+      !!entityId && !furs.isLoading && furs.isSelectionReady && !fina.isLoading && fina.isSelectionReady && !isEditMode,
   });
 
   // Overall loading state
-  const isFormDataLoading =
-    furs.isLoading || !furs.isSelectionReady || fina.isLoading || !fina.isSelectionReady || isNextNumberLoading;
+  const isFormDataLoading = isEditMode
+    ? false
+    : furs.isLoading || !furs.isSelectionReady || fina.isLoading || !fina.isSelectionReady || isNextNumberLoading;
 
   // Pre-fill advance invoice number from preview
   useEffect(() => {
+    if (isEditMode) return;
     if (nextNumberData?.number) {
       form.setValue("number", nextNumberData.number);
     }
-  }, [nextNumberData?.number, form]);
+  }, [nextNumberData?.number, form, isEditMode]);
 
   // Auto-populate tax_clause from entity settings when transaction type changes
   const effectiveTransactionType = transactionType ?? "domestic";
@@ -361,13 +619,14 @@ export default function CreateAdvanceInvoiceForm({
   useEffect(() => {
     if (effectiveTransactionType === prevTransactionTypeRef.current) return;
     prevTransactionTypeRef.current = effectiveTransactionType;
+    if (isEditMode) return;
 
     const taxClauseDefaults = (activeEntity?.settings as any)?.tax_clause_defaults;
     if (!taxClauseDefaults) return;
 
     const clause = taxClauseDefaults[effectiveTransactionType] ?? "";
     form.setValue("tax_clause", clause);
-  }, [effectiveTransactionType, activeEntity, form]);
+  }, [effectiveTransactionType, activeEntity, form, isEditMode]);
 
   // Customer form management
   const {
@@ -390,27 +649,41 @@ export default function CreateAdvanceInvoiceForm({
     },
     onError,
   });
+  const { mutate: createCustomAdvanceInvoice, isPending: isCreateCustomPending } = useCreateCustomAdvanceInvoice({
+    entityId,
+    onSuccess: (data) => {
+      furs.saveCombo();
+      fina.saveCombo();
+      onSuccess?.(data);
+    },
+    onError,
+  });
+  const { mutate: updateAdvanceInvoice, isPending: isUpdatePending } = useUpdateAdvanceInvoice({
+    entityId,
+    onSuccess,
+    onError,
+  });
 
   // Shared submit logic for both regular save and save as draft
   const submitAdvanceInvoice = useCallback(
     (values: CreateAdvanceInvoiceFormValues, isDraft: boolean) => {
-      // Skip e-SLOG and FURS validation for drafts
-      if (!isDraft && eslog.isEnabled) {
-        const validationErrors = validateEslogForm(values as any, activeEntity);
-
-        if (validationErrors.length > 0) {
-          const entityErrors = getEntityErrors(validationErrors);
-          const formErrors = getFormFieldErrors(validationErrors);
-          eslog.setEntityErrors(entityErrors);
-          for (const error of formErrors) {
-            form.setError(error.field as any, {
-              type: "eslog",
-              message: error.message,
-            });
-          }
-          return;
+      if (!isEditMode && !isDraft && eslog.isEnabled && eslogEntityErrorsRef.current.length > 0) {
+        return;
+      }
+
+      if (isEditMode) {
+        if (!documentId) {
+          throw new Error("Advance invoice edit mode requires a documentId");
         }
-        eslog.setEntityErrors([]);
+
+        const updatePayload = prepareAdvanceInvoiceUpdateSubmission(values, {
+          originalCustomer,
+          wasCustomerFormShown: showCustomerForm,
+          priceModes: priceModesRef.current,
+        }) as UpdateAdvanceInvoice;
+
+        updateAdvanceInvoice({ id: documentId, data: updatePayload });
+        return;
       }
 
       const fursOptions = buildFursOptions({
@@ -419,6 +692,7 @@ export default function CreateAdvanceInvoiceForm({
         skipFiscalization,
         premiseName: furs.selectedPremiseName,
         deviceName: furs.selectedDeviceName,
+        operator: operatorPrefill,
       });
 
       const finaOptions = buildFinaOptions({
@@ -426,7 +700,8 @@ export default function CreateAdvanceInvoiceForm({
         useFinaNumbering,
         premiseName: fina.selectedPremiseName,
         deviceName: fina.selectedDeviceName,
-        paymentType: paymentTypes[0],
+        paymentType: getFirstValidPaymentType(paymentRows),
+        operator: operatorPrefill,
       });
 
       const eslogOptions = buildEslogOptions({
@@ -435,33 +710,64 @@ export default function CreateAdvanceInvoiceForm({
         isEnabled: eslog.isEnabled,
       });
 
+      if (!isDraft && markAsPaid) {
+        const paymentValidation = validatePaymentRows(paymentRows, paymentDocumentTotal, "full_required");
+        const paymentMessage =
+          paymentValidation.typeError ?? paymentValidation.amountError ?? paymentValidation.totalError;
+
+        if (paymentMessage) {
+          setPaymentValidationMessage(paymentMessage);
+          return;
+        }
+      }
+
       const payload = prepareAdvanceInvoiceSubmission(values, {
         originalCustomer,
         wasCustomerFormShown: showCustomerForm,
         markAsPaid: isDraft ? false : markAsPaid,
-        paymentTypes,
+        payments: serializePaymentRowsForApi(paymentRows, paymentDocumentTotal, {
+          preserveUntouchedAmounts: true,
+        }),
         furs: fursOptions,
         fina: finaOptions,
         eslog: eslogOptions,
         priceModes: priceModesRef.current,
         isDraft,
       });
+      const preservedExpectedTotalWithTax = getPreservedExpectedTotalWithTax(values);
+      if (preservedExpectedTotalWithTax !== undefined) {
+        (payload as any).expected_total_with_tax = preservedExpectedTotalWithTax;
+      } else {
+        delete (payload as any).expected_total_with_tax;
+      }
 
-      createAdvanceInvoice(payload);
+      if (customCreateTemplate && financialInputsMatchSource(values)) {
+        delete (payload as any).expected_total_with_tax;
+        createCustomAdvanceInvoice(applyCustomCreateTemplate(payload as any, customCreateTemplate));
+      } else {
+        createAdvanceInvoice(payload);
+      }
     },
     [
-      activeEntity,
       createAdvanceInvoice,
+      createCustomAdvanceInvoice,
+      customCreateTemplate,
+      documentId,
       eslog,
       furs,
       fina,
-      form,
+      financialInputsMatchSource,
+      getPreservedExpectedTotalWithTax,
+      isEditMode,
       useFinaNumbering,
       markAsPaid,
       originalCustomer,
-      paymentTypes,
+      paymentDocumentTotal,
+      paymentRows,
       showCustomerForm,
       skipFiscalization,
+      operatorPrefill,
+      updateAdvanceInvoice,
     ],
   );
 
@@ -469,31 +775,41 @@ export default function CreateAdvanceInvoiceForm({
   const handleSaveAsDraft = useCallback(async () => {
     setIsDraftPending(true);
     try {
+      eslogValidationModeRef.current = "draft";
       const isValid = await form.trigger();
       if (isValid) {
         const values = form.getValues();
         submitAdvanceInvoice(values, true);
+      } else {
+        scrollToFirstInvalidField(FORM_ID);
       }
     } finally {
+      eslogValidationModeRef.current = "submit";
       setIsDraftPending(false);
     }
   }, [form, submitAdvanceInvoice]);
 
   useFormFooterRegistration({
     formId: "create-advance-invoice-form",
-    isPending,
+    isPending: isPending || isCreateCustomPending || isUpdatePending,
     isDirty: form.formState.isDirty || !!initialValues,
-    label: t("Save"),
-    secondaryAction: {
-      label: t("Save as Draft"),
-      onClick: handleSaveAsDraft,
-      isPending: isDraftPending,
-    },
+    label: isEditMode ? t("Update") : t("Save"),
+    secondaryAction:
+      allowDrafts && !isEditMode
+        ? {
+            label: t("Save as Draft"),
+            onClick: handleSaveAsDraft,
+            isPending: isDraftPending,
+          }
+        : undefined,
   });
 
   // Set default note, footer, and signature from entity settings (advance invoices don't have payment terms)
   useEffect(() => {
-    const entityDefaultNote = (activeEntity?.settings as any)?.default_invoice_note;
+    if (isEditMode) return;
+    const entityDefaultNote =
+      (activeEntity?.settings as any)?.default_advance_invoice_note ||
+      (activeEntity?.settings as any)?.default_invoice_note;
     if (entityDefaultNote && !form.getValues("note")) {
       form.setValue("note", entityDefaultNote);
     }
@@ -505,7 +821,7 @@ export default function CreateAdvanceInvoiceForm({
     if (entityDefaultSignature && !form.getValues("signature")) {
       form.setValue("signature", entityDefaultSignature);
     }
-  }, [activeEntity, form]);
+  }, [activeEntity, form, isEditMode]);
 
   // Auto-add tax field for tax subject entities
   useEffect(() => {
@@ -517,27 +833,29 @@ export default function CreateAdvanceInvoiceForm({
     }
   }, [activeEntity?.is_tax_subject, form]);
 
-  const buildPreviewPayload = useCallback((values: CreateAdvanceInvoiceFormValues): AdvanceInvoicePreviewPayload => {
-    const currentItems = values.items || [];
-
-    const transformedItems = currentItems.map((item: any, index: number) => {
-      const { price, ...rest } = item;
-      const isGross = priceModesRef.current[index] ?? false;
-      return isGross ? { ...rest, gross_price: price } : { ...rest, price };
-    });
-
-    return {
-      number: values.number,
-      date: values.date,
-      customer_id: values.customer_id,
-      customer: values.customer,
-      items: transformedItems,
-      currency_code: values.currency_code,
-      reference: values.reference,
-      note: values.note,
-      signature: values.signature,
-    };
-  }, []);
+  const buildPreviewPayload = useCallback(
+    (values: CreateAdvanceInvoiceFormValues): AdvanceInvoicePreviewPayload => {
+      const preservedExpectedTotalWithTax = getPreservedExpectedTotalWithTax(values);
+      return {
+        number: values.number,
+        date: values.date,
+        customer_id: values.customer_id,
+        customer: values.customer,
+        items: prepareDocumentItems(values.items, priceModesRef.current),
+        currency_code: values.currency_code,
+        reference: values.reference,
+        note: values.note,
+        tax_clause: values.tax_clause,
+        signature: values.signature,
+        footer: values.footer,
+        ...(preservedExpectedTotalWithTax !== undefined
+          ? { expected_total_with_tax: preservedExpectedTotalWithTax }
+          : {}),
+        ...(normalizePtDocumentInput(values.pt) ? { pt: normalizePtDocumentInput(values.pt) } : {}),
+      };
+    },
+    [getPreservedExpectedTotalWithTax],
+  );
 
   const emitPreviewPayload = useCallback((payload: AdvanceInvoicePreviewPayload) => {
     const callback = onChangeRef.current;
@@ -620,10 +938,10 @@ export default function CreateAdvanceInvoiceForm({
 
   return (
     <Form {...form}>
-      <form id="create-advance-invoice-form" onSubmit={form.handleSubmit(onSubmit)} className="space-y-8">
+      <FormRoot id={FORM_ID} onSubmit={form.handleSubmit(onSubmit)} className="space-y-8">
         {/* e-SLOG entity-level validation errors */}
         {eslog.entityErrors.length > 0 && (
-          <Alert variant="destructive">
+          <Alert variant="destructive" data-form-error-summary="true">
             <AlertCircle className="h-4 w-4" />
             <AlertTitle>{t("e-SLOG Validation Failed")}</AlertTitle>
             <AlertDescription>
@@ -631,7 +949,7 @@ export default function CreateAdvanceInvoiceForm({
               <ul className="list-disc space-y-1 pl-4">
                 {eslog.entityErrors.map((error) => (
                   <li key={error.field} className="text-sm">
-                    {error.message}
+                    {translateEslogValidationError(error, t)}
                   </li>
                 ))}
               </ul>
@@ -650,13 +968,15 @@ export default function CreateAdvanceInvoiceForm({
             selectedCustomerId={selectedCustomerId}
             initialCustomerName={initialCustomerName}
             t={t}
+            locale={locale}
           />
           <DocumentDetailsSection
             control={form.control}
             documentType={_type}
             t={t}
+            locale={locale}
             fursInline={
-              furs.isEnabled && furs.hasPremises
+              !isEditMode && furs.isEnabled && furs.hasPremises
                 ? {
                     premises: furs.activePremises.map((p) => ({
                       id: p.id,
@@ -675,7 +995,7 @@ export default function CreateAdvanceInvoiceForm({
                 : undefined
             }
             finaInline={
-              useFinaNumbering
+              !isEditMode && useFinaNumbering
                 ? {
                     premises: fina.activePremises.map((p: any) => ({
                       id: p.id,
@@ -694,27 +1014,44 @@ export default function CreateAdvanceInvoiceForm({
             }
           >
             {/* Mark as paid section (UI-only state, not in form schema) */}
-            <MarkAsPaidSection
-              checked={markAsPaid}
-              onCheckedChange={setMarkAsPaid}
-              paymentTypes={paymentTypes}
-              onPaymentTypesChange={setPaymentTypes}
-              t={t}
-              alwaysShowPaymentType={!!fina.isActive}
-              forced
-            />
+            {!isEditMode && (
+              <MarkAsPaidSection
+                checked={markAsPaid}
+                onCheckedChange={(checked) => {
+                  setMarkAsPaid(checked);
+                  setPaymentValidationMessage(undefined);
+                }}
+                paymentRows={paymentRows}
+                onPaymentRowsChange={(rows) => {
+                  setPaymentRows(rows);
+                  setPaymentValidationMessage(undefined);
+                }}
+                documentTotal={paymentDocumentTotal}
+                t={t}
+                alwaysShowPaymentType={!!fina.isActive}
+                forced
+                validationMessage={paymentValidationMessage}
+                requireFullPayment
+              />
+            )}
+            {detailsExtras}
           </DocumentDetailsSection>
         </div>
 
         <DocumentItemsSection
           control={form.control}
+          documentType={_type}
           watch={form.watch}
           setValue={form.setValue}
+          clearErrors={form.clearErrors}
+          trigger={form.trigger}
+          isSubmitted={form.formState.isSubmitted}
           getValues={form.getValues}
           entityId={entityId}
           currencyCode={activeEntity?.currency_code ?? undefined}
           onAddNewTax={onAddNewTax}
           t={t}
+          locale={locale}
           taxesDisabled={reverseChargeApplies}
           taxesDisabledMessage={
             reverseChargeApplies ? t("Reverse charge - tax exempt EU B2B sale") : viesWarning ? viesWarning : undefined
@@ -775,7 +1112,7 @@ export default function CreateAdvanceInvoiceForm({
             customer: formValues.customer as any,
           }}
         />
-      </form>
+      </FormRoot>
     </Form>
   );
 }