import { CategoriasService } from './categorias.service';

jest.mock('src/utils/alcance-rubro', () => ({ rubrosFiltroUsuario: jest.fn().mockResolvedValue(null) }));
jest.mock('src/utils/rubro-context', () => ({ rubroDelRequest: jest.fn().mockReturnValue(null) }));
jest.mock('src/auth/guards/submodulo.guard', () => ({ submoduloHabilitado: jest.fn() }));
// eslint-disable-next-line @typescript-eslint/no-require-imports
const { submoduloHabilitado } = require('src/auth/guards/submodulo.guard') as { submoduloHabilitado: jest.Mock };

const E1 = 'E1';
const ID = '11111111-1111-4111-8111-111111111111';
const DEST = '22222222-2222-4222-8222-222222222222';
const PADRE = '33333333-3333-4333-8333-333333333333';
const RUBRO = '44444444-4444-4444-8444-444444444444';
const USER = '55555555-5555-4555-8555-555555555555';

function crear() {
  const prisma: any = {
    categorias: {
      findFirst: jest.fn(),
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockResolvedValue(0),
      create: jest.fn(),
      update: jest.fn(),
    },
    rubros: { findFirst: jest.fn() },
    productos: { count: jest.fn().mockResolvedValue(0), updateMany: jest.fn().mockResolvedValue({ count: 0 }) },
    reglas_precio: { count: jest.fn().mockResolvedValue(0) },
    planes_cuotas: { count: jest.fn().mockResolvedValue(0) },
    oferta_aplicacion: { count: jest.fn().mockResolvedValue(0) },
    inventario_sesiones: { count: jest.fn().mockResolvedValue(0) },
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
    perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue({ id: 'pp' }) },
    $queryRaw: jest.fn().mockResolvedValue([]),
    $transaction: jest.fn(),
  };
  prisma.$transaction.mockImplementation((cb: any) => (typeof cb === 'function' ? cb(prisma) : Promise.all(cb)));
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const cache = { set: jest.fn().mockResolvedValue(undefined) };
  submoduloHabilitado.mockReset().mockResolvedValue({ habilitado: true, fechaFinPrueba: null });
  return { service: new CategoriasService(prisma, audit as any, cache as any), prisma, audit, cache };
}

const cat = (extra: Record<string, unknown> = {}) => ({
  id: ID,
  empresa_id: E1,
  descripcion: 'Bebidas',
  padre_id: null,
  rubro_id: null,
  activo: true,
  deleted_at: false,
  icono: null,
  ...extra,
});

