import { NotFoundException } from '@nestjs/common';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { CajasController } from 'src/cajas/cajas.controller';
import { CajasService } from 'src/cajas/cajas.service';
import { SucursalesController } from './sucursales.controller';
import { SucursalesService } from './sucursales.service';

/**
 * Prueba de punta a punta: GET /cajas/:id, GET /cajas?sucursal_id, GET /sucursales/:id
 * devolvían datos de otra empresa, y PUT /sucursales/:id + activar-desactivar no
 * filtraban por empresa ni pedían permiso.
 */
const SUC_PROPIA = { id: 'suc-propia', empresa_id: 'emp-1', descripcion: 'Matriz', punto_establecimiento: '001', active: true };

const permisoDe = (proto: any, metodo: string) => Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto[metodo]);

describe('Sucursales — filtro por empresa del token', () => {
  const crear = () => {
    const prisma: any = {
      empresas_sucursales: {
        findFirst: jest.fn(({ where }) =>
          Promise.resolve(where.id === SUC_PROPIA.id && (where.empresa_id === undefined || where.empresa_id === 'emp-1') ? SUC_PROPIA : null),
        ),
        findUnique: jest.fn().mockResolvedValue(SUC_PROPIA),
        update: jest.fn(({ data }) => Promise.resolve({ ...SUC_PROPIA, ...data })),
        updateMany: jest.fn(),
        create: jest.fn(({ data }) => Promise.resolve({ id: 'nueva', ...data })),
        delete: jest.fn(),
      },
      $transaction: jest.fn((ops: any[]) => Promise.all(ops)),
    };
    const queues: any = { enqueueMiddlewareEmpresa: jest.fn() };
    const audit: any = { log: jest.fn() };
    const empresas: any = { findOne: jest.fn().mockResolvedValue({ id: 'emp-1' }) };
    return { service: new SucursalesService(empresas, prisma, queues, audit), prisma };
  };

  it('GET /sucursales/:id de otra empresa → 404', async () => {
    const { service } = crear();
    await expect(service.findOne('suc-propia', 'emp-2')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.findOne('suc-propia', 'emp-1')).resolves.toMatchObject({ data: { id: 'suc-propia' } });
  });

  it('detalle de otra empresa → 404', async () => {
    const { service } = crear();
    await expect(service.findOneWithRelations('suc-propia', 'emp-2')).rejects.toBeInstanceOf(NotFoundException);
  });

  it('PUT /sucursales/:id de otra empresa → 404 sin tocar nada', async () => {
    const { service, prisma } = crear();
    await expect(service.update('suc-propia', { descripcion: 'X' }, 'emp-2', 'u')).rejects.toBeInstanceOf(NotFoundException);
    expect(prisma.empresas_sucursales.update).not.toHaveBeenCalled();
  });

  it('PUT /sucursales/:id no muda la sucursal de empresa por el cuerpo', async () => {
    const { service, prisma } = crear();
    await service.update('suc-propia', { descripcion: 'Centro', empresa_id: 'emp-2' }, 'emp-1', 'u');
    expect(prisma.empresas_sucursales.update.mock.calls[0][0].data).toEqual({ descripcion: 'Centro' });
  });

  it('activar/desactivar de otra empresa → 404 sin tocar nada', async () => {
    const { service, prisma } = crear();
    await expect(service.activarDesactivar('suc-propia', 'emp-2', 'u')).rejects.toBeInstanceOf(NotFoundException);
    expect(prisma.empresas_sucursales.update).not.toHaveBeenCalled();
    await service.activarDesactivar('suc-propia', 'emp-1', 'u');
    expect(prisma.empresas_sucursales.update).toHaveBeenCalledWith({ where: { id: 'suc-propia' }, data: { active: false } });
  });

  it('predeterminada, logo y borrar: solo la propia', async () => {
    const { service } = crear();
    await expect(service.setDefault('suc-propia', 'emp-2', 'u')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.unsetDefault('suc-propia', 'emp-2', 'u')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.updateLogo('suc-propia', null, 'emp-2', 'u')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.remove('suc-propia', 'emp-2', 'u')).rejects.toBeInstanceOf(NotFoundException);
  });

  it('crear: la empresa sale del token, no del cuerpo', async () => {
    const { service, prisma } = crear();
    prisma.empresas_sucursales.findFirst.mockResolvedValueOnce(null);
    await service.create({ empresa_id: 'emp-2', punto_establecimiento: '002' } as any, 'emp-1', 'u');
    expect(prisma.empresas_sucursales.create.mock.calls[0][0].data.empresa_id).toBe('emp-1');
  });

  it('cada escritura pide su permiso de Administración › Sucursales', () => {
    const p = SucursalesController.prototype;
    expect(permisoDe(p, 'create')).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_SUC_SUCURSAL_CREAR' });
    expect(permisoDe(p, 'findOneWithRelations')).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_SUC_SUCURSAL_VER' });
    for (const m of ['update', 'activarDesactivar', 'setDefault', 'unsetDefault', 'updateConfig', 'uploadLogo', 'removeLogo']) {
      expect(permisoDe(p, m)).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_SUC_SUCURSAL_EDITAR' });
    }
    expect(permisoDe(p, 'remove')).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_SUC_SUCURSAL_ELIMINAR' });
  });
});

describe('Cajas — filtro por empresa del token', () => {
  const crear = () => {
    const prisma: any = {
      cajas: { findFirst: jest.fn().mockResolvedValue(null), findMany: jest.fn().mockResolvedValue([]) },
    };
    return { service: new CajasService(prisma, { log: jest.fn() } as any), prisma };
  };

  it('GET /cajas/:id busca solo dentro de la empresa', async () => {
    const { service, prisma } = crear();
    await expect(service.findOne('caja-ajena', 'emp-1')).rejects.toBeInstanceOf(NotFoundException);
    expect(prisma.cajas.findFirst.mock.calls[0][0].where).toEqual({
      id: 'caja-ajena',
      OR: [{ empresa_id: 'emp-1' }, { empresas_sucursales: { empresa_id: 'emp-1' } }],
    });
  });

  it('GET /cajas?sucursal_id filtra por la empresa de la sucursal', async () => {
    const { service, prisma } = crear();
    await service.findAllBySucursal('suc-ajena', 'emp-1');
    expect(prisma.cajas.findMany.mock.calls[0][0].where).toEqual({
      sucursal_id: 'suc-ajena',
      empresas_sucursales: { empresa_id: 'emp-1' },
    });
  });

  it('sin empresa en el token no devuelve ni modifica cajas', async () => {
    const { service, prisma } = crear();
    await expect(service.findOne('c', undefined)).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.findAllBySucursal('s', undefined)).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.toggleStatus('c', undefined, 'u')).rejects.toBeInstanceOf(NotFoundException);
    expect(prisma.cajas.findFirst).not.toHaveBeenCalled();
  });

  it('crear, editar, activar/desactivar y borrar piden editar sucursales', () => {
    const p = CajasController.prototype;
    for (const m of ['create', 'update', 'toggleStatus', 'remove']) {
      expect(permisoDe(p, m)).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_SUC_SUCURSAL_EDITAR' });
    }
  });
});
