// ─── Finanzas · Factura (fuente: expediente | standalone) ─────────────────
// FUSIÓN del corazón de P8: antes existían DOS componentes casi idénticos —
// FacturaScreen (screens/docs/factura.jsx, P7 — factura ligada a un
// expediente, guarda con saveDocOnExp) y FacturaFinScreen (screens-finanzas-
// nuevo.jsx — factura standalone, guarda con MicosStore.create/update
// directo sobre la colección `facturas`) — mismo layout completo (DocumentShell
// + AFIP + DocMetaStrip + Emisor/Cliente + ItemsTable+Totals + Observaciones),
// mismo patrón useDocEdit/buildDocActions, y AMBAS terminan escribiendo la
// MISMA tabla `facturas` (una factura de expediente es, en la DB, una fila de
// `facturas` con expediente_id seteado — ver dominio/expediente-docs.js
// saveFacturaOnExp). Se fusionan en UN componente parametrizado por fuente
// (`fuente = expediente si viene la prop expediente, standalone si no`); la
// bifurcación que antes vivía en core/app.jsx (finanzas-doc-detail kind
// 'factura': elegía FacturaFinScreen o FacturaScreen mirando si la factura
// tenía expedienteId) ahora es un solo destino con props.
//
// Diferencias reales entre fuentes que SÍ se preservan (no es la misma UI a
// pesar de compartir esqueleto):
//   - Resolución del documento: expediente resuelve por índice sobre
//     exp.facturas (1:N); standalone resuelve por id sobre window.FACTURAS.
//   - Persistencia: expediente usa saveDocOnExp/saveFacturaOnExp (avanza el
//     pipeline del expediente); standalone usa MicosStore.create/update
//     directo (sin pipeline).
//   - Cliente: expediente lo fija al paciente/entidad del expediente (sin
//     picker — el lápiz de "cambiar cliente" ya era un no-op en el original);
//     standalone lo elige con PartySelectorModal (snapshot guardado en el
//     propio documento) y muestra "Consumidor Final" por default.
//   - Meta strip: expediente tiene Período desde/hasta (facturación médica
//     por período); standalone tiene Estado/Moneda en su lugar (no hay
//     concepto de período fuera de un expediente).
//   - Borrado: expediente delega en `onDelete` (lo dispara app.jsx, modal
//     central); standalone lo maneja con su propio ConfirmDeleteModal.
//   - MedicalContextCard (info de paciente/médico) solo tiene sentido con
//     expediente.
// FIX addenda arquitecto (hallazgo P7 #3): `exp.particular.nombre` sin guarda
// crasheaba con F5 en esta ruta si no había expediente en memoria (bifurcación
// de rutas al fusionar) — guardado con `exp?.particular?.nombre`.
// Expone a window: FacturaScreen. Consume window.resolveDocExp (compartido.jsx
// de screens/docs/), DocumentShell/DocCard/PartyBlock/Totals/
// MedicalContextCard/ObservacionesCard/buildEmisorFields/buildClienteFields
// (ui/doc-kit-shell.jsx), buildClienteFieldsCompacto (screens/finanzas/
// compartido.jsx), DocMetaStrip (ui/doc-kit-meta.jsx), ItemsTable (ui/doc-kit-
// items.jsx), useDocEdit/buildDocActions/ConfirmDeleteModal (ui/doc-kit-
// edit.jsx), window.PartySelectorModal (ui/party-selector.jsx),
// emptyFactura/saveDocOnExp (dominio/expediente-docs.js), MicosNextSeqId
// (dominio/secuencias.js), MicosItemsMath (doc-itemmath.js), MicosStore
// (core/store.js), MicosDocFacturaA/MicosDocFacturaB/openPrintDoc (doc-
// factura.js/screens-print.jsx).
//
// EXCEPCIÓN AL TECHO DURO DE 400 LÍNEAS (regla de la compuerta, P7 §3 — mismo
// criterio ya usado en doc-kit-edit.jsx y screens/docs/remito.jsx): fusiona 2
// pantallas completas (expediente + standalone) en UN solo tema cohesivo
// ("Factura, las dos fuentes") — partirlo de nuevo en 2 archivos reintroduce
// exactamente la duplicación que esta fusión vino a eliminar. Cada rama
// (esStandalone / !esStandalone) queda nombrada y documentada inline, no hay
// bloques anónimos.

