import { DepositosService } from './depositos.service';

/**
 * Las operaciones por id de `depositos` solo ven los de la empresa de la sesión:
 * un id ajeno se contesta igual que uno inexistente (404 DEPOSITO_NO_ENCONTRADO) y no toca nada.
 */
describe('DepositosService: operaciones por id con empresa', () => {
  const MIA = 'empresa-mia';
  const AJENA = 'empresa-ajena';
  const SUC_MIA = 'suc-mia';
  const SUC_AJENA = 'suc-ajena';
  const depositoMio = { id: 'dep-mio', empresa_id: MIA, sucursal_id: SUC_MIA, descripcion: 'Mío', codigo: 'M', tipo: 'fisico', es_principal: false, active: true };
  const depositoAjeno = { id: 'dep-ajeno', empresa_id: AJENA, sucursal_id: SUC_AJENA, descripcion: 'Ajeno', codigo: 'A', tipo: 'fisico', es_principal: false, active: true };
  const SUCURSALES = [
    { id: SUC_MIA, empresa_id: MIA },
    { id: SUC_AJENA, empresa_id: AJENA },
  ];

  /** La base responde según el `where`: si el servicio no filtra por empresa, el depósito ajeno aparece. */
  const crear = () => {
    const filas = [depositoMio, depositoAjeno];
    const cumple = (fila: Record<string, unknown>, where: Record<string, unknown>) => Object.entries(where).every(([k, v]) => fila[k] === v);
    const prisma: any = {
      depositos: {
        findFirst: jest.fn(({ where }) => Promise.resolve(filas.find((f) => cumple(f, where)) ?? null)),
        findUnique: jest.fn(({ where }) => Promise.resolve(filas.find((f) => f.id === where.id) ?? null)),
        create: jest.fn(({ data }) => Promise.resolve({ id: 'dep-nuevo', ...data })),
        update: jest.fn(({ where, data }) => Promise.resolve({ ...filas.find((f) => f.id === where.id), ...data })),
        delete: jest.fn().mockResolvedValue({}),
      },
      empresas_sucursales: {
        findFirst: jest.fn(({ where }) => Promise.resolve(SUCURSALES.find((s) => cumple(s, where)) ?? null)),
      },
    };
    const audit: any = { log: jest.fn().mockResolvedValue(undefined) };
    return { prisma, audit, service: new DepositosService(prisma, audit) };
  };
  const noEncontrado = (codigo: string) => ({ status: 404, response: expect.objectContaining({ codigo }) });

  describe('con un depósito de otra empresa', () => {
    it('remove: 404 con su código, no se borra ni se audita', async () => {
      const { service, prisma, audit } = crear();
      await expect(service.remove(depositoAjeno.id, MIA, 'usr')).rejects.toMatchObject(noEncontrado('DEPOSITO_NO_ENCONTRADO'));
      expect(prisma.depositos.delete).not.toHaveBeenCalled();
      expect(audit.log).not.toHaveBeenCalled();
    });

    it('findOne: 404, no devuelve el depósito ni su stock', async () => {
      const { service } = crear();
      await expect(service.findOne(depositoAjeno.id, MIA)).rejects.toMatchObject(noEncontrado('DEPOSITO_NO_ENCONTRADO'));
    });

    it('update: 404, no se modifica', async () => {
      const { service, prisma, audit } = crear();
      await expect(service.update(depositoAjeno.id, { descripcion: 'Pisado' }, MIA, 'usr')).rejects.toMatchObject(noEncontrado('DEPOSITO_NO_ENCONTRADO'));
      expect(prisma.depositos.update).not.toHaveBeenCalled();
      expect(audit.log).not.toHaveBeenCalled();
    });

    it('toggleActive: 404, no se desactiva', async () => {
      const { service, prisma, audit } = crear();
      await expect(service.toggleActive(depositoAjeno.id, MIA, 'usr')).rejects.toMatchObject(noEncontrado('DEPOSITO_NO_ENCONTRADO'));
      expect(prisma.depositos.update).not.toHaveBeenCalled();
      expect(audit.log).not.toHaveBeenCalled();
    });
  });

  describe('con una sucursal de otra empresa', () => {
    it('create: 404 con campo sucursal_id, no se crea', async () => {
      const { service, prisma } = crear();
      await expect(service.create({ sucursal_id: SUC_AJENA, descripcion: 'X' }, MIA, 'usr')).rejects.toMatchObject({
        status: 404,
        response: expect.objectContaining({ codigo: 'SUCURSAL_NO_ENCONTRADA', campo: 'sucursal_id' }),
      });
      expect(prisma.depositos.create).not.toHaveBeenCalled();
    });

    it('update: 404 con campo sucursal_id, no se mueve el depósito', async () => {
      const { service, prisma } = crear();
      await expect(service.update(depositoMio.id, { sucursal_id: SUC_AJENA }, MIA, 'usr')).rejects.toMatchObject({
        status: 404,
        response: expect.objectContaining({ codigo: 'SUCURSAL_NO_ENCONTRADA', campo: 'sucursal_id' }),
      });
      expect(prisma.depositos.update).not.toHaveBeenCalled();
    });
  });

  describe('con lo propio sigue andando', () => {
    it('remove borra y audita con la empresa de la sesión', async () => {
      const { service, prisma, audit } = crear();
      await expect(service.remove(depositoMio.id, MIA, 'usr')).resolves.toEqual({ message: 'Depósito eliminado exitosamente' });
      expect(prisma.depositos.delete).toHaveBeenCalledWith({ where: { id: depositoMio.id } });
      expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ empresa_id: MIA, action: 'DELETE', entity_id: depositoMio.id }));
    });

    it('findOne devuelve el depósito', async () => {
      const { service } = crear();
      await expect(service.findOne(depositoMio.id, MIA)).resolves.toMatchObject({ id: depositoMio.id });
    });

    it('update sin sucursal no la consulta; con una propia, actualiza', async () => {
      const { service, prisma } = crear();
      await service.update(depositoMio.id, { descripcion: 'Nuevo' }, MIA, 'usr');
      expect(prisma.empresas_sucursales.findFirst).not.toHaveBeenCalled();
      await service.update(depositoMio.id, { sucursal_id: SUC_MIA }, MIA, 'usr');
      expect(prisma.depositos.update).toHaveBeenCalledTimes(2);
    });

    it('toggleActive invierte el estado', async () => {
      const { service } = crear();
      await expect(service.toggleActive(depositoMio.id, MIA, 'usr')).resolves.toMatchObject({ data: { active: false } });
    });

    it('create con sucursal propia guarda la empresa de la sesión', async () => {
      const { service, prisma } = crear();
      await service.create({ sucursal_id: SUC_MIA, descripcion: 'Nuevo' }, MIA, 'usr');
      expect(prisma.depositos.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ empresa_id: MIA, sucursal_id: SUC_MIA }) }));
    });
  });
});
