import { Prisma } from '@prisma/client';
import { ListaPreciosController } from './lista-precios.controller';
import { ListaPreciosService } from './lista-precios.service';
import { claveGeneracionCatalogo } from 'src/ecommerce/catalogo-cache';
import { ProductosService } from 'src/productos/productos.service';

/**
 * B12 y lo que necesita la pantalla nueva: moneda solo de las habilitadas, duplicar con zona,
 * cuotas que no se pisan, códigos de error, listado con estado y orden, resumen y tienda.
 */
const crearServicio = (prisma: any) => {
  const service = Object.create(ListaPreciosService.prototype) as ListaPreciosService;
  const audit = { log: jest.fn() };
  const cache = { set: jest.fn().mockResolvedValue(undefined) };
  Object.assign(service as any, { prisma, auditService: audit, cache, logger: { log: jest.fn(), error: jest.fn() } });
  return { service, audit, cache };
};

const filaMoneda = (codigo: string) => ({ moneda: { codigo } });

/** Empresa con estas monedas habilitadas (`principal` es la marcada). Una moneda inactiva no llega: el `where` la excluye. */
const monedas = (habilitadas: string[], principal?: string) => ({
  findMany: jest.fn().mockResolvedValue(habilitadas.map(filaMoneda)),
  findFirst: jest.fn().mockResolvedValue(principal ? filaMoneda(principal) : null),
});

const prismaLista = (extra: any = {}) => ({
  lista_precios: {
    findFirst: jest.fn().mockResolvedValue(null),
    create: jest.fn().mockImplementation(({ data }) => Promise.resolve({ id: 'n1', ...data })),
    update: jest.fn().mockImplementation(({ data }) => Promise.resolve({ id: 'l1', nombre: 'Lista', ...data })),
    ...extra.lista_precios,
  },
  empresa_monedas: extra.empresa_monedas ?? monedas(['PYG'], 'PYG'),
  clientes: { findMany: jest.fn().mockResolvedValue([]) },
  lista_precios_asignaciones: { findMany: jest.fn().mockResolvedValue([]), create: jest.fn().mockImplementation(({ data }) => Promise.resolve(data)), findFirst: jest.fn().mockResolvedValue(null) },
  lista_precios_productos: { count: jest.fn().mockResolvedValue(0) },
  moneda: { findFirst: jest.fn().mockResolvedValue({ decimales_estandar: 2 }) },
  ...extra.resto,
});

/** La lista existe y el código está libre: asegurarListaDeEmpresa la encuentra y validarCodigoLibre no encuentra otra. */
const listaExistente = (lista: any) => ({
  findFirst: jest.fn(({ where }: any) => Promise.resolve(where.codigo ? null : lista)),
});

const duplicable = (origen: any) => {
  const tx = {
    lista_precios: { create: jest.fn().mockImplementation(({ data }) => Promise.resolve({ id: 'l2', empresa_id: 'e1', nombre: data.nombre, codigo: data.codigo, ...data })) },
    lista_precios_productos: { createMany: jest.fn() },
    lista_precios_asignaciones: { createMany: jest.fn() },
  };
  const prisma: any = {
    lista_precios: { ...listaExistente({ id: 'l1' }), findUnique: jest.fn().mockResolvedValue({ id: 'l1', empresa_id: 'e1', nombre: 'Origen', moneda: 'PYG', activa: true, lista_precios_productos: [], lista_precios_asignaciones: [], ...origen }) },
    empresa_monedas: monedas(['PYG'], 'PYG'),
    $transaction: (fn: any) => fn(tx),
  };
  return { prisma, tx };
};