// P5: _facNextNum se fusionó en window.MicosNextSeqId (dominio/secuencias.js).
function resolverFactura(id) { return (window.FACTURAS || []).find((f) => f.id === id) || null; }
function makeBlankFactura() {
  const hoy = MicosTodayISO();
  const numero = MicosNextSeqId(window.FACTURAS || [], 'numero', '', 8);
  return {
    id: 'fac-' + Date.now(),
    publicId: 'FAC-' + numero,
    expedienteId: null, entidadId: null,
    tipoFactura: 'A', puntoVenta: '0012', numero,
    fechaEmision: hoy, fechaVencPago: hoy, condicionVenta: 'Cuenta corriente',
    cae: '', caeFechaVenc: '',
    cliente: null, estado: 'PENDIENTE', observaciones: '', importeLetras: '',
    items: [], total: 0,
  };
}

function FacturaScreen({
  // Fuente 'expediente'
  expediente, facturaIndex,
  // Fuente 'standalone' (sin expediente)
  facturaId, isCreate = false, onSaved,
  // Comunes
  onBack, backLabel, onDelete,
}) {
  const esStandalone = !expediente;
  const co = COMPANY_CONFIG;
  const M = MicosItemsMath;

  // Resolución del documento — SIEMPRE se calculan ambas ramas (nunca se
  // saltea un hook entre renders: si el caller cambiara de fuente sin
  // desmontar el componente, useDocEdit tiene que seguir llamándose en el
  // mismo orden).
  const exp = expediente ? resolveDocExp(expediente) : null;
  const facturasExp = exp ? (exp.facturas || []) : [];
  const idx = facturaIndex == null ? 0 : facturaIndex;
  const existingExp = exp ? (facturasExp[idx] || null) : null;

  const standaloneBlank = React.useMemo(
    () => (esStandalone && isCreate ? makeBlankFactura() : null),
    [esStandalone, isCreate]
  );
  const standaloneFac = esStandalone ? (isCreate ? standaloneBlank : resolverFactura(facturaId)) : null;

  const isCreateEff = esStandalone ? isCreate : !existingExp;
  const original = React.useMemo(() => {
    if (esStandalone) return standaloneFac;
    return existingExp || emptyFactura(exp, facturasExp.length === 0);
  }, [esStandalone, standaloneFac, existingExp]);

  const [toast, setToast] = React.useState(null);
  const [confirmDel, setConfirmDel] = React.useState(false);
  const [clientePicker, setClientePicker] = React.useState(false);

  const { editing, draft, setDraft, enterEdit, discardEdit, saveEdit, patch } = useDocEdit(() => ({
    tipoFactura: original.tipoFactura || 'A',
    puntoVenta: original.puntoVenta,
    numero: original.numero,
    fechaEmision: original.fechaEmision,
    periodoDesde: original.periodoDesde,
    periodoHasta: original.periodoHasta,
    fechaVencPago: original.fechaVencPago || original.fechaEmision,
    condicionVenta: original.condicionVenta,
    cae: original.cae || '',
    caeFechaVenc: original.caeFechaVenc || '',
    estado: original.estado || 'PENDIENTE',
    observaciones: original.observaciones || '',
    importeLetras: original.importeLetras || '',
    cliente: original.cliente || null,
    items: (original.items || []).map((it) => M.migrate(it)),
  }), {
    startEditing: isCreateEff,
    onCancel: () => { if (isCreateEff) onBack && onBack(); },
    onSave: (d) => {
      if (esStandalone) {
        // Sin ítems reales (factura migrada sin factura_item): no recalcular el
        // total en $0 — preservar el total de cabecera ya persistido (real,
        // viene de la DB). Solo recalcular desde los ítems cuando hay ítems.
        const hasItemsSave = (d.items || []).length > 0;
        const total = hasItemsSave
          ? Math.round(M.summary(d.items).total * 100) / 100
          : (Number(original.total) || 0);
        const upd = {
          tipoFactura: d.tipoFactura, puntoVenta: d.puntoVenta, numero: d.numero,
          publicId: 'FAC-' + d.numero,
          fechaEmision: d.fechaEmision, fechaVencPago: d.fechaVencPago,
          cae: d.cae, caeFechaVenc: d.caeFechaVenc, estado: d.estado,
          observaciones: d.observaciones || '',
          cliente: d.cliente || null,
          entidadId: (d.cliente && d.cliente.id) || original.entidadId || null,
          items: (d.items || []).map((it) => ({ ...it })), total,
        };
        if (isCreateEff) {
          MicosStore.create('facturas', { ...original, ...upd, __nuevo: true });
          onSaved && onSaved(original.id);
        } else {
          if (window.MicosStore) MicosStore.update('facturas', original.id, upd);
          Object.assign(original, upd);
          setToast(`Factura ${upd.publicId} guardada`);
          setTimeout(() => setToast(null), 3600);
        }
        return;
      }
      // Ítems con `total` de línea (subtotal = base+IVA−bonif) + `total` de cabecera (summary
      // con IVA). Antes el docObj (rama expediente) no mandaba `total` — facturas.total quedaba
      // NULL — y los ítems heredados del remito venían sin `total` (migrate lo dropea) —
      // factura_item.total NULL. Invariantes flujo 2/3: sum(factura_item.total) == facturas.total,
      // y v_facturas_stats deriva PENDIENTE/PARCIAL/COBRADO de facturas.total (con NULL caía
      // siempre a COBRADO). Mismo criterio que presupuesto.jsx / orden-compra.jsx.
      const itemsFac = (d.items || []).map((it) => ({ ...it, total: M._round(M.normalize(it).subtotal) }));
      const docObj = {
        ...original,
        tipoFactura: d.tipoFactura,
        puntoVenta: d.puntoVenta,
        fechaEmision: d.fechaEmision,
        periodoDesde: d.periodoDesde,
        periodoHasta: d.periodoHasta,
        fechaVencPago: d.fechaVencPago,
        condicionVenta: d.condicionVenta,
        observaciones: d.observaciones || '',
        importeLetras: d.importeLetras || '',
        items: itemsFac,
        total: M.summary(itemsFac).total,
      };
      saveDocOnExp(exp, 'factura', docObj, null, idx);
      const num = `${docObj.tipoFactura}-${String(docObj.puntoVenta).padStart(4, '0')}-${docObj.numero}`;
      setToast(`Factura FAC-${num} ${isCreateEff ? 'creada' : 'guardada'}`);
      setTimeout(() => setToast(null), 3600);
    },
  });

  if (esStandalone && !original) {
    return (
      <div className="space-y-6 pt-2">
        <button onClick={onBack} className="flex items-center gap-2 text-[11px] font-bold uppercase tracking-[0.12em] cursor-pointer" style={{ color: 'var(--muted-foreground)' }}><IconArrowLeft size={13} />{backLabel || 'Volver a Finanzas'}</button>
        <p className="text-[14px] font-semibold" style={{ color: 'var(--muted-foreground)' }}>No se encontró la factura.</p>
      </div>
    );
  }

  const f = editing && draft ? draft : original;
  const patchItem = (i, field, value) => setDraft((d) => {
    const items = d.items.map((it, k) => {
      if (k !== i) return it;
      const next = { ...it, [field]: value };
      const c = Number(next.cantidad) || 0, u = Number(next.unitario) || 0, b = Number(next.bonifPct) || 0;
      next.total = c * u * (1 - b / 100);
      return next;
    });
    return { ...d, items };
  });
  const addItem = () => setDraft((d) => ({ ...d, items: [...d.items, M.blank()] }));
  const removeItem = (i) => setDraft((d) => ({ ...d, items: d.items.filter((_, k) => k !== i) }));

  const s = M.summary(f.items || []);
  const isExento = (f.items || []).every((it) => !Number(it.ivaPct));
  // Standalone sin ítems migrados: mostrar el total de cabecera con aviso
  // explícito en vez de una tabla vacía + "$0,00" (mismo criterio que Compras).
  const hasItems = (f.items || []).length > 0;
  const totalMostrar = (esStandalone && !hasItems) ? (Number(f.total) || s.total) : s.total;
  const estOptions = Object.entries(COBRO_ESTADOS || {}).map(([v, c]) => ({ value: v, label: c.label }));
  const estLabel = (COBRO_ESTADOS || {})[f.estado];

  const onPrint = () => {
    if (esStandalone) {
      const live = resolverFactura(original.id) || original;
      const mod = (live.tipoFactura === 'A') ? MicosDocFacturaA : MicosDocFacturaB;
      if (!mod || !window.openPrintDoc) return;
      const fakeExp = { entidad: live.cliente || {}, publicId: '' };
      openPrintDoc(mod.fromExpediente(fakeExp, co, live), {
        mod, title: `Factura ${live.tipoFactura}-${live.puntoVenta}-${live.numero}`,
        subtitle: (live.cliente && live.cliente.razonSocial) || '',
      });
      return;
    }
    const fresh = resolveDocExp(expediente);
    const doc = (fresh.facturas && fresh.facturas[idx]) || original;
    const mod = (doc.tipoFactura === 'A') ? MicosDocFacturaA : MicosDocFacturaB;
    const data = mod.fromExpediente(fresh, co, doc);
    openPrintDoc(data, {
      mod,
      title: `Factura ${doc.tipoFactura}-${String(doc.puntoVenta).padStart(4, '0')}-${doc.numero}`,
      subtitle: `${fresh.publicId}${fresh.entidad?.razonSocial ? ' · ' + fresh.entidad.razonSocial : ''}`,
    });
  };
  // Puente ERP→CRM (carril B-erp): "Enviar por mail" con esta factura adjunta.
  // `doc` = código A-0001-123 (= _crmCodigoFactura del CRM) para el expediente;
  // standalone usa su publicId. Standalone no vincula expediente (sin `exp`), así
  // que el CRM no auto-adjunta el PDF — el botón igual sirve para redactarle al
  // cliente. Datos SIEMPRE del `original` (persistido), no del draft.
  const facCodigo = esStandalone
    ? (original.publicId || `FAC-${original.numero}`)
    : `${original.tipoFactura}-${String(original.puntoVenta).padStart(4, '0')}-${original.numero}`;
  const onEmail = window.buildDocEmailAction && window.buildDocEmailAction({
    tipo: 'Factura',
    docId: facCodigo,
    expPublicId: esStandalone ? '' : exp.publicId,
    fields: esStandalone ? buildClienteFieldsCompacto(original.cliente) : buildClienteFields(exp),
  });
  const actions = buildDocActions({
    editing, enterEdit, discardEdit, saveEdit, onPrint, onEmail,
    onDelete: esStandalone
      ? ((!isCreateEff && editing) ? () => setConfirmDel(true) : undefined)
      : (editing && onDelete ? onDelete : undefined),
  });

  const condVentaOptions = ['Contado', 'Cuenta corriente', 'Cheque', 'Transferencia'];
  // P17a (recorrido §10): Micos solo emite A (B2B) y B (B2C) — se saca C del
  // selector (relevado contra la DB real: 0 facturas tipo C existentes hoy,
  // el CHECK de schema seguía permitiéndolo pero nunca se usó — restringir acá
  // no pisa ningún dato existente).
  const tipoOptions = ['A', 'B'];
  const fullNumber = `${f.tipoFactura}-${String(f.puntoVenta).padStart(4, '0')}-${original.numero}`;

  // Meta strip: los campos comunes + los que difieren por fuente (período
  // desde/hasta solo tiene sentido dentro de un expediente; estado/moneda solo
  // como registro standalone, ver header).
  // P17a (recorrido §10): Punto venta y Número son fiscales/AFIP — SIEMPRE
  // bloqueados, en las DOS fuentes (antes standalone los dejaba editar, única
  // asimetría real: el número/punto de venta lo genera AFIP, no lo escribimos
  // nosotros, sin importar si la factura está o no ligada a un expediente).
  const metaItems = [
    ...(esStandalone ? [{ label: 'Comprobante', value: 'Factura' }] : []),
    { label: 'Tipo', value: editing ? draft.tipoFactura : original.tipoFactura, mono: true, accent: true, editable: editing, inputType: 'select', options: tipoOptions, onChange: (v) => patch('tipoFactura', v) },
    {
      label: 'Punto venta',
      // Standalone: puntoVenta ya llega/se guarda como string (a veces sin
      // padding si viene de la DB real). Expediente: numérico, se pad-ea a 4.
      value: esStandalone ? original.puntoVenta : String(original.puntoVenta).padStart(4, '0'),
      mono: true,
    },
    { label: 'Número', value: original.numero, mono: true, accent: true },
    { label: 'Emisión', value: editing ? draft.fechaEmision : formatDate(original.fechaEmision), mono: true, editable: editing, inputType: 'date', onChange: (v) => patch('fechaEmision', v) },
  ];
  if (esStandalone) {
    metaItems.push(
      { label: 'Vencimiento', value: editing ? draft.fechaVencPago : formatDate(original.fechaVencPago), mono: true, editable: editing, inputType: 'date', onChange: (v) => patch('fechaVencPago', v) },
      { label: 'Estado', value: editing ? draft.estado : (estLabel ? estLabel.label : f.estado), editable: editing, inputType: 'select', options: estOptions.map((o) => o.value), onChange: (v) => patch('estado', v) },
      { label: 'Moneda', value: 'Pesos argentinos' },
    );
  } else {
    metaItems.push(
      { label: 'Período desde', value: editing ? draft.periodoDesde : formatDate(original.periodoDesde), mono: true, editable: editing, inputType: 'date', placeholder: 'Período desde', onChange: (v) => patch('periodoDesde', v) },
      { label: 'Período hasta', value: editing ? draft.periodoHasta : formatDate(original.periodoHasta), mono: true, editable: editing, inputType: 'date', placeholder: 'Período hasta', onChange: (v) => patch('periodoHasta', v) },
      { label: 'Vto. pago', value: editing ? draft.fechaVencPago : formatDate(original.fechaVencPago), mono: true, editable: editing, inputType: 'date', onChange: (v) => patch('fechaVencPago', v) },
      { label: 'Cond. venta', value: editing ? draft.condicionVenta : original.condicionVenta, editable: editing, inputType: 'select', options: condVentaOptions, onChange: (v) => patch('condicionVenta', v) },
    );
  }

  // Cliente: expediente lo fija al directorio del expediente (sin picker,
  // guarda `exp?.particular?.nombre` — FIX addenda P8, F5 sin expediente en
  // memoria); standalone lo elige (snapshot propio, PartySelectorModal).
  const clienteNombre = esStandalone
    ? ((f.cliente && f.cliente.razonSocial) || (editing ? '— elegí uno —' : 'Consumidor Final'))
    : (exp.entidad?.razonSocial || (exp.particular?.nombre ? `${exp.particular.nombre} ${exp.particular.apellido || ''}`.trim() : '—'));
  const clienteSub = esStandalone
    ? ((f.cliente && f.cliente.condicionIva) || 'Consumidor Final')
    : (exp.entidad?.condicionIva || 'Consumidor Final');
  const clienteFields = esStandalone ? buildClienteFieldsCompacto(f.cliente) : buildClienteFields(exp);

  const subtitle = esStandalone ? (
    <React.Fragment>
      <span className="font-bold" style={{ color: 'var(--foreground)' }}>{clienteNombre}</span>
      <span className="mx-1.5 opacity-50">·</span>
      <span style={{ color: 'var(--muted-foreground)' }}>Emitida el {formatDateLong(f.fechaEmision)}</span>
    </React.Fragment>
  ) : undefined;

  return (
    <DocumentShell
      onBack={onBack}
      backLabel={backLabel || (esStandalone ? 'Volver a Finanzas' : 'Volver al expediente')}
      eyebrow={`Factura ${editing ? draft.tipoFactura : original.tipoFactura}`}
      statusLabel={esStandalone ? undefined : (editing ? 'Editando' : 'Emitida')}
      statusPill={esStandalone ? undefined : 'pill-factura'}
      bigId={esStandalone ? (f.publicId || `FAC-${f.numero}`) : `FAC-${fullNumber}`}
      expedienteId={esStandalone ? undefined : exp.publicId}
      fechaEmision={f.fechaEmision}
      subtitle={subtitle}
      editing={editing}
      isCreate={isCreateEff}
      toast={toast}
      actions={actions}
    >
      {!esStandalone && <MedicalContextCard exp={exp} />}

      {/* AFIP / CAE info */}
      <DocCard editing={esStandalone ? editing : undefined}>
        <p className="text-[11px] font-bold uppercase tracking-[0.2em] mb-6" style={{ color: 'var(--accent)' }}>
          Información AFIP
        </p>
        <div className="grid grid-cols-2 sm:grid-cols-3 gap-x-8 gap-y-6">
          {esStandalone && (
            <div className="space-y-2">
              <p className="text-[10.5px] font-bold uppercase tracking-[0.14em]" style={{ color: 'var(--muted-foreground)' }}>
                Tipo
              </p>
              <p className="text-[17px] font-extrabold leading-none tracking-tight" style={{ color: 'var(--accent)' }}>
                Factura {editing ? draft.tipoFactura : original.tipoFactura}
              </p>
            </div>
          )}
          <div className="space-y-2">
            <p className="text-[10.5px] font-bold uppercase tracking-[0.14em]" style={{ color: 'var(--muted-foreground)' }}>
              CAE
            </p>
            {/* P17a (recorrido §10): CAE es fiscal/AFIP — SIEMPRE bloqueado, en
                las DOS fuentes (antes el modo standalone lo dejaba editar). */}
            <p className="text-[17px] font-mono font-extrabold leading-none tracking-tight tabular-nums"
              style={{ color: original.cae ? 'var(--foreground)' : 'color-mix(in oklab, var(--muted-foreground) 60%, transparent)' }}>
              {original.cae || '— pendiente —'}
            </p>
          </div>
          <div className="space-y-2">
            <p className="text-[10.5px] font-bold uppercase tracking-[0.14em]" style={{ color: 'var(--muted-foreground)' }}>
              Vto. CAE
            </p>
            <p className="text-[17px] font-mono font-extrabold leading-none tracking-tight tabular-nums"
              style={{ color: original.caeFechaVenc ? 'var(--foreground)' : 'color-mix(in oklab, var(--muted-foreground) 60%, transparent)' }}>
              {original.caeFechaVenc ? formatDate(original.caeFechaVenc) : '—'}
            </p>
          </div>
          {!esStandalone && (
            <div className="space-y-2">
              <p className="text-[10.5px] font-bold uppercase tracking-[0.14em]" style={{ color: 'var(--muted-foreground)' }}>
                Estado AFIP
              </p>
              <p className="text-[17px] font-extrabold leading-none tracking-tight"
                style={{ color: original.cae ? 'var(--accent)' : 'var(--warning)' }}>
                {original.cae ? 'Aprobada' : 'Pendiente'}
              </p>
            </div>
          )}
        </div>
      </DocCard>

      <DocMetaStrip editing={editing} items={metaItems} />

      {/* Emisor + Cliente */}
      <DocCard className="relative">
        <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
          <PartyBlock
            eyebrow="Emisor"
            name={co.nombre}
            sub={co.situacionIva}
            fields={buildEmisorFields(co)}
          />
          <PartyBlock
            eyebrow="Cliente"
            name={clienteNombre}
            sub={clienteSub}
            fields={clienteFields}
          />
        </div>
        {/* Fuente expediente: el cliente lo fija el expediente (sin picker, ver el header de
            este archivo) — mismo criterio que "Estado AFIP" más arriba, condicionado a
            `!esStandalone`. Antes el ícono se mostraba SIEMPRE con `editing`, aunque en la rama
            de expediente no tuviera ningún efecto (hallazgo BAJA, AUDITORIA-ui-decorativa). */}
        {editing && esStandalone && (
          <button onClick={() => setClientePicker(true)} title="Cambiar cliente" className="party-edit-btn absolute" style={{ top: 16, right: 16 }} type="button">
            <IconPencil size={13} />
          </button>
        )}
      </DocCard>

      <DocCard editing={editing}>
        {esStandalone && !editing && !hasItems ? (
          <div className="rounded-xl px-5 py-7 text-center" style={{
            border: '1px dashed color-mix(in oklab, var(--border) 70%, transparent)',
            background: 'color-mix(in oklab, var(--surface) 40%, transparent)',
          }}>
            <p className="text-[13px] font-bold" style={{ color: 'var(--foreground)' }}>
              Sin detalle de ítems migrado
            </p>
            <p className="text-[12px] mt-1.5 max-w-md mx-auto" style={{ color: 'var(--muted-foreground)' }}>
              Esta factura no tiene ítems línea a línea cargados en el sistema. El total es el de cabecera del comprobante.
            </p>
            <p className="text-[22px] font-extrabold tabular-nums mt-4" style={{ color: 'var(--accent)' }}>
              {formatMoney(totalMostrar)}
            </p>
          </div>
        ) : (
          <React.Fragment>
            <ItemsTable
              items={f.items}
              showGanancia={!esStandalone}
              showBonif
              showIva
              editing={editing}
              onItemChange={patchItem}
              onItemRemove={removeItem}
              onAdd={addItem}
            />
            <Totals
              subtotal={s.totalBase}
              bonificaciones={s.bonifTotal}
              ivaLines={s.ivaLines}
              total={totalMostrar}
              hideIva={esStandalone ? isExento : undefined}
              importeLetras={esStandalone ? original.importeLetras : (editing ? draft.importeLetras : original.importeLetras)}
            />
          </React.Fragment>
        )}
      </DocCard>

      <ObservacionesCard editing={editing} value={editing ? draft.observaciones : original.observaciones} onChange={(v) => patch('observaciones', v)} />

      {esStandalone && clientePicker && window.PartySelectorModal && (
        <window.PartySelectorModal
          type="entidad"
          open={true}
          onClose={() => setClientePicker(false)}
          onPick={(obj) => {
            if (obj) setDraft((d) => ({ ...d, cliente: {
              id: obj.id,
              razonSocial: obj.razonSocial || obj.nombre || '',
              condicionIva: obj.condicionIva || 'Responsable Inscripto',
              cuit: obj.cuit || '',
              domicilio: obj.domicilio || '',
              localidad: obj.localidad || '',
              condicionVenta: obj.condicionVenta || 'Cuenta corriente',
            } }));
            setClientePicker(false);
          }}
        />
      )}
      {esStandalone && confirmDel && window.ConfirmDeleteModal && (
        <window.ConfirmDeleteModal
          title="¿Eliminar factura?"
          itemName={original.publicId}
          description="Se va a borrar esta factura de Finanzas. Esta acción no se puede deshacer."
          confirmLabel="Sí, eliminar"
          onCancel={() => setConfirmDel(false)}
          onConfirm={() => { if (window.MicosStore) MicosStore.remove('facturas', original.id); setConfirmDel(false); onBack(); }}
        />
      )}
    </DocumentShell>
  );
}

Object.assign(window, { FacturaScreen });