/**
 * Qué cambió de verdad al editar un gasto.
 *
 * La pantalla manda la cabecera completa y todos los ítems en cada edición. Si
 * bastara con que un campo viniera para tratarla como financiera, abrir y guardar
 * un gasto pagado sin tocar nada rehacía la cuenta por pagar, pedía que no tuviera
 * pagos y regeneraba el egreso de Tesorería. Acá se comparan valores: lo que no
 * viene en el DTO no cambió, y lo que viene se compara normalizado (TRANSFERENCIA
 * es CONTADO, una moneda NULL es guaraníes, la cotización con 6 decimales).
 */
import { UpdateGastoDto } from './dto/update-gasto.dto';

export type FormaPagoGasto = 'CONTADO' | 'CREDITO' | 'ANTICIPO';

type Numero = number | string | { toString(): string } | null | undefined;

export interface ItemComparable {
  producto_id?: string | null;
  requisicion_det_id?: string | null;
  tipo_gasto_id?: string | null;
  descripcion?: string | null;
  cantidad?: Numero;
  precio_unitario?: Numero;
  porcentaje_iva?: Numero;
}

export interface GastoComparable {
  proveedor_id?: string | null;
  forma_pago?: string | null;
  requisicion_id?: string | null;
  moneda_id?: string | null;
  cotizacion?: Numero;
  cuenta_tesoreria_id?: string | null;
  medio_pago_id?: string | null;
  total?: Numero;
  gasto_det?: ItemComparable[];
}

/** TRANSFERENCIA (forma vieja) y vacío son CONTADO. */
export function normalizarFormaPago(f?: string | null): FormaPagoGasto {
  const v = String(f ?? '')
    .trim()
    .toUpperCase();
  if (v === 'CREDITO' || v === 'ANTICIPO') return v;
  return 'CONTADO';
}

const num = (v: Numero, decimales: number): number => {
  const n = Number(v === null || v === undefined ? 0 : String(v));
  const f = Math.pow(10, decimales);
  return Number.isFinite(n) ? Math.round((n + Number.EPSILON) * f) / f : 0;
};

const id = (v?: string | null): string | null => (v ? String(v) : null);

/** El campo viene en el DTO (null cuenta: es "borrar"; undefined no). */
const viene = (obj: object, campo: string) =>
  Object.prototype.hasOwnProperty.call(obj, campo) && (obj as Record<string, unknown>)[campo] !== undefined;

/** Un gasto viejo sin moneda es de guaraníes. */
const monedaNormalizada = (monedaId: string | null | undefined, monedaPygId: string | null) =>
  id(monedaId) ?? monedaPygId;

function cambiaMoneda(existente: GastoComparable, cab: Record<string, any>, monedaPygId: string | null): boolean {
  if (!viene(cab, 'moneda_id')) return false;
  return monedaNormalizada(cab.moneda_id, monedaPygId) !== monedaNormalizada(existente.moneda_id, monedaPygId);
}

function cambiaCotizacion(existente: GastoComparable, cab: Record<string, any>, monedaPygId: string | null): boolean {
  if (!viene(cab, 'cotizacion') || cab.cotizacion === null) return false;
  // En guaraníes la cotización es siempre 1: lo que venga no cambia nada.
  const monedaFinal = viene(cab, 'moneda_id') ? cab.moneda_id : existente.moneda_id;
  if (monedaPygId && monedaNormalizada(monedaFinal, monedaPygId) === monedaPygId) return false;
  return num(cab.cotizacion, 6) !== num(existente.cotizacion ?? 1, 6);
}

const textoItem = (v?: string | null) => String(v ?? '').trim();

