import { GestionMoraService } from 'src/cobranzas/gestion-mora.service';
import { CobrosService } from 'src/cobros/cobros.service';
import { FacturasService } from 'src/facturas/facturas.service';
import { NotaCreditosService } from 'src/nota-creditos/nota-creditos.service';
import { NotaRemisionService } from 'src/nota-remision/nota-remision.service';
import { resolverPermisos } from 'src/productos/permisos-columnas';
import { PERFILES_SISTEMA_SEED, SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { PrivilegioSelector, resolverSelectores } from 'src/seguridad/seeds/selectores';
import { SyncService } from 'src/sync/sync.service';

jest.mock('src/productos/permisos-columnas', () => ({ resolverPermisos: jest.fn() }));

/**
 * Ronda 2 de la revisión del costo: el producto incluido entero (`productos: true` / `{ include }`) y el costo de venta de
 * `factura_det` salían en las respuestas de ventas. Ahora:
 * - el producto se incluye con `omit: OMITIR_COSTO_PRODUCTO` en facturas (lista), NC (lista y detalle), remisión (detalle)
 *   y la sincronización del POS. Nadie lo recibe ahí, porque ningún flujo lo lee de esas respuestas;
 * - `costo_unitario_venta`/`costo_total_venta` (y el costo de cada lote de la línea) salen en `GET /facturas` y
 *   `/facturas/:id` solo con INV_STK_COSTO_VER; en cobros pendientes y gestión de mora, nunca.
 * La base falsa de abajo aplica el `omit` de la consulta como lo haría Prisma: lo que se prueba es la consulta real.
 */
const privilegios: PrivilegioSelector[] = SEGURIDAD_SEED.flatMap((m) =>
  m.submodulos.flatMap((s) => s.privilegios.map((p) => ({ id: p.codigo, codigo: p.codigo, accion: p.accion, submodulos: { codigo: s.codigo, modulo_id: m.codigo } }))),
);
const modulos = SEGURIDAD_SEED.map((m) => ({ id: m.codigo, codigo: m.codigo }));
const delPerfil = (nombre: string) => new Set(resolverSelectores(PERFILES_SISTEMA_SEED.find((x) => x.perfil === nombre)!.selectores, privilegios, modulos));
const comoPerfil = (nombre: string) => {
  const otorgados = delPerfil(nombre);
  (resolverPermisos as jest.Mock).mockImplementation(async (_p: unknown, _u: string, pedidos: string[]) => new Set(pedidos.filter((c) => otorgados.has(c))));
  return otorgados;
};

/** Aplica a la fila el `omit` de la consulta (arriba y en cada relación de `include`/`select`), como Prisma. */
function aplicar(fila: any, args: any): any {
  if (Array.isArray(fila)) return fila.map((f) => aplicar(f, args));
  if (!fila || typeof fila !== 'object' || !args || typeof args !== 'object') return fila;
  const copia = { ...fila };
  for (const k of Object.keys(args.omit ?? {})) delete copia[k];
  const rel = { ...(args.include ?? {}), ...(args.select ?? {}) };
  for (const [k, v] of Object.entries(rel)) if (v && typeof v === 'object' && k in copia) copia[k] = aplicar(copia[k], v);
  return copia;
}
const devuelve = (fila: any) => jest.fn(async (args: any) => aplicar(fila, args));
const devuelveLista = (filas: any[]) => jest.fn(async (args: any) => aplicar(filas, args));

const PRODUCTO = { id: 'prod-1', descripcion: 'JAMONADA', precio: 110000, precio_costo: 80000, unidades_de_medida: { id: 'u' } };
const DET_FACTURA = () => ({
  id: 'd-1', dcantproser: 2, costo_unitario_venta: 80000, costo_total_venta: 160000, productos: { ...PRODUCTO },
  factura_det_lote: [{ id: 'l-1', cantidad: 2, costo_unitario: 80000, costo_total: 160000, lotes_producto: { id: 'lp', numero_lote: 'A' } }],
});
const FACTURA = () => ({ id: 'fac-1', cliente_id: null, dfeemide: new Date(), created_at: new Date(), factura_det: [DET_FACTURA()], pedido_origen: null });

const servicio = <T>(Clase: new (...a: any[]) => T, prisma: any): any => Object.assign(Object.create(Clase.prototype), { prisma });
const basePrisma = () => ({
  usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: true }) },
  empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'subsidiary' }) },
  asignacion_sucursal_caja_usuario: { findMany: jest.fn().mockResolvedValue([]) },
  empresas_sucursales: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn().mockResolvedValue(null) },
  cob_gestion_mora: { findMany: jest.fn().mockResolvedValue([]) },
  $transaction: jest.fn(async (ops: any[]) => Promise.all(ops)),
});

const facturas = async () => {
  const prisma: any = { ...basePrisma(), factura_cab: { findMany: devuelveLista([FACTURA()]), count: jest.fn().mockResolvedValue(1) } };
  return (await servicio(FacturasService, prisma).findAll(1, 10, 'emp-1', { usuarioId: 'usr-1' })).items[0];
};
const factura = async () => {
  const prisma: any = {
    ...basePrisma(),
    // El detalle no incluye el producto: la línea llega sin `productos` (como lo devolvería Prisma).
    factura_cab: { findFirst: devuelve({ ...FACTURA(), factura_det: [{ ...DET_FACTURA(), productos: undefined }], cliente_id: null, vendedor: null, cobrador: null, clientes: null }) },
    cob_interes_cobrado: { findFirst: jest.fn().mockResolvedValue(null) },
    vendedores_cobradores: { findUnique: jest.fn().mockResolvedValue(null) },
  };
  return (await servicio(FacturasService, prisma).findOne('fac-1', 'emp-1', 'usr-1')).data;
};

