import { ConflictException, NotFoundException } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { CajasService } from '../cajas/cajas.service';
import { tieneAlgunPrivilegio } from '../auth/guards/algun-privilegio.guard';
import { UpdatePosConfigDto } from './dto/update-pos-config.dto';
import { PosConfigService, controlesQueCambian, datosCreacionPosConfig } from './pos-config.service';
import { validate } from 'class-validator';

describe('P2 / C1 — la fila nueva usa los defaults únicos', () => {
  it('el primer guardado desde el retail no prende el PIN', () => {
    const datos = datosCreacionPosConfig('caja-1', { tipo_pos: 'retail', layout: 'list' });
    expect(datos).toMatchObject({
      caja_id: 'caja-1',
      tipo_pos: 'retail',
      layout: 'list',
      requiere_autorizacion_apertura: false,
      requiere_autorizacion_cierre: false,
      requiere_arqueo_cierre: true,
      diferencia_arqueo_permitida: null,
    });
    expect(datos).not.toHaveProperty('montos_rapidos');
  });
});

describe('C2 — DTO de la tolerancia', () => {
  it('vacío queda null (sin control) y 0 queda 0', () => {
    expect(plainToInstance(UpdatePosConfigDto, { diferencia_arqueo_permitida: '' }).diferencia_arqueo_permitida).toBeNull();
    expect(plainToInstance(UpdatePosConfigDto, { diferencia_arqueo_permitida: 0 }).diferencia_arqueo_permitida).toBe(0);
    expect(plainToInstance(UpdatePosConfigDto, {}).diferencia_arqueo_permitida).toBeUndefined();
  });
});

describe('H9 — pos-config valida la empresa de la caja', () => {
  const crear = (caja: unknown) => {
    const service = Object.create(PosConfigService.prototype) as any;
    service.logger = { log: jest.fn() };
    service.auditService = { log: jest.fn() };
    service.prisma = {
      cajas: { findFirst: jest.fn().mockResolvedValue(caja) },
      pos_config: { findUnique: jest.fn().mockResolvedValue(null), upsert: jest.fn().mockResolvedValue({ id: 'cfg' }) },
    };
    return service;
  };

  it('caja de otra empresa: 404 y no se lee ni se escribe', async () => {
    const service = crear(null);
    await expect(service.findByCaja('caja-x', 'emp-1')).rejects.toBeInstanceOf(NotFoundException);
    await expect(service.update('caja-x', {}, 'emp-1')).rejects.toBeInstanceOf(NotFoundException);
    expect(service.prisma.pos_config.upsert).not.toHaveBeenCalled();
    expect(service.prisma.cajas.findFirst.mock.calls[0][0].where.OR).toEqual([
      { empresa_id: 'emp-1' },
      { empresas_sucursales: { empresa_id: 'emp-1' } },
    ]);
  });

  it('sin fila devuelve los defaults', async () => {
    const service = crear({ id: 'caja-1', descripcion: 'Caja 1' });
    expect(await service.findByCaja('caja-1', 'emp-1')).toMatchObject({ id: null, tipo_pos: 'admin', requiere_arqueo_cierre: true });
  });

  it('el upsert crea con defaults + cambios', async () => {
    const service = crear({ id: 'caja-1', descripcion: 'Caja 1' });
    await service.update('caja-1', { tipo_pos: 'retail' }, 'emp-1');
    expect(service.prisma.pos_config.upsert.mock.calls[0][0].create).toMatchObject({
      tipo_pos: 'retail',
      requiere_autorizacion_cierre: false,
    });
  });
});

describe('U2 / U3 / C1 — cajas', () => {
  const crear = (over: Record<string, any> = {}) => {
    const service = Object.create(CajasService.prototype) as any;
    service.logger = { log: jest.fn() };
    service.auditService = { log: jest.fn() };
    const tx = {
      cajas: { create: jest.fn().mockResolvedValue({ id: 'nueva', descripcion: 'Caja 2', sucursal_id: 'suc' }) },
      pos_config: { create: jest.fn() },
    };
    service.tx = tx;
    service.prisma = {
      empresas_sucursales: { findFirst: jest.fn().mockResolvedValue({ id: 'suc', descripcion: 'Centro' }) },
      cajas: { findFirst: jest.fn().mockResolvedValue(null), update: jest.fn() },
      sesiones_caja: { findFirst: jest.fn().mockResolvedValue(null) },
      $transaction: jest.fn(async (fn: any) => fn(tx)),
      ...over,
    };
    return service;
  };

  it('U2: nombre repetido en la sucursal → 409', async () => {
    const service = crear();
    service.prisma.cajas.findFirst.mockResolvedValue({ id: 'otra' });
    await expect(
      service.create({ sucursal_id: 'suc', empresa_id: 'x', descripcion: 'caja 1' }, 'u', 'emp-1'),
    ).rejects.toBeInstanceOf(ConflictException);
  });

  it('U2: la sucursal tiene que ser de la empresa del token', async () => {
    const service = crear();
    service.prisma.empresas_sucursales.findFirst.mockResolvedValue(null);
    await expect(service.create({ sucursal_id: 'suc', empresa_id: 'otra', descripcion: 'X' }, 'u', 'emp-1')).rejects.toBeInstanceOf(
      NotFoundException,
    );
    expect(service.prisma.empresas_sucursales.findFirst).toHaveBeenCalledWith({ where: { id: 'suc', empresa_id: 'emp-1' } });
  });

  it('C1: la caja nueva nace con su configuración (arqueo sí, PIN no)', async () => {
    const service = crear();
    await service.create({ sucursal_id: 'suc', empresa_id: 'x', descripcion: 'Caja 2' }, 'u', 'emp-1');
    expect(service.tx.pos_config.create).toHaveBeenCalledWith({
      data: expect.objectContaining({ caja_id: 'nueva', requiere_arqueo_cierre: true, requiere_autorizacion_cierre: false }),
    });
  });

  it('U3: no se desactiva una caja con sesión abierta', async () => {
    const service = crear();
    service.prisma.cajas.findFirst.mockResolvedValue({ id: 'c', estado: true, descripcion: 'Caja 1' });
    service.prisma.sesiones_caja.findFirst.mockResolvedValue({ usuario: { nombres: 'Ana' } });
    await expect(service.toggleStatus('c', 'emp-1', 'u')).rejects.toThrow(/la abrió Ana/);
    expect(service.prisma.cajas.update).not.toHaveBeenCalled();
  });
});

