basic-erp/apps/web/src/app/features/documents/document-layouts.ts

import type { GridColumn, GridLine } from '../../shared/grid/grid.types';
import type { VhLookup } from '../../shared/value-help/value-help.types';
import type { DocRecord, LinesSpec } from './document-model';
import { DOCUMENT_LINE_COLUMNS, lineColumnsFor, lineFieldsOf, newDocumentLine, recalcLine, uomEntryOf } from './line-columns';

/** Valores calculados o del socio que una fila de solo lectura puede mostrar. */
export type ComputedSource = 'docNum' | 'partnerName' | 'partnerTaxId' | 'subtotal' | 'tax' | 'total';

/**
 * Un campo de la cabecera (o del pie) del formulario. La pantalla de cada documento declara su lista
 * de campos y el formulario base los dibuja: no hay HTML por documento.
 */
export type HeaderField =
  | { type: 'text'; key: string; label: string; readonly?: boolean }
  | { type: 'date'; key: string; label: string; required?: boolean; missing?: string }
  | { type: 'number'; key: string; label: string; decimals?: number }
  | { type: 'textarea'; key: string; label: string }
  /** Lista de valores válidos (típico de un campo de usuario con valores válidos en SAP). */
  | { type: 'select'; key: string; label: string; options: readonly { value: string | number; label: string }[]; required?: boolean; missing?: string }
  /** Abre la lista de almacenes. */
  | { type: 'warehouse'; key: string; label: string; required?: boolean; missing?: string }
  /** Código del socio de negocio (cliente o proveedor) con su lista; solo editable al crear. */
  | { type: 'partner'; key: string; label: string; required?: boolean; missing?: string }
  /** Prefijo y número del folio tributario en una misma fila (`FolioPrefixString` y `FolioNumber`). */
  | { type: 'folio'; label: string; prefixKey: string; numberKey: string }
  | { type: 'computed'; label: string; source: ComputedSource };

export interface FieldColumns {
  /** Dos columnas como máximo (regla del proyecto base). */
  left: readonly HeaderField[];
  right: readonly HeaderField[];
}

/**
 * Formulario de un documento: qué campos de cabecera y de pie, qué columnas de línea y cómo se
 * guarda. El formulario base lo dibuja sin saber de qué documento se trata.
 */
export interface DocumentLayout {
  lines: LinesSpec;
  header: FieldColumns;
  /** Debajo de las líneas: comentarios y, donde los hay, descuento y totales. */
  footer: FieldColumns;
  columns: readonly GridColumn[];
  /** Cabecera de un documento nuevo (siempre lleva `DocDate`). */
  newHeader: () => DocRecord;
  /** Línea nueva; las transferencias toman los almacenes de la cabecera. */
  newLine: (header: DocRecord) => GridLine;
  /** Recalcula una línea tras un cambio (total = cantidad × precio…). */
  recalc?: (line: GridLine, changedKey: string) => GridLine;
  /** Una vez contabilizado ya no se modifica (SAP no permite cambiar entradas, salidas ni transferencias). */
  immutable?: boolean;
  /** Ajustes a la cabecera antes de crear. */
  beforeCreate?: (header: DocRecord) => DocRecord;
  requiredLine: readonly { key: string; label: string }[];
}

export const today = (): string => new Date().toISOString().slice(0, 10);

// --- catálogo de campos ---------------------------------------------------------------------

/** Catálogo de campos: cada pantalla elige cuáles lleva. */
export const FIELDS = {
  docNum: { type: 'computed', label: 'Número', source: 'docNum' },
  docDate: { type: 'date', key: 'DocDate', label: 'Fecha de contabilización', required: true, missing: 'la fecha de contabilización' },
  docDueDate: { type: 'date', key: 'DocDueDate', label: 'Fecha de vencimiento' },
  requiredDate: { type: 'date', key: 'RequriedDate', label: 'Fecha requerida', required: true, missing: 'la fecha requerida' },
  comments: { type: 'textarea', key: 'Comments', label: 'Comentarios' },
  numAtCard: { type: 'text', key: 'NumAtCard', label: 'Nº referencia' },
  folio: { type: 'folio', label: 'Folio', prefixKey: 'FolioPrefixString', numberKey: 'FolioNumber' },
  fromWarehouse: { type: 'warehouse', key: 'FromWarehouse', label: 'Almacén origen', required: true, missing: 'el almacén origen' },
  toWarehouse: { type: 'warehouse', key: 'ToWarehouse', label: 'Almacén destino', required: true, missing: 'el almacén destino' },
  requester: { type: 'text', key: 'Requester', label: 'Solicitante (usuario)' },
} as const satisfies Record<string, HeaderField>;