describe('ListaPreciosService · B12', () => {
  afterEach(() => jest.useRealTimers());

  it('duplicar copia zona_id en las asignaciones', async () => {
    const { prisma, tx } = duplicable({ lista_precios_asignaciones: [{ tipo_entidad: 'zona', entidad_id: null, zona_id: 'z1', zona_geografica: 'Norte', canal_venta: null }] });
    await crearServicio(prisma).service.duplicarListaPrecios('l1', { codigo: 'C2', nombre: 'Copia', copiarAsignaciones: true }, 'u1', 'e1');
    expect(tx.lista_precios_asignaciones.createMany.mock.calls[0][0].data[0]).toMatchObject({ tipo_entidad: 'zona', zona_id: 'z1', zona_geografica: 'Norte' });
  });

  it('crear con una moneda que la empresa no tiene', async () => {
    const prisma = prismaLista();
    await expect(crearServicio(prisma).service.crearListaPrecios({ codigo: 'A', nombre: 'A', moneda: 'USD' } as any, 'e1', 'u1')).rejects.toMatchObject({
      status: 400,
      response: expect.objectContaining({ codigo: 'MONEDA_NO_HABILITADA', campo: 'moneda' }),
    });
    expect(prisma.lista_precios.create).not.toHaveBeenCalled();
  });

  it('crear con una moneda habilitada la guarda normalizada', async () => {
    const prisma = prismaLista({ empresa_monedas: monedas(['PYG', 'USD'], 'PYG') });
    await crearServicio(prisma).service.crearListaPrecios({ codigo: 'A', nombre: 'A', moneda: 'usd' } as any, 'e1', 'u1');
    expect(prisma.lista_precios.create.mock.calls[0][0].data.moneda).toBe('USD');
  });

  it('crear sin moneda toma la principal', async () => {
    const prisma = prismaLista({ empresa_monedas: monedas(['USD'], 'USD') });
    await crearServicio(prisma).service.crearListaPrecios({ codigo: 'A', nombre: 'A' } as any, 'e1', 'u1');
    expect(prisma.lista_precios.create.mock.calls[0][0].data.moneda).toBe('USD');
  });

  it('empresa sin filas de monedas sigue creando en PYG', async () => {
    const prisma = prismaLista({ empresa_monedas: monedas([]) });
    await crearServicio(prisma).service.crearListaPrecios({ codigo: 'A', nombre: 'A', moneda: 'PYG' } as any, 'e1', 'u1');
    expect(prisma.lista_precios.create.mock.calls[0][0].data.moneda).toBe('PYG');
  });

  it('una moneda con active false no se admite (y una con active nulo sí)', async () => {
    const prisma = prismaLista({ empresa_monedas: monedas([], 'PYG') });
    await expect(crearServicio(prisma).service.crearListaPrecios({ codigo: 'A', nombre: 'A', moneda: 'USD' } as any, 'e1', 'u1')).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'MONEDA_NO_HABILITADA' }) });
    expect(prisma.empresa_monedas.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'e1', OR: [{ active: true }, { active: null }] });
  });

  it('cambiar moneda: valida, audita y conserva clientesAsignados', async () => {
    const prisma = prismaLista({
      lista_precios: listaExistente({ id: 'l1', moneda: 'PYG' }),
      empresa_monedas: monedas(['PYG', 'USD'], 'PYG'),
      resto: { clientes: { findMany: jest.fn().mockResolvedValue([{ id: 'c1' }]) } },
    });
    prisma.lista_precios.update = jest.fn().mockResolvedValue({ id: 'l1', nombre: 'Lista', moneda: 'USD' });
    const { service, audit } = crearServicio(prisma);
    const r = await service.cambiarMonedaLista('l1', 'usd', 'u1', 'e1');
    expect(r.clientesAsignados).toBe(1);
    expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ user_id: 'u1', old_value: { moneda: 'PYG' }, new_value: { moneda: 'USD' } }));
  });

  it('cambiar a una moneda no habilitada no escribe', async () => {
    const prisma = prismaLista({ lista_precios: { ...listaExistente({ id: 'l1', moneda: 'PYG' }), update: jest.fn() } });
    await expect(crearServicio(prisma).service.cambiarMonedaLista('l1', 'EUR', 'u1', 'e1')).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'MONEDA_NO_HABILITADA', campo: 'moneda' }) });
    expect(prisma.lista_precios.update).not.toHaveBeenCalled();
  });

  it('cambiar con un formato inválido da el mismo código', async () => {
    const prisma = prismaLista({ lista_precios: listaExistente({ id: 'l1', moneda: 'PYG' }) });
    await expect(crearServicio(prisma).service.cambiarMonedaLista('l1', 'dólar', 'u1', 'e1')).rejects.toMatchObject({ status: 400, response: expect.objectContaining({ codigo: 'MONEDA_NO_HABILITADA' }) });
  });

  it('editar sin moneda no la valida', async () => {
    const prisma = prismaLista({ lista_precios: listaExistente({ id: 'l1', moneda: 'USD' }) });
    prisma.lista_precios.update = jest.fn().mockResolvedValue({ id: 'l1', nombre: 'LP-USD' });
    await crearServicio(prisma).service.actualizarListaPrecios('l1', { nombre: 'LP-USD', prioridad: 40 }, 'u1', 'e1');
    expect(prisma.empresa_monedas.findMany).not.toHaveBeenCalled();
    expect(prisma.lista_precios.update.mock.calls[0][0].data.prioridad).toBe(40);
  });

  it('editar con otra moneda la valida', async () => {
    const prisma = prismaLista({ lista_precios: { ...listaExistente({ id: 'l1', moneda: 'PYG' }), update: jest.fn() } });
    await expect(crearServicio(prisma).service.actualizarListaPrecios('l1', { moneda: 'USD' }, 'u1', 'e1')).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'MONEDA_NO_HABILITADA' }) });
    expect(prisma.lista_precios.update).not.toHaveBeenCalled();
  });

  it('editar mandando la misma moneda no habilitada anda', async () => {
    const prisma = prismaLista({ lista_precios: listaExistente({ id: 'l1', moneda: 'USD' }) });
    prisma.lista_precios.update = jest.fn().mockResolvedValue({ id: 'l1', nombre: 'LP-USD' });
    await crearServicio(prisma).service.actualizarListaPrecios('l1', { moneda: 'USD' }, 'u1', 'e1');
    expect(prisma.lista_precios.update.mock.calls[0][0].data.moneda).toBe('USD');
  });

  it('duplicar una lista en moneda no habilitada sin mandar moneda anda', async () => {
    const { prisma, tx } = duplicable({ moneda: 'USD' });
    await crearServicio(prisma).service.duplicarListaPrecios('l1', { codigo: 'C2', nombre: 'Copia' }, 'u1', 'e1');
    expect(tx.lista_precios.create.mock.calls[0][0].data.moneda).toBe('USD');
  });

  it('duplicar mandando otra moneda no habilitada no crea', async () => {
    const { prisma, tx } = duplicable({ moneda: 'PYG' });
    await expect(crearServicio(prisma).service.duplicarListaPrecios('l1', { codigo: 'C2', nombre: 'Copia', moneda: 'EUR' }, 'u1', 'e1')).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'MONEDA_NO_HABILITADA' }) });
    expect(tx.lista_precios.create).not.toHaveBeenCalled();
  });

  describe('cuotas al guardar un precio', () => {
    const preciosPrisma = (existente: any) => {
      const prisma: any = {
        lista_precios: { findFirst: jest.fn().mockResolvedValue({ id: 'l1', nombre: 'Lista' }), findUnique: jest.fn().mockResolvedValue({ nombre: 'Lista', codigo: 'L' }) },
        productos: { findMany: jest.fn().mockResolvedValue([{ id: 'p1' }]) },
        lista_precios_productos: { findMany: jest.fn().mockResolvedValue(existente ? [{ producto_id: 'p1', ...existente }] : []), update: jest.fn().mockResolvedValue({}), create: jest.fn().mockResolvedValue({}) },
      };
      prisma.$transaction = (fn: any) => fn(prisma);
      return prisma;
    };

    it('actualizar un precio sin mandar cuotas no las toca', async () => {
      const prisma: any = preciosPrisma({ id: 'f1', origen_precio: 'lista', permite_cuotas: false, cuotas_maximas: 6 });
      await crearServicio(prisma).service.actualizarPreciosProductos('l1', [{ productoId: 'p1', precioBase: 100 }], 'u1', 'e1');
      const data = prisma.lista_precios_productos.update.mock.calls[0][0].data;
      expect(data.permite_cuotas).toBeUndefined();
      expect(data.cuotas_maximas).toBeUndefined();
    });

    it('mandando permiteCuotas false y cuotasMaximas 6 los guarda', async () => {
      const prisma: any = preciosPrisma({ id: 'f1', origen_precio: 'lista' });
      await crearServicio(prisma).service.actualizarPreciosProductos('l1', [{ productoId: 'p1', precioBase: 100, permiteCuotas: false, cuotasMaximas: 6 }], 'u1', 'e1');
      expect(prisma.lista_precios_productos.update.mock.calls[0][0].data).toMatchObject({ permite_cuotas: false, cuotas_maximas: 6 });
    });

    it('crear sin cuotas deja el default de la base', async () => {
      const prisma: any = preciosPrisma(null);
      await crearServicio(prisma).service.actualizarPreciosProductos('l1', [{ productoId: 'p1', precioBase: 100 }], 'u1', 'e1');
      const data = prisma.lista_precios_productos.create.mock.calls[0][0].data;
      expect(data.permite_cuotas).toBeUndefined();
      expect(data.cuotas_maximas).toBeUndefined();
    });
  });

  describe('errores con código', () => {
    it('código repetido: 409 con codigo LISTA_CODIGO_DUPLICADO y campo codigo, y el mensaje sigue igual', async () => {
      const prisma = prismaLista({ lista_precios: { findFirst: jest.fn().mockResolvedValue({ id: 'x', codigo: 'MAY', nombre: 'Mayorista' }), create: jest.fn() } });
      await expect(crearServicio(prisma).service.crearListaPrecios({ codigo: 'may', nombre: 'Otra' } as any, 'e1')).rejects.toMatchObject({
        status: 409,
        response: expect.objectContaining({ success: false, codigo: 'LISTA_CODIGO_DUPLICADO', campo: 'codigo', message: 'Ya existe una lista con el código MAY («Mayorista»). Elegí otro código.' }),
      });
    });

    it('lista ajena: 404 con LISTA_NO_ENCONTRADA', async () => {
      const prisma = prismaLista({ lista_precios: { findFirst: jest.fn().mockResolvedValue(null) } });
      await expect(crearServicio(prisma).service.cambiarEstadoLista('l1', false, 'u1', 'ajena')).rejects.toMatchObject({ status: 404, response: expect.objectContaining({ codigo: 'LISTA_NO_ENCONTRADA' }) });
    });

    it('alta sin código: CODIGO_LISTA_REQUERIDO', async () => {
      await expect(crearServicio(prismaLista()).service.crearListaPrecios({ codigo: '  ', nombre: 'A' } as any, 'e1')).rejects.toMatchObject({ status: 400, response: expect.objectContaining({ codigo: 'CODIGO_LISTA_REQUERIDO', campo: 'codigo' }) });
    });

    it('edición con código vacío: CODIGO_LISTA_REQUERIDO', async () => {
      const prisma = prismaLista({ lista_precios: listaExistente({ id: 'l1', moneda: 'PYG' }) });
      await expect(crearServicio(prisma).service.actualizarListaPrecios('l1', { codigo: ' ' }, 'u1', 'e1')).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'CODIGO_LISTA_REQUERIDO' }) });
    });

    it('duplicar sin código y sin nombre', async () => {
      const a = duplicable({});
      await expect(crearServicio(a.prisma).service.duplicarListaPrecios('l1', { codigo: '', nombre: 'X' }, 'u1', 'e1')).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'CODIGO_LISTA_REQUERIDO', campo: 'codigo' }) });
      const b = duplicable({});
      await expect(crearServicio(b.prisma).service.duplicarListaPrecios('l1', { codigo: 'X', nombre: '' }, 'u1', 'e1')).rejects.toMatchObject({ response: expect.objectContaining({ codigo: 'NOMBRE_LISTA_REQUERIDO', campo: 'nombre' }) });
    });

    it('P2002 en relanzar da LISTA_CODIGO_DUPLICADO', async () => {
      const c = Object.create(ListaPreciosController.prototype) as ListaPreciosController;
      const err = new Prisma.PrismaClientKnownRequestError('dup', { code: 'P2002', clientVersion: 'x' });
      Object.assign(c as any, { listaPreciosService: { crearListaPrecios: jest.fn().mockRejectedValue(err) }, logger: { error: jest.fn() } });
      await expect(c.crearListaPrecios({} as any, { id: 'u1', empresa_id: 'e1' } as any)).rejects.toMatchObject({ status: 409, response: expect.objectContaining({ codigo: 'LISTA_CODIGO_DUPLICADO', campo: 'codigo' }) });
    });
  });

  describe('listado', () => {
    const listado = (filas: any[] = []) => ({ lista_precios: { count: jest.fn().mockResolvedValue(filas.length), findMany: jest.fn().mockResolvedValue(filas) } });
    const hoy = '2026-11-05T00:00:00.000Z';

    beforeEach(() => jest.useFakeTimers({ now: new Date('2026-11-05T15:00:00Z') }));

    it('estado vencida filtra', async () => {
      const prisma: any = listado();
      await crearServicio(prisma).service.obtenerListasEmpresa('e1', { estado: 'vencida' });
      expect(prisma.lista_precios.findMany.mock.calls[0][0].where.AND).toEqual([{ activa: true, fecha_inicio: { lte: new Date(hoy) }, fecha_fin: { lt: new Date(hoy) } }]);
      expect(prisma.lista_precios.count.mock.calls[0][0].where.AND).toEqual([{ activa: true, fecha_inicio: { lte: new Date(hoy) }, fecha_fin: { lt: new Date(hoy) } }]);
    });

    it('estado vigente con búsqueda aplica los dos', async () => {
      const prisma: any = listado();
      await crearServicio(prisma).service.obtenerListasEmpresa('e1', { estado: 'vigente', nombre: 'may' });
      const { where } = prisma.lista_precios.findMany.mock.calls[0][0];
      expect(where.OR).toEqual([{ nombre: { contains: 'may', mode: 'insensitive' } }, { codigo: { contains: 'may', mode: 'insensitive' } }]);
      expect(where.AND[0].OR).toEqual([{ fecha_fin: null }, { fecha_fin: { gte: new Date(hoy) } }]);
    });

    it('orden nombre desc con id de desempate', async () => {
      const prisma: any = listado();
      await crearServicio(prisma).service.obtenerListasEmpresa('e1', { orden: 'nombre', direccion: 'desc' });
      expect(prisma.lista_precios.findMany.mock.calls[0][0].orderBy).toEqual([{ nombre: 'desc' }, { id: 'asc' }]);
    });

    it('orden desconocido deja el de hoy', async () => {
      const prisma: any = listado();
      await crearServicio(prisma).service.obtenerListasEmpresa('e1', { orden: 'empresa_id', direccion: 'desc' });
      expect(prisma.lista_precios.findMany.mock.calls[0][0].orderBy).toEqual([{ prioridad: 'asc' }, { fecha_creacion: 'desc' }, { id: 'asc' }]);
    });

    it('limit 9999 baja a 500', async () => {
      const prisma: any = listado();
      const r = await crearServicio(prisma).service.obtenerListasEmpresa('e1', {}, 1, 9999);
      expect(prisma.lista_precios.findMany.mock.calls[0][0].take).toBe(500);
      expect(r.limit).toBe(500);
    });

    it('cada fila trae estado_vigencia', async () => {
      const base = { activa: true, fecha_inicio: new Date('2026-01-01'), fecha_fin: null, fecha_creacion: new Date('2026-01-01'), fecha_actualizacion: null, _count: { lista_precios_productos: 0, lista_precios_asignaciones: 0, clientes: 0 } };
      const prisma: any = listado([
        { ...base, id: 'a' },
        { ...base, id: 'b', fecha_fin: new Date('2026-11-04') },
        { ...base, id: 'c', fecha_inicio: new Date('2026-11-06') },
        { ...base, id: 'd', activa: false },
      ]);
      const r = await crearServicio(prisma).service.obtenerListasEmpresa('e1');
      expect(r.data.map((l: any) => l.estado_vigencia)).toEqual(['vigente', 'vencida', 'programada', 'inactiva']);
    });

    it('resumen: cuenta por estado', async () => {
      const count = jest.fn(({ where }: any) => {
        if (where.activa === false) return Promise.resolve(1);
        if (where.fecha_inicio?.lte && !where.fecha_fin) return Promise.resolve(3);
        if (where.activa === undefined) return Promise.resolve(4);
        return Promise.resolve(0);
      });
      const r = await crearServicio({ lista_precios: { count } }).service.resumenListasEmpresa('e1');
      expect(r).toEqual({ vigentes: 3, programadas: 0, vencidas: 0, inactivas: 1, total: 4 });
      expect(count.mock.calls.every(([a]: any) => a.where.empresa_id === 'e1')).toBe(true);
    });
  });

  describe('a las 22:00 de Asunción', () => {
    beforeEach(() => jest.useFakeTimers({ now: new Date('2026-11-06T01:00:00Z') }));

    it('duplicar sin fecha toma el día de Asunción', async () => {
      const { prisma, tx } = duplicable({});
      await crearServicio(prisma).service.duplicarListaPrecios('l1', { codigo: 'C2', nombre: 'Copia' }, 'u1', 'e1');
      expect(tx.lista_precios.create.mock.calls[0][0].data.fecha_inicio.toISOString()).toBe('2026-11-05T00:00:00.000Z');
    });

    it('crear sin fecha toma el día de Asunción', async () => {
      const prisma = prismaLista();
      await crearServicio(prisma).service.crearListaPrecios({ codigo: 'A', nombre: 'A' } as any, 'e1');
      expect(prisma.lista_precios.create.mock.calls[0][0].data.fecha_inicio.toISOString()).toBe('2026-11-05T00:00:00.000Z');
    });

    it('el Excel del catálogo mira el mismo día que el motor', async () => {
      const findMany = jest.fn().mockResolvedValue([]);
      const productos = Object.create(ProductosService.prototype) as ProductosService;
      Object.assign(productos as any, {
        filtroListado: jest.fn().mockResolvedValue({ whereClause: {}, depositoIds: null }),
        puedeVerCosto: jest.fn().mockResolvedValue(false),
        prisma: { productos: { findMany: jest.fn().mockResolvedValue([]) }, categorias: { findMany: jest.fn().mockResolvedValue([]) }, depositos: { findMany: jest.fn().mockResolvedValue([]) }, lista_precios: { findMany } },
        listaPrecios: { monedaPrincipal: jest.fn().mockResolvedValue('PYG'), obtenerPreciosProductosBatch: jest.fn().mockResolvedValue({}) },
      });
      await productos.exportarCatalogo('e1', 'u1', {} as any);
      const { fecha_inicio, OR } = findMany.mock.calls[0][0].where;
      expect(fecha_inicio.lte.toISOString()).toBe('2026-11-05T00:00:00.000Z');
      expect(OR[1].fecha_fin.gte.toISOString()).toBe('2026-11-05T00:00:00.000Z');
    });

    it('asignar sin fecha a las 22:00 toma el día de Asunción', async () => {
      const prisma = prismaLista({
        lista_precios: { findFirst: jest.fn().mockResolvedValue({ id: 'l1' }) },
        resto: { clientes: { findFirst: jest.fn().mockResolvedValue({ id: 'c1' }) } },
      });
      await crearServicio(prisma).service.asignarListaPrecios('l1', [{ tipoEntidad: 'cliente', entidadId: 'c1' }], 'e1');
      expect(prisma.lista_precios_asignaciones.create.mock.calls[0][0].data.fecha_inicio.toISOString()).toBe('2026-11-05T00:00:00.000Z');
    });
  });

  describe('tienda', () => {
    const invalidada = (cache: any) => expect(cache.set).toHaveBeenCalledWith(claveGeneracionCatalogo('e1'), expect.any(Number), expect.any(Number));

    it('crear, editar, estado, moneda, duplicar y desactivar invalidan la tienda de la empresa', async () => {
      expect(claveGeneracionCatalogo('e1')).toBe('store:catalogo:gen:e1');

      const alta = crearServicio(prismaLista());
      await alta.service.crearListaPrecios({ codigo: 'A', nombre: 'A' } as any, 'e1');
      invalidada(alta.cache);

      const existente = () => {
        const p = prismaLista({ lista_precios: listaExistente({ id: 'l1', moneda: 'PYG' }), empresa_monedas: monedas(['PYG', 'USD'], 'PYG') });
        p.lista_precios.update = jest.fn().mockResolvedValue({ id: 'l1', nombre: 'L', empresa_id: 'e1', moneda: 'USD' });
        return crearServicio(p);
      };
      const editar = existente();
      await editar.service.actualizarListaPrecios('l1', { nombre: 'L' }, 'u1', 'e1');
      invalidada(editar.cache);

      const activar = existente();
      await activar.service.cambiarEstadoLista('l1', true, 'u1', 'e1');
      invalidada(activar.cache);

      const desactivar = existente();
      await desactivar.service.cambiarEstadoLista('l1', false, 'u1', 'e1');
      invalidada(desactivar.cache);

      const moneda = existente();
      await moneda.service.cambiarMonedaLista('l1', 'USD', 'u1', 'e1');
      invalidada(moneda.cache);

      const dup = crearServicio(duplicable({}).prisma);
      await dup.service.duplicarListaPrecios('l1', { codigo: 'C2', nombre: 'Copia' }, 'u1', 'e1');
      invalidada(dup.cache);
    });
  });
});

