import { DepositosService } from 'src/depositos/depositos.service';
import { FacturasService } from 'src/facturas/facturas.service';
import { NotaCreditosService } from 'src/nota-creditos/nota-creditos.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';

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

/**
 * Ronda 1 de la revisión de seguridad del costo: tres rutas más que entregaban el costo sin `INV_STK_COSTO_VER`.
 * - `GET /facturas/reporte/productos` (VEN_FAC_FACTURA_VER: Cajero y Vendedor): `costo_total` y `margen` por producto, arriba y en `en_moneda`.
 * - `GET /nota-creditos/:id` (VEN_NC_NOTA_CREDITO_VER: Vendedor): el producto entero de cada línea.
 * - `GET /depositos/:id` (INV_DEP_DEPOSITO_VER): el producto entero de cada fila de stock.
 * Los permisos son los de cada perfil de sistema del seed, resueltos con sus selectores.
 */
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 = (otorgados: Set<string>) =>
  (resolverPermisos as jest.Mock).mockImplementation(async (_p: unknown, _u: string, pedidos: string[]) => new Set(pedidos.filter((c) => otorgados.has(c))));

const PYG_ID = '11111111-1111-4111-8111-111111111111';
const USD_ID = '22222222-2222-4222-8222-222222222222';
const MONEDAS: Record<string, { id: string; codigo: string }> = {
  [PYG_ID]: { id: PYG_ID, codigo: 'PYG' },
  [USD_ID]: { id: USD_ID, codigo: 'USD' },
};

const crearPrisma = () => ({
  usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: true }) },
  empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'subsidiary' }) },
  rubros: { findFirst: jest.fn().mockResolvedValue(null) },
  asignacion_sucursal_caja_usuario: { findMany: jest.fn().mockResolvedValue([]) },
  empresas_sucursales: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn().mockResolvedValue(null) },
  empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG_ID }) },
  moneda: {
    findUnique: jest.fn((a: any) => Promise.resolve(MONEDAS[a.where.id] ?? null)),
    findFirst: jest.fn().mockResolvedValue({ id: PYG_ID }),
  },
  factura_cab: { count: jest.fn(), findMany: jest.fn() },
  factura_det: { findMany: jest.fn(), count: jest.fn(), aggregate: jest.fn() },
});

const servicio = (prisma: any) => {
  const service: any = Object.create(FacturasService.prototype);
  service.prisma = prisma;
  return service;
};

/** Líneas de factura: prod-1 vendido en PYG y en USD (cotización 7500), prod-2 en una factura sin moneda. */
const cab = (id: string, moneda: string | null, dticam: number | null, dtotope: number, dtotalgs: number) => ({
  id,
  moneda_id: moneda,
  dticam,
  moneda: moneda ? { codigo: MONEDAS[moneda].codigo } : null,
  factura_subtotales: [{ dtotope, dtotalgs }],
});
const PROD1 = { id: 'prod-1', descripcion: 'JAMONADA', cod_producto: 'JAM', precio: 0, precio_costo: 80000, tipo: 'producto', categoria: { id: 'cat-a', descripcion: 'Fiambres' } };
const PROD2 = { id: 'prod-2', descripcion: 'QUESO', cod_producto: 'QUE', precio: 0, precio_costo: 0, tipo: 'producto', categoria: { id: 'cat-b', descripcion: 'Lácteos' } };
const L1 = {
  producto_id: 'prod-1', factura_cab_id: 'fac-1', ddesproser: 'JAMONADA', dcantproser: 10, dtotbruopeitem: 1100000, dtotopeitem: 1100000,
  ddescitem: 0, ddescgloitem: 0, dliqivaitem: 100000, duniproser: 110000, dticamit: null, productos: PROD1, factura_cab: cab('fac-1', PYG_ID, null, 1100000, 1100000),
};
const L2 = {
  producto_id: 'prod-1', factura_cab_id: 'fac-2', ddesproser: 'JAMONADA', dcantproser: 1, dtotbruopeitem: 12, dtotopeitem: 11,
  ddescitem: 1, ddescgloitem: 0, dliqivaitem: 1, duniproser: 12, dticamit: null, productos: PROD1, factura_cab: cab('fac-2', USD_ID, 7500, 11, 82500),
};
const L3 = {
  producto_id: 'prod-2', factura_cab_id: 'fac-3', ddesproser: 'QUESO', dcantproser: 2, dtotbruopeitem: 50000, dtotopeitem: 50000,
  ddescitem: 0, ddescgloitem: 0, dliqivaitem: 4545.45, duniproser: 25000, dticamit: null, productos: PROD2, factura_cab: cab('fac-3', null, null, 50000, 50000),
};