export const commentsOnly: FieldColumns = { left: [FIELDS.comments], right: [] };

// --- columnas de línea compartidas ----------------------------------------------------------

const [baseItemColumn, descriptionColumn, quantityColumn, warehouseColumn, priceColumn] = DOCUMENT_LINE_COLUMNS;
export { descriptionColumn, priceColumn, quantityColumn, warehouseColumn };

/** Artículo que además completa la unidad de medida de la línea (`UoMEntry`). */
export const itemColumn: GridColumn = {
  ...baseItemColumn,
  lookup: {
    ...baseItemColumn.lookup!,
    apply: (item, line) => ({ ...baseItemColumn.lookup!.apply(item, line), UoMEntry: uomEntryOf(item) ?? line['UoMEntry'] }),
  },
};

/** Lista de almacenes de la cabecera (la misma de las líneas). */
export const WAREHOUSE_LOOKUP: VhLookup = warehouseColumn.lookup!.config;

export const blankLine = (): GridLine => ({ ItemCode: '', ItemDescription: '', Quantity: 1, WarehouseCode: '' });

// --- documentos con socio de negocio (ventas y compras) -------------------------------------

/**
 * Ventas y compras: socio, referencia, fechas; líneas con precio, descuento e impuesto; pie con
 * comentarios, descuento y totales. Es el punto de partida; cada pantalla ajusta lo suyo:
 * - `left` y `right` agregan campos a la cabecera base (por ejemplo `FIELDS.folio` en las facturas);
 * - `header` la reemplaza por completo;
 * - `lineColumns` reemplaza las columnas de línea (elegidas de `LINE_COLUMNS`); lo que se envía a SAP
 *   por línea se deduce de ellas.
 */
export function marketingLayout(opts: {
  partnerLabel: string;
  taxResource: string;
  left?: readonly HeaderField[];
  right?: readonly HeaderField[];
  header?: FieldColumns;
  lineColumns?: readonly GridColumn[];
}): DocumentLayout {
  const columns = lineColumnsFor(opts.taxResource, opts.lineColumns);
  return {
    lines: { key: 'DocumentLines', fields: lineFieldsOf(columns), base: true },
    header: opts.header ?? {
      left: [
        { type: 'partner', key: 'CardCode', label: opts.partnerLabel, required: true, missing: `el ${opts.partnerLabel.toLowerCase()}` },
        { type: 'computed', label: 'Nombre', source: 'partnerName' },
        { type: 'computed', label: 'RUT', source: 'partnerTaxId' },
        FIELDS.numAtCard,
        ...(opts.left ?? []),
      ],
      right: [FIELDS.docNum, FIELDS.docDate, FIELDS.docDueDate, ...(opts.right ?? [])],
    },
    footer: {
      left: [FIELDS.comments],
      right: [
        { type: 'computed', label: 'Total antes del descuento', source: 'subtotal' },
        { type: 'number', key: 'DiscountPercent', label: 'Descuento %', decimals: 2 },
        { type: 'computed', label: 'Impuesto', source: 'tax' },
        { type: 'computed', label: 'Total del documento', source: 'total' },
      ],
    },
    columns,
    newHeader: () => ({ DocDate: today(), DocDueDate: today(), DiscountPercent: 0 }),
    newLine: newDocumentLine,
    recalc: recalcLine,
    requiredLine: [],
  };
}

// --- consultas sobre un layout --------------------------------------------------------------

const allFields = (layout: DocumentLayout): HeaderField[] => [
  ...layout.header.left,
  ...layout.header.right,
  ...layout.footer.left,
  ...layout.footer.right,
];

/** Campos de cabecera que se editan (y se envían a SAP). */
export const headerKeysOf = (layout: DocumentLayout): readonly string[] =>
  allFields(layout).flatMap((f) => {
    switch (f.type) {
      case 'computed':
        return [];
      case 'folio':
        return [f.prefixKey, f.numberKey];
      default:
        return [f.key];
    }
  });

/** Campos obligatorios de la cabecera, con el texto para el aviso ("Indique el cliente."). */
export const requiredHeaderOf = (layout: DocumentLayout): { key: string; label: string }[] =>
  allFields(layout).flatMap((f) =>
    (f.type === 'date' || f.type === 'warehouse' || f.type === 'partner' || f.type === 'select') && f.required
      ? [{ key: f.key, label: f.missing ?? f.label }]
      : [],
  );

export const hasFolio = (layout: DocumentLayout): boolean => allFields(layout).some((f) => f.type === 'folio');