import { BadRequestException, ConflictException, NotFoundException } from '@nestjs/common';
import { AsignacionesSucursalService } from './asignaciones-sucursal.service';

/**
 * U13: la pantalla recibe una fila por asignación (sin expandir por caja).
 * U15: validaciones al crear (empresa, caja de la sucursal, activas, duplicados)
 * y filtro de empresa en lectura y borrado.
 */
describe('AsignacionesSucursalService', () => {
  const crear = (opts: {
    sucursal?: unknown;
    usuario?: unknown;
    caja?: unknown;
    previas?: Array<{ caja_id: string | null }>;
    asignaciones?: unknown[];
    existente?: unknown;
  } = {}) => {
    const service = Object.create(AsignacionesSucursalService.prototype) as any;
    service.logger = { log: jest.fn() };
    service.auditService = { log: jest.fn() };
    service.prisma = {
      empresas_sucursales: {
        findFirst: jest.fn().mockResolvedValue(
          'sucursal' in opts ? opts.sucursal : { id: 'suc-1', descripcion: 'Matriz', active: true },
        ),
      },
      usuario: { findFirst: jest.fn().mockResolvedValue('usuario' in opts ? opts.usuario : { id: 'usr' }) },
      cajas: {
        findFirst: jest.fn().mockResolvedValue('caja' in opts ? opts.caja : { descripcion: 'Caja 1', estado: true }),
      },
      asignacion_sucursal_caja_usuario: {
        findMany: jest.fn(({ select }) =>
          Promise.resolve(select ? opts.previas ?? [] : opts.asignaciones ?? []),
        ),
        findFirst: jest.fn().mockResolvedValue(opts.existente ?? null),
        create: jest.fn(async ({ data }: any) => ({ id: 'asig-1', ...data })),
        delete: jest.fn(),
      },
    };
    return service;
  };

  const dto = { sucursal_id: 'suc-1', usuario_id: 'usr', caja_id: 'caja-1' };

  it('crea una asignación válida', async () => {
    const service = crear();
    await service.create(dto, 'emp', 'actor');
    expect(service.prisma.empresas_sucursales.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'suc-1', empresa_id: 'emp' } }),
    );
    expect(service.prisma.cajas.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'caja-1', sucursal_id: 'suc-1' } }),
    );
    expect(service.prisma.asignacion_sucursal_caja_usuario.create).toHaveBeenCalled();
  });

  it('sucursal de otra empresa: 400', async () => {
    const service = crear({ sucursal: null });
    await expect(service.create(dto, 'emp')).rejects.toBeInstanceOf(BadRequestException);
  });

  it('caja de otra sucursal o inactiva: 400', async () => {
    await expect(crear({ caja: null }).create(dto, 'emp')).rejects.toThrow('no es de la sucursal');
    await expect(crear({ caja: { descripcion: 'Caja 9', estado: false } }).create(dto, 'emp')).rejects.toThrow(
      'está inactiva',
    );
  });

  it('usuario de otra empresa: 400', async () => {
    await expect(crear({ usuario: null }).create(dto, 'emp')).rejects.toThrow('no es de esta empresa');
  });

  it('duplicada: 409; una caja puntual con «todas las cajas» se permite (caja compartida)', async () => {
    await expect(crear({ previas: [{ caja_id: 'caja-1' }] }).create(dto, 'emp')).rejects.toBeInstanceOf(
      ConflictException,
    );
    const conTodas = crear({ previas: [{ caja_id: null }] });
    await conTodas.create(dto, 'emp');
    expect(conTodas.prisma.asignacion_sucursal_caja_usuario.create).toHaveBeenCalled();
    await expect(
      crear({ previas: [{ caja_id: null }] }).create({ ...dto, caja_id: undefined }, 'emp'),
    ).rejects.toThrow('ya tiene asignadas todas');
  });

  const asignacionTodas = {
    id: 'asig-1',
    sucursal_id: 'suc-1',
    caja_id: null,
    usuario_id: 'usr',
    caja: null,
    sucursal: { id: 'suc-1', descripcion: 'Matriz', cajas: [{ id: 'c1' }, { id: 'c2' }] },
  };

  it('para la pantalla de Asignaciones: una fila por asignación', async () => {
    const service = crear({ asignaciones: [asignacionTodas] });
    const filas = await service.findByUsuario('usr', 'emp');
    expect(filas).toHaveLength(1);
    expect(filas[0]).toMatchObject({ id: 'asig-1', acceso_todas: true, caja: null });
    expect(service.prisma.asignacion_sucursal_caja_usuario.findMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { usuario_id: 'usr', sucursal: { empresa_id: 'emp' } } }),
    );
  });

  it('para /me: expande a una fila por caja activa', async () => {
    const service = crear({ asignaciones: [asignacionTodas] });
    const filas = await service.findByUsuario('usr', 'emp', true);
    expect(filas.map((f: any) => f.caja_id)).toEqual(['c1', 'c2']);
  });

  it('borrar una asignación de otra empresa: 404', async () => {
    const service = crear({ existente: null });
    await expect(service.remove('asig-x', 'emp')).rejects.toBeInstanceOf(NotFoundException);
    expect(service.prisma.asignacion_sucursal_caja_usuario.delete).not.toHaveBeenCalled();
  });
});