const reporte = async () => {
  const prisma: any = crearPrisma();
  prisma.factura_det.findMany.mockResolvedValue([L1, L2, L3]);
  const service: any = Object.create(FacturasService.prototype);
  service.prisma = prisma;
  return service.getReporteProductos('emp-1', { limit: 50 }, 'usr-1');
};

const notaCredito = async () => {
  const prisma: any = {
    nota_credito_cab: {
      // Aplica el `omit` del producto como Prisma.
      findFirst: jest.fn().mockImplementation(async (args: any) => {
        const productos: Record<string, unknown> = { id: 'prod-1', descripcion: 'JAMONADA', precio: 110000, precio_costo: 80000 };
        for (const k of Object.keys(args.include.nota_credito_det.include.productos?.omit ?? {})) delete productos[k];
        return { id: 'nc-1', nota_credito_det: [{ id: 'd-1', productos }] };
      }),
    },
  };
  const service: any = Object.create(NotaCreditosService.prototype);
  service.prisma = prisma;
  return (await service.findOne('nc-1', 'emp-1')).data;
};

const deposito = async () => {
  const prisma: any = {
    depositos: {
      findFirst: jest.fn().mockResolvedValue({ id: 'dep-1', stock_deposito: [{ id: 's-1', cantidad_disponible: 3, producto: { id: 'prod-1', descripcion: 'JAMONADA', precio_costo: 80000 } }] }),
    },
  };
  return new DepositosService(prisma, { log: jest.fn() } as any).findOne('dep-1', 'emp-1', 'usr-1');
};

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

describe('reporte de ventas por producto sin costo ni margen', () => {
  it.each(['Cajero', 'Vendedor'])('%s (VEN_FAC_FACTURA_VER sin INV_STK_COSTO_VER): ni costo_total ni margen, arriba ni en en_moneda', async (perfil) => {
    const otorgados = delPerfil(perfil);
    expect(otorgados.has('VEN_FAC_FACTURA_VER')).toBe(true);
    expect(otorgados.has('INV_STK_COSTO_VER')).toBe(false);
    comoPerfil(otorgados);
    const r = await reporte();
    const filas = [...r.productos, ...r.en_moneda.productos];
    expect(filas.length).toBeGreaterThan(0);
    for (const p of filas) {
      expect(p).not.toHaveProperty('costo_total');
      expect(p).not.toHaveProperty('margen');
      expect(p.ingresos_netos).toBeGreaterThan(0);
    }
    expect(JSON.stringify(r.por_moneda)).not.toMatch(/costo|margen/);
  });

  it.each(['Administrador', 'Supervisor'])('%s (con INV_STK_COSTO_VER): costo_total y margen', async (perfil) => {
    comoPerfil(delPerfil(perfil));
    const r = await reporte();
    const jam = r.en_moneda.productos.find((p: any) => p.producto_id === 'prod-1');
    expect(jam.costo_total).toBeGreaterThan(0);
    expect(typeof jam.margen).toBe('number');
  });
});

describe('nota de crédito: el producto de cada línea sin costo', () => {
  it('Vendedor (VEN_NC_NOTA_CREDITO_VER): sin precio_costo', async () => {
    const otorgados = delPerfil('Vendedor');
    expect(otorgados.has('VEN_NC_NOTA_CREDITO_VER')).toBe(true);
    comoPerfil(otorgados);
    const nc = await notaCredito();
    expect(nc.nota_credito_det[0].productos).not.toHaveProperty('precio_costo');
    expect(nc.nota_credito_det[0].productos.descripcion).toBe('JAMONADA');
  });
  it('Administrador: tampoco (ronda 2: la NC incluye el producto con omit del costo; ningún flujo lo lee de acá)', async () => {
    comoPerfil(delPerfil('Administrador'));
    expect((await notaCredito()).nota_credito_det[0].productos).not.toHaveProperty('precio_costo');
  });
});

describe('depósito: el producto de cada fila de stock sin costo', () => {
  it('quien ve depósitos sin INV_STK_COSTO_VER: sin precio_costo', async () => {
    comoPerfil(new Set(['INV_DEP_DEPOSITO_VER']));
    const d: any = await deposito();
    expect(d.stock_deposito[0].producto).not.toHaveProperty('precio_costo');
    expect(d.stock_deposito[0].cantidad_disponible).toBe(3);
  });
  it('Encargado Stock: con precio_costo', async () => {
    comoPerfil(delPerfil('Encargado Stock'));
    const d: any = await deposito();
    expect(d.stock_deposito[0].producto.precio_costo).toBe(80000);
  });
});