beforeEach(() => jest.clearAllMocks());

describe('facturas: lista y detalle', () => {
  it.each(['Cajero', 'Vendedor'])('%s: sin el costo de venta de la línea ni de sus lotes, y el producto sin precio_costo', async (perfil) => {
    expect(comoPerfil(perfil).has('VEN_FAC_FACTURA_VER')).toBe(true);
    for (const f of [await facturas(), await factura()]) {
      const d = f.factura_det[0];
      expect(d).not.toHaveProperty('costo_unitario_venta');
      expect(d).not.toHaveProperty('costo_total_venta');
      expect(d.factura_det_lote[0]).not.toHaveProperty('costo_unitario');
      expect(d.factura_det_lote[0]).not.toHaveProperty('costo_total');
      expect(d.factura_det_lote[0].cantidad).toBe(2);
      if (d.productos) expect(d.productos).not.toHaveProperty('precio_costo');
    }
  });
  it.each(['Administrador', 'Supervisor'])('%s (INV_STK_COSTO_VER): con el costo de venta de la línea y del lote', async (perfil) => {
    comoPerfil(perfil);
    for (const f of [await facturas(), await factura()]) {
      expect(f.factura_det[0].costo_total_venta).toBe(160000);
      expect(f.factura_det[0].factura_det_lote[0].costo_total).toBe(160000);
    }
  });
});

describe('notas de crédito y remisiones: el producto de cada línea sin costo', () => {
  const NC = () => ({ id: 'nc-1', dfeemide: new Date(), created_at: new Date(), nota_credito_det: [{ id: 'd', productos: { ...PRODUCTO } }] });
  it.each(['Vendedor', 'Administrador'])('%s: GET /nota-creditos y /nota-creditos/:id', async (perfil) => {
    comoPerfil(perfil);
    const prisma: any = { ...basePrisma(), nota_credito_cab: { findMany: devuelveLista([NC()]), count: jest.fn().mockResolvedValue(1), findFirst: devuelve(NC()) } };
    const s = servicio(NotaCreditosService, prisma);
    const lista = (await s.findAll(1, 10, 'emp-1', { usuarioId: 'usr-1' })).data[0];
    const uno = (await s.findOne('nc-1', 'emp-1', 'usr-1')).data;
    for (const n of [lista, uno]) {
      expect(n.nota_credito_det[0].productos).not.toHaveProperty('precio_costo');
      expect(n.nota_credito_det[0].productos.descripcion).toBe('JAMONADA');
    }
  });
  it.each(['Vendedor', 'Administrador'])('%s: GET /nota-remision/:id', async (perfil) => {
    comoPerfil(perfil);
    const prisma: any = { nota_remision_cab: { findFirst: devuelve({ id: 'nr-1', deposito_destino_id: null, nota_remision_det: [{ id: 'd', productos: { ...PRODUCTO } }] }) } };
    const r = await servicio(NotaRemisionService, prisma).findOne('nr-1', 'emp-1');
    expect(r.nota_remision_det[0].productos).not.toHaveProperty('precio_costo');
    expect(r.nota_remision_det[0].productos.unidades_de_medida).toEqual({ id: 'u' });
  });
});

describe('cobranzas y sincronización del POS', () => {
  it('gestión de mora: las facturas sin el costo de venta de sus líneas', async () => {
    const prisma: any = { cob_gestion_mora: { findFirst: devuelve({ id: 'g', facturas: [{ factura_cab: { id: 'f', factura_det: [DET_FACTURA()] } }] }) } };
    const g = await servicio(GestionMoraService, prisma).findOne('g', 'emp-1');
    expect(g.facturas[0].factura_cab.factura_det[0]).not.toHaveProperty('costo_total_venta');
    expect(g.facturas[0].factura_cab.factura_det[0]).not.toHaveProperty('costo_unitario_venta');
  });
  it('cobros: las facturas a crédito pendientes sin el costo de venta (consulta con omit)', async () => {
    const prisma: any = { factura_cab: { findMany: jest.fn().mockResolvedValue([]) } };
    const s = servicio(CobrosService, prisma);
    s.interesManual = { pendienteParaCobro: jest.fn().mockResolvedValue({}) };
    await s.getFacturasCreditoPendientes('c', 'emp-1').catch(() => undefined);
    const args = prisma.factura_cab.findMany.mock.calls[0][0];
    expect(args.include.factura_det.omit).toEqual({ costo_unitario_venta: true, costo_total_venta: true });
  });
  it('GET /sync/productos (POS offline): sin precio_costo', async () => {
    const prisma: any = { productos: { findMany: devuelveLista([{ ...PRODUCTO }]) } };
    const [p] = await servicio(SyncService, prisma).getProductosDelta('emp-1');
    expect(p).not.toHaveProperty('precio_costo');
    expect(p.precio).toBe(110000);
  });
});