describe('AlgunPrivilegioGuard', () => {
  it('pasa con cualquiera de los privilegios; superadmin siempre', async () => {
    const prisma: any = {
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
      perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue({ id: 'pp' }) },
    };
    expect(await tieneAlgunPrivilegio(prisma, 'u', ['A', 'B'])).toBe(true);
    expect(prisma.perfiles_privilegios.findFirst.mock.calls[0][0].where.privilegios).toEqual({ codigo: { in: ['A', 'B'] } });
    prisma.perfiles_privilegios.findFirst.mockResolvedValue(null);
    expect(await tieneAlgunPrivilegio(prisma, 'u', ['A'])).toBe(false);
    prisma.usuario.findUnique.mockResolvedValue({ is_superadmin: true });
    expect(await tieneAlgunPrivilegio(prisma, 'u', ['A'])).toBe(true);
  });
});

describe('E2E 2026-10-25 — los controles de la caja solo con ADM_POSCFG_EDITAR', () => {
  const crear = (vigente: Record<string, unknown> | null, esAdminPos: boolean) => {
    const service = Object.create(PosConfigService.prototype) as any;
    service.logger = { log: jest.fn() };
    service.auditService = { log: jest.fn() };
    service.prisma = {
      cajas: { findFirst: jest.fn().mockResolvedValue({ id: 'caja-1', descripcion: 'Caja 1' }) },
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
      perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(esAdminPos ? { id: 'pp' } : null) },
      pos_config: { findUnique: jest.fn().mockResolvedValue(vigente), upsert: jest.fn().mockResolvedValue({ id: 'cfg' }) },
    };
    return service;
  };

  it('el cajero (solo VEN_POS_POS_CONFIGURAR) no puede apagar el PIN ni la tolerancia', async () => {
    const service = crear({ requiere_autorizacion_cierre: true, diferencia_arqueo_permitida: '0' }, false);
    await expect(
      service.update('caja-1', { requiere_autorizacion_cierre: false, diferencia_arqueo_permitida: null }, 'emp-1', 'cajero'),
    ).rejects.toThrow(/ADM_POSCFG_EDITAR/);
    expect(service.prisma.pos_config.upsert).not.toHaveBeenCalled();
  });

  it('el cajero sí guarda la impresora, y reenviar el mismo valor de un control no cuenta como cambio', async () => {
    const service = crear({ requiere_autorizacion_cierre: true, diferencia_arqueo_permitida: '0' }, false);
    await service.update(
      'caja-1',
      { printer_name: 'EPSON', requiere_autorizacion_cierre: true, diferencia_arqueo_permitida: 0 },
      'emp-1',
      'cajero',
    );
    expect(service.prisma.pos_config.upsert).toHaveBeenCalled();
  });

  it('caja sin fila: compara contra los defaults (prender el PIN es un cambio)', async () => {
    const service = crear(null, false);
    await expect(service.update('caja-1', { requiere_autorizacion_cierre: true }, 'emp-1', 'cajero')).rejects.toThrow(
      /requiere_autorizacion_cierre/,
    );
  });

  it('con ADM_POSCFG_EDITAR cambia los controles', async () => {
    const service = crear({ requiere_autorizacion_cierre: true }, true);
    await service.update('caja-1', { requiere_autorizacion_cierre: false }, 'emp-1', 'admin');
    expect(service.prisma.pos_config.upsert).toHaveBeenCalled();
  });
});

describe('DOBA 2026-10-27 — caja compartida y precio bajo el mínimo son controles de la caja', () => {
  it('cambiarlos pide ADM_POSCFG_EDITAR; mandar el mismo valor no', () => {
    const actual = { caja_compartida: false, precio_bajo_minimo: 'autorizacion' };
    expect(controlesQueCambian(actual, { caja_compartida: true, precio_bajo_minimo: 'aviso' })).toEqual([
      'caja_compartida',
      'precio_bajo_minimo',
    ]);
    // El texto no se compara como número (NaN !== NaN lo marcaba siempre como cambio).
    expect(controlesQueCambian(actual, { caja_compartida: false, precio_bajo_minimo: 'autorizacion' })).toEqual([]);
  });

  it('precio_bajo_minimo solo acepta «autorizacion» o «aviso»', async () => {
    const errores = async (v: unknown) => validate(plainToInstance(UpdatePosConfigDto, { precio_bajo_minimo: v }));
    expect(await errores('aviso')).toHaveLength(0);
    expect(await errores('autorizacion')).toHaveLength(0);
    expect(await errores('libre')).toHaveLength(1);
  });
});