/** Cambian de verdad los ítems (comparados en orden). */
export function cambianItems(existente: GastoComparable, dto: UpdateGastoDto): boolean {
  if (!dto.items || dto.items.length === 0) return false;
  const actuales = existente.gasto_det ?? [];
  if (dto.items.length !== actuales.length) return true;
  return dto.items.some((nuevo, i) => {
    const viejo = actuales[i];
    if (id(nuevo.producto_id) !== id(viejo.producto_id)) return true;
    if (id(nuevo.requisicion_det_id) !== id(viejo.requisicion_det_id)) return true;
    if (id(nuevo.tipo_gasto_id) !== id(viejo.tipo_gasto_id)) return true;
    // Con producto, una descripción vacía toma la del producto: no es un cambio.
    const descripcionNueva = textoItem(nuevo.descripcion);
    if (!(nuevo.producto_id && !descripcionNueva) && descripcionNueva !== textoItem(viejo.descripcion)) return true;
    if (num(nuevo.cantidad, 4) !== num(viejo.cantidad, 4)) return true;
    if (num(nuevo.precio_unitario, 4) !== num(viejo.precio_unitario, 4)) return true;
    if (
      nuevo.porcentaje_iva !== undefined &&
      nuevo.porcentaje_iva !== null &&
      num(nuevo.porcentaje_iva, 2) !== num(viejo.porcentaje_iva ?? 10, 2)
    )
      return true;
    return false;
  });
}

/** Total IVA incluido de los ítems del DTO, como lo calcula el servicio. */
function totalDeItems(items: NonNullable<UpdateGastoDto['items']>): number {
  return num(
    items.reduce((acc, it) => acc + num(Number(it.cantidad || 0) * Number(it.precio_unitario || 0), 2), 0),
    2,
  );
}

/**
 * Verdadero solo si cambia de verdad el proveedor, la forma de pago, la
 * requisición, la moneda, la cotización o los ítems. Eso es lo que obliga a
 * rehacer la CxP y a que el gasto no tenga pagos aplicados.
 */
export function esEdicionFinanciera(
  existente: GastoComparable,
  dto: UpdateGastoDto,
  monedaPygId: string | null,
): boolean {
  const cab: Record<string, any> = dto.cabecera ?? {};
  if (viene(cab, 'proveedor_id')) {
    if (id(cab.proveedor_id) !== id(existente.proveedor_id)) return true;
  }
  if (viene(cab, 'forma_pago') && normalizarFormaPago(cab.forma_pago) !== normalizarFormaPago(existente.forma_pago))
    return true;
  if (viene(cab, 'requisicion_id')) {
    if (id(cab.requisicion_id) !== id(existente.requisicion_id)) return true;
  }
  if (cambiaMonedaOCotizacion(existente, dto, monedaPygId)) return true;
  return cambianItems(existente, dto);
}

/** Cambia de verdad la moneda o la cotización (lo que obliga a volver a resolver la cotización). */
export function cambiaMonedaOCotizacion(
  existente: GastoComparable,
  dto: UpdateGastoDto,
  monedaPygId: string | null,
): boolean {
  const cab: Record<string, any> = dto.cabecera ?? {};
  return cambiaMoneda(existente, cab, monedaPygId) || cambiaCotizacion(existente, cab, monedaPygId);
}

/**
 * Verdadero si cambia lo que sale de la cuenta: moneda, cotización, cuenta,
 * medio de pago o total. Solo entonces hay que volver a validar que la cuenta
 * acepta la moneda (N5) y rehacer el egreso.
 */
export function cambiaElPago(
  existente: GastoComparable,
  dto: UpdateGastoDto,
  monedaPygId: string | null = null,
): boolean {
  const cab: Record<string, any> = dto.cabecera ?? {};
  if (cambiaMonedaOCotizacion(existente, dto, monedaPygId)) return true;
  if (viene(cab, 'cuenta_tesoreria_id') && id(cab.cuenta_tesoreria_id) !== id(existente.cuenta_tesoreria_id))
    return true;
  if (viene(cab, 'medio_pago_id') && id(cab.medio_pago_id) !== id(existente.medio_pago_id)) return true;
  if (dto.items && dto.items.length > 0 && totalDeItems(dto.items) !== num(existente.total, 2)) return true;
  return false;
}