describe('CategoriasService (K1)', () => {
  describe('lecturas', () => {
    it('findTree pide _count.productos con deleted: false y los nodos lo traen', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findMany.mockResolvedValue([
        cat({ _count: { productos: 3 } }),
        cat({ id: DEST, padre_id: ID, _count: { productos: 0 } }),
      ]);
      const { data } = await service.findTree(E1);
      expect(prisma.categorias.findMany.mock.calls[0][0].include._count).toEqual({
        select: { productos: { where: { deleted: false } } },
      });
      expect(data[0]._count.productos).toBe(3);
      expect(data[0].children).toHaveLength(1);
    });

    it('findAll sigue aplicando el rubro (where con empresa y no borradas)', async () => {
      const { service, prisma } = crear();
      await service.findAll(1, 2000, E1, USER);
      expect(prisma.categorias.findMany.mock.calls[0][0].where).toMatchObject({ empresa_id: E1, deleted_at: false });
      expect(prisma.categorias.findMany.mock.calls[0][0].take).toBe(2000);
    });
  });

  describe('create y update: rubro, padre y ciclos', () => {
    it.each([
      ['create', (s: CategoriasService) => s.create({ descripcion: 'Nueva', rubro_id: RUBRO }, E1)],
      ['update', (s: CategoriasService) => s.update(ID, { rubro_id: RUBRO }, E1)],
    ])('%s con rubro_id de otra empresa da 404 RUBRO_NO_ENCONTRADO con campo rubro_id', async (_n, llamar) => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.rubros.findFirst.mockResolvedValue(null);
      await expect(llamar(service)).rejects.toMatchObject({
        status: 404,
        response: { codigo: 'RUBRO_NO_ENCONTRADO', campo: 'rubro_id' },
      });
      expect(prisma.rubros.findFirst).toHaveBeenCalledWith({ where: { id: RUBRO, empresa_id: E1 }, select: { id: true } });
      expect(prisma.categorias.create).not.toHaveBeenCalled();
      expect(prisma.categorias.update).not.toHaveBeenCalled();
    });

    it.each([
      ['create', (s: CategoriasService) => s.create({ descripcion: 'Nueva', padre_id: PADRE }, E1)],
      ['update', (s: CategoriasService) => s.update(ID, { padre_id: PADRE }, E1)],
    ])('%s con padre_id de otra empresa da 404 CATEGORIA_PADRE_NO_ENCONTRADA', async (_n, llamar) => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockImplementation(async ({ where }: any) => (where.id === ID ? cat() : null));
      await expect(llamar(service)).rejects.toMatchObject({
        status: 404,
        response: { codigo: 'CATEGORIA_PADRE_NO_ENCONTRADA', campo: 'padre_id' },
      });
    });

    function arbol(filas: Array<[string, string | null]>) {
      const ctx = crear();
      ctx.prisma.categorias.findFirst.mockImplementation(async ({ where }: any) =>
        where.id === ID ? cat() : filas.some(([id]) => id === where.id) ? { id: where.id } : null,
      );
      ctx.prisma.categorias.findMany.mockImplementation(async ({ select }: any) =>
        select?.padre_id ? filas.map(([id, padre_id]) => ({ id, padre_id })) : [],
      );
      ctx.prisma.categorias.update.mockResolvedValue(cat());
      return ctx;
    }

    it('A bajo A da 409 CATEGORIA_CICLO', async () => {
      const { service } = arbol([[ID, null]]);
      await expect(service.update(ID, { padre_id: ID }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_CICLO', campo: 'padre_id' },
      });
    });

    it('A bajo su hija da 409 CATEGORIA_CICLO', async () => {
      const { service } = arbol([[ID, null], [DEST, ID]]);
      await expect(service.update(ID, { padre_id: DEST }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_CICLO' },
      });
    });

    it('A bajo su nieta da 409 CATEGORIA_CICLO', async () => {
      const { service } = arbol([[ID, null], [DEST, ID], [PADRE, DEST]]);
      await expect(service.update(ID, { padre_id: PADRE }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_CICLO' },
      });
    });

    it('A bajo B sin relación pasa', async () => {
      const { service, prisma } = arbol([[ID, null], [PADRE, null]]);
      await service.update(ID, { padre_id: PADRE }, E1);
      expect(prisma.categorias.update).toHaveBeenCalled();
    });

    it('con datos en lazo B→C→B termina y no cuelga', async () => {
      const { service, prisma } = arbol([[ID, null], [PADRE, DEST], [DEST, PADRE]]);
      await service.update(ID, { padre_id: PADRE }, E1);
      expect(prisma.categorias.update).toHaveBeenCalled();
    });

    it('padre_id null manda null; sin padre_id, undefined', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat({ padre_id: PADRE }));
      prisma.categorias.update.mockResolvedValue(cat());
      await service.update(ID, { padre_id: null }, E1);
      expect(prisma.categorias.update.mock.calls[0][0].data.padre_id).toBeNull();
      await service.update(ID, { color: '#4caf50' }, E1);
      expect(prisma.categorias.update.mock.calls[1][0].data.padre_id).toBeUndefined();
    });
  });

  describe('duplicados', () => {
    it('crear "servicios" con otra de igual padre y rubro da 409 CATEGORIA_DUPLICADA', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findMany.mockResolvedValue([{ id: 'x', descripcion: 'SERVICIOS' }]);
      await expect(service.create({ descripcion: 'servicios' }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_DUPLICADA', campo: 'descripcion', message: 'La categoría ya existe' },
      });
    });

    it('con igual padre y otro rubro pasa: la búsqueda va por padre y rubro', async () => {
      const { service, prisma } = crear();
      prisma.rubros.findFirst.mockResolvedValue({ id: RUBRO });
      prisma.categorias.create.mockResolvedValue(cat());
      await service.create({ descripcion: 'Servicios', rubro_id: RUBRO }, E1);
      expect(prisma.categorias.findMany.mock.calls[0][0].where).toMatchObject({ padre_id: null, rubro_id: RUBRO });
      expect(prisma.categorias.create).toHaveBeenCalled();
    });

    it('«JUGOS » guardada con espacio choca con «jugos»', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findMany.mockResolvedValue([{ id: 'x', descripcion: 'JUGOS ' }]);
      await expect(service.create({ descripcion: 'jugos' }, E1)).rejects.toMatchObject({ status: 409 });
    });

    it('editar solo color de una fila que ya choca no busca duplicados', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.categorias.update.mockResolvedValue(cat());
      await service.update(ID, { color: '#4caf50' }, E1);
      expect(prisma.categorias.findMany).not.toHaveBeenCalled();
    });

    it('cambiar el rubro y chocar da 409', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.rubros.findFirst.mockResolvedValue({ id: RUBRO });
      prisma.categorias.findMany.mockResolvedValue([{ id: 'x', descripcion: 'bebidas' }]);
      await expect(service.update(ID, { rubro_id: RUBRO }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_DUPLICADA' },
      });
      expect(prisma.categorias.findMany.mock.calls[0][0].where).toMatchObject({ rubro_id: RUBRO, id: { not: ID } });
    });

    it('descripción "   " da 400 CAMPO_REQUERIDO', async () => {
      const { service } = crear();
      await expect(service.create({ descripcion: '   ' }, E1)).rejects.toMatchObject({
        status: 400,
        response: { codigo: 'CAMPO_REQUERIDO', campo: 'descripcion' },
      });
    });
  });

  describe('id que no es uuid', () => {
    it.each([
      ['update', (s: CategoriasService) => s.update('no-uuid', { color: '#fff' }, E1)],
      ['activarDesactivar', (s: CategoriasService) => s.activarDesactivar('no-uuid', E1)],
      ['remove', (s: CategoriasService) => s.remove('no-uuid', E1)],
      ['reasignarYEliminar', (s: CategoriasService) => s.reasignarYEliminar('no-uuid', DEST, E1, USER)],
    ])('%s da 404 CATEGORIA_NO_ENCONTRADA sin consultar', async (_n, llamar) => {
      const { service, prisma } = crear();
      await expect(llamar(service)).rejects.toMatchObject({
        status: 404,
        response: { codigo: 'CATEGORIA_NO_ENCONTRADA', message: 'Categoría no encontrada' },
      });
      expect(prisma.categorias.findFirst).not.toHaveBeenCalled();
      expect(prisma.$transaction).not.toHaveBeenCalled();
    });
  });

  describe('remove', () => {
    it('con 1 hija da 409 CATEGORIA_CON_HIJAS con hijas: 1 y el mensaje de hoy', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.categorias.count.mockResolvedValue(1);
      await expect(service.remove(ID, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_CON_HIJAS', hijas: 1, message: 'No se puede eliminar una categoría con hijos' },
      });
      expect(prisma.categorias.update).not.toHaveBeenCalled();
    });

    it('con 3 productos no borrados da 409 CATEGORIA_CON_PRODUCTOS con productos: 3', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.productos.count.mockResolvedValue(3);
      await expect(service.remove(ID, E1)).rejects.toMatchObject({
        status: 409,
        response: {
          codigo: 'CATEGORIA_CON_PRODUCTOS',
          productos: 3,
          message: 'No se puede eliminar la categoría porque tiene 3 producto(s).',
        },
      });
      expect(prisma.productos.count).toHaveBeenCalledWith({ where: { categoria_id: ID, empresa_id: E1, deleted: false } });
    });

    it('con regla, plan y oferta activos da 409 CATEGORIA_EN_USO con los conteos', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.reglas_precio.count.mockResolvedValue(1);
      prisma.planes_cuotas.count.mockResolvedValue(2);
      prisma.oferta_aplicacion.count.mockResolvedValue(3);
      await expect(service.remove(ID, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_EN_USO', reglas: 1, planes: 2, ofertas: 3, sesiones: 0 },
      });
      expect(prisma.oferta_aplicacion.count).toHaveBeenCalledWith({
        where: { aplica_a: 'categoria', referencia_id: ID, ofertas: { empresa_id: E1, active: true } },
      });
    });

    it('con una sesión de inventario abierta con conteos de la categoría da CATEGORIA_EN_USO con sesiones: 1', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.inventario_sesiones.count.mockResolvedValue(1);
      await expect(service.remove(ID, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_EN_USO', sesiones: 1 },
      });
      expect(prisma.inventario_sesiones.count).toHaveBeenCalledWith({
        where: {
          empresa_id: E1,
          estado: 'abierto',
          OR: [{ conteos: { some: { categoria_id: ID } } }, { zonas_aplicadas: { some: { categoria_id: ID } } }],
        },
      });
    });

    it('sin nada, baja lógica y audita', async () => {
      const { service, prisma, audit } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.categorias.update.mockResolvedValue(cat({ deleted_at: true }));
      await service.remove(ID, E1, USER);
      expect(prisma.categorias.update).toHaveBeenCalledWith({
        where: { id: ID },
        data: { deleted_at: true, updated_at: expect.any(Date) },
      });
      expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'DELETE', entity_id: ID }));
    });

    it('el FOR UPDATE va antes de los count', async () => {
      const { service, prisma } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      prisma.categorias.update.mockResolvedValue(cat());
      await service.remove(ID, E1);
      const bloqueo = prisma.$queryRaw.mock.invocationCallOrder[0];
      expect(bloqueo).toBeLessThan(prisma.categorias.count.mock.invocationCallOrder[0]);
      expect(bloqueo).toBeLessThan(prisma.productos.count.mock.invocationCallOrder[0]);
    });
  });

  describe('reasignarYEliminar', () => {
    function lista() {
      const ctx = crear();
      ctx.prisma.categorias.findFirst.mockImplementation(async ({ where }: any) =>
        where.id === ID ? cat() : where.id === DEST ? cat({ id: DEST, descripcion: 'Otras' }) : null,
      );
      ctx.prisma.categorias.update.mockResolvedValue(cat({ deleted_at: true }));
      ctx.prisma.productos.updateMany.mockResolvedValue({ count: 5 });
      return ctx;
    }

    it('sin INV_PRD_PRODUCTO_EDITAR da 403 SIN_PERMISO_PRODUCTOS y no abre transacción', async () => {
      const { service, prisma } = lista();
      prisma.perfiles_privilegios.findFirst.mockResolvedValue(null);
      await expect(service.reasignarYEliminar(ID, DEST, E1, USER)).rejects.toMatchObject({
        status: 403,
        response: { codigo: 'SIN_PERMISO_PRODUCTOS' },
      });
      expect(prisma.$transaction).not.toHaveBeenCalled();
      expect(prisma.perfiles_privilegios.findFirst).toHaveBeenCalledWith({
        where: {
          active: true,
          modulos: { codigo: 'INVENTARIO' },
          privilegios: { codigo: 'INV_PRD_PRODUCTO_EDITAR' },
          perfiles: { usuario_perfiles: { some: { user_id: USER } } },
        },
        select: { id: true },
      });
    });

    it('con INV_PRODUCTOS excluido da 403 aunque tenga el permiso', async () => {
      const { service, prisma } = lista();
      submoduloHabilitado.mockResolvedValue({ habilitado: false, causa: 'excluido', mensaje: 'x' });
      await expect(service.reasignarYEliminar(ID, DEST, E1, USER)).rejects.toMatchObject({
        status: 403,
        response: { codigo: 'SIN_PERMISO_PRODUCTOS' },
      });
      expect(submoduloHabilitado).toHaveBeenCalledWith(prisma, E1, 'INV_PRODUCTOS');
      expect(prisma.$transaction).not.toHaveBeenCalled();
    });

    it('superadmin pasa sin mirar perfiles ni submódulo', async () => {
      const { service, prisma } = lista();
      prisma.usuario.findUnique.mockResolvedValue({ is_superadmin: true });
      prisma.perfiles_privilegios.findFirst.mockResolvedValue(null);
      await expect(service.reasignarYEliminar(ID, DEST, E1, USER)).resolves.toMatchObject({
        data: { productos_movidos: 5 },
      });
      expect(prisma.perfiles_privilegios.findFirst).not.toHaveBeenCalled();
    });

    it('destino_id === id da 400 DESTINO_INVALIDO', async () => {
      const { service, prisma } = lista();
      await expect(service.reasignarYEliminar(ID, ID, E1, USER)).rejects.toMatchObject({
        status: 400,
        response: { codigo: 'DESTINO_INVALIDO' },
      });
      expect(prisma.$transaction).not.toHaveBeenCalled();
    });

    it.each([
      ['de otra empresa o borrado', null],
      ['inactivo', null],
    ])('destino %s da 400 DESTINO_INVALIDO con campo destino_id', async (_n, destino) => {
      const { service, prisma } = lista();
      prisma.categorias.findFirst.mockImplementation(async ({ where }: any) => (where.id === ID ? cat() : destino));
      await expect(service.reasignarYEliminar(ID, DEST, E1, USER)).rejects.toMatchObject({
        status: 400,
        response: { codigo: 'DESTINO_INVALIDO', campo: 'destino_id' },
      });
      expect(prisma.categorias.findFirst).toHaveBeenCalledWith({
        where: { id: DEST, empresa_id: E1, deleted_at: false, activo: true },
        select: { id: true },
      });
      expect(prisma.productos.updateMany).not.toHaveBeenCalled();
    });

    it('con hijas da CATEGORIA_CON_HIJAS', async () => {
      const { service, prisma } = lista();
      prisma.categorias.count.mockResolvedValue(2);
      await expect(service.reasignarYEliminar(ID, DEST, E1, USER)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_CON_HIJAS', hijas: 2 },
      });
      expect(prisma.productos.updateMany).not.toHaveBeenCalled();
    });

    it('con sesión de inventario abierta da CATEGORIA_EN_USO', async () => {
      const { service, prisma } = lista();
      prisma.inventario_sesiones.count.mockResolvedValue(1);
      await expect(service.reasignarYEliminar(ID, DEST, E1, USER)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'CATEGORIA_EN_USO', sesiones: 1 },
      });
    });

    it('bloquea origen y destino en orden por id', async () => {
      const { service, prisma } = lista();
      await service.reasignarYEliminar(ID, DEST, E1, USER);
      const [textos] = prisma.$queryRaw.mock.calls[0];
      expect(textos.join('?')).toBe('SELECT id FROM categorias WHERE id IN (?::uuid, ?::uuid) ORDER BY id FOR UPDATE');
      expect(prisma.$queryRaw.mock.calls[0].slice(1)).toEqual([ID, DEST]);
    });

    it('mueve solo los no borrados de la empresa y devuelve productos_movidos', async () => {
      const { service, prisma } = lista();
      const r = await service.reasignarYEliminar(ID, DEST, E1, USER);
      expect(prisma.productos.updateMany).toHaveBeenCalledWith({
        where: { categoria_id: ID, empresa_id: E1, deleted: false },
        data: { categoria_id: DEST, updated_at: expect.any(Date) },
      });
      expect(r).toEqual({ message: 'Categoría eliminada exitosamente', data: { productos_movidos: 5 } });
      expect(prisma.categorias.update).toHaveBeenCalledWith({
        where: { id: ID },
        data: { deleted_at: true, updated_at: expect.any(Date) },
      });
    });

    it('si la baja lógica falla, rechaza y no invalida la caché', async () => {
      const { service, prisma, cache, audit } = lista();
      prisma.categorias.update.mockRejectedValue(new Error('falla'));
      await expect(service.reasignarYEliminar(ID, DEST, E1, USER)).rejects.toThrow('falla');
      expect(cache.set).not.toHaveBeenCalled();
      expect(audit.log).not.toHaveBeenCalled();
    });

    it('audita con new_value { destino_id, productos_movidos: 5 }', async () => {
      const { service, audit } = lista();
      await service.reasignarYEliminar(ID, DEST, E1, USER);
      expect(audit.log).toHaveBeenCalledWith(
        expect.objectContaining({
          action: 'DELETE',
          entity_type: 'categoria',
          entity_id: ID,
          user_id: USER,
          new_value: { destino_id: DEST, productos_movidos: 5 },
        }),
      );
    });
  });

  describe('caché de la tienda', () => {
    const escrituras: Array<[string, (s: CategoriasService, p: any) => Promise<unknown>]> = [
      ['create', (s, p) => (p.categorias.create.mockResolvedValue(cat()), s.create({ descripcion: 'Nueva' }, E1))],
      ['update', (s, p) => (p.categorias.update.mockResolvedValue(cat()), s.update(ID, { color: '#fff' }, E1))],
      ['activarDesactivar', (s, p) => (p.categorias.update.mockResolvedValue(cat()), s.activarDesactivar(ID, E1))],
      ['remove', (s, p) => (p.categorias.update.mockResolvedValue(cat()), s.remove(ID, E1))],
      [
        'reasignarYEliminar',
        (s, p) => {
          p.categorias.findFirst.mockImplementation(async ({ where }: any) => cat({ id: where.id }));
          p.categorias.update.mockResolvedValue(cat());
          return s.reasignarYEliminar(ID, DEST, E1, USER);
        },
      ],
    ];

    it.each(escrituras)('%s invalida la generación', async (_n, escribir) => {
      const { service, prisma, cache } = crear();
      prisma.categorias.findFirst.mockResolvedValue(cat());
      await escribir(service, prisma);
      expect(cache.set).toHaveBeenCalledWith('store:catalogo:gen:E1', expect.any(Number), expect.any(Number));
    });
  });
});