describe('Cambiar moneda: no deja una lista que cobre mal (ola final, N1)', () => {
  const preparar = (lista: any = {}, { pendientes = 0, principal = 'PYG' } = {}) => {
    const prisma: any = prismaLista({
      lista_precios: listaExistente({ id: 'l1', nombre: 'Lista', moneda: 'PYG', redondeo_activo: false, redondeo_decimales: 0, ...lista }),
      empresa_monedas: monedas(['PYG', 'USD'], principal),
    });
    prisma.lista_precios.update = jest.fn().mockResolvedValue({ id: 'l1', nombre: 'Lista' });
    prisma.lista_precios_productos.count.mockResolvedValue(pendientes);
    return { prisma, ...crearServicio(prisma) };
  };

  it('redondeo activo a 0 decimales, de PYG a USD: 409 LISTA_REDONDEO_MONEDA con campo y no escribe', async () => {
    const { prisma, service } = preparar({ redondeo_activo: true, redondeo_decimales: 0 });
    await expect(service.cambiarMonedaLista('l1', 'USD', 'u1', 'e1')).rejects.toMatchObject({
      status: 409,
      response: expect.objectContaining({ codigo: 'LISTA_REDONDEO_MONEDA', campo: 'redondeoDecimales', decimales: 2 }),
    });
    expect(prisma.lista_precios.update).not.toHaveBeenCalled();
    expect(prisma.moneda.findFirst.mock.calls[0][0].where).toEqual({ codigo: 'USD' });
  });

  it('redondeo activo con 2 decimales a USD: pasa', async () => {
    const { prisma, service } = preparar({ redondeo_activo: true, redondeo_decimales: 2 });
    await service.cambiarMonedaLista('l1', 'USD', 'u1', 'e1');
    expect(prisma.lista_precios.update).toHaveBeenCalled();
  });

  it('redondeo apagado a 0 decimales a USD: pasa', async () => {
    const { prisma, service } = preparar({ redondeo_activo: false, redondeo_decimales: 0 });
    await service.cambiarMonedaLista('l1', 'USD', 'u1', 'e1');
    expect(prisma.lista_precios.update).toHaveBeenCalled();
  });

  it('de USD a PYG con redondeo a 0 decimales: pasa (el guaraní va entero)', async () => {
    const { prisma, service } = preparar({ moneda: 'USD', redondeo_activo: true, redondeo_decimales: 0 });
    await service.cambiarMonedaLista('l1', 'PYG', 'u1', 'e1');
    expect(prisma.lista_precios.update).toHaveBeenCalled();
  });

  it('bases en 0 y la moneda nueva no es la principal: 409 LISTA_PRECIOS_PENDIENTES con filas y no escribe', async () => {
    const { prisma, service } = preparar({}, { pendientes: 3 });
    await expect(service.cambiarMonedaLista('l1', 'USD', 'u1', 'e1')).rejects.toMatchObject({
      status: 409,
      response: expect.objectContaining({ codigo: 'LISTA_PRECIOS_PENDIENTES', filas: 3 }),
    });
    expect(prisma.lista_precios_productos.count.mock.calls[0][0].where).toEqual({ lista_precios_id: 'l1', precio_base: 0 });
    expect(prisma.lista_precios.update).not.toHaveBeenCalled();
  });

  it('bases en 0 y la moneda nueva es la principal: pasa (quedan pendientes, toman el precio del producto)', async () => {
    const { prisma, service } = preparar({ moneda: 'USD' }, { pendientes: 3 });
    await service.cambiarMonedaLista('l1', 'PYG', 'u1', 'e1');
    expect(prisma.lista_precios.update).toHaveBeenCalled();
  });

  // Re-revisión de la ola: el PUT de la lista también acepta `moneda` y no puede esquivar el 409.
  it('PUT con moneda y redondeo a 0 decimales, de PYG a USD: 409 LISTA_REDONDEO_MONEDA y no escribe', async () => {
    const { prisma, service } = preparar({ redondeo_activo: true, redondeo_decimales: 0 });
    await expect(service.actualizarListaPrecios('l1', { moneda: 'USD' }, 'u1', 'e1')).rejects.toMatchObject({
      status: 409,
      response: expect.objectContaining({ codigo: 'LISTA_REDONDEO_MONEDA' }),
    });
    expect(prisma.lista_precios.update).not.toHaveBeenCalled();
  });

  it('PUT con moneda y bases en 0, a una moneda que no es la principal: 409 LISTA_PRECIOS_PENDIENTES y no escribe', async () => {
    const { prisma, service } = preparar({}, { pendientes: 2 });
    await expect(service.actualizarListaPrecios('l1', { moneda: 'USD' }, 'u1', 'e1')).rejects.toMatchObject({
      status: 409,
      response: expect.objectContaining({ codigo: 'LISTA_PRECIOS_PENDIENTES', filas: 2 }),
    });
    expect(prisma.lista_precios.update).not.toHaveBeenCalled();
  });

  it('PUT que cambia moneda y sube el redondeo a 2 decimales en el mismo pedido: pasa (se mira el redondeo que queda)', async () => {
    const { prisma, service } = preparar({ redondeo_activo: true, redondeo_decimales: 0 });
    await service.actualizarListaPrecios('l1', { moneda: 'USD', redondeoDecimales: 2 }, 'u1', 'e1');
    expect(prisma.lista_precios.update).toHaveBeenCalled();
  });
});
