import { ConflictException } from '@nestjs/common';
import { MobileCajaService } from './mobile-caja.service';

// Caja mobile (spec 2026-10-18-rendiciones, Task 5): recibos disponibles sigue siendo un
// array (la app hace `recibos.map`) y `rendir` crea y envía en una sola transacción con el
// día de Asunción.

const crear = (over: { create?: jest.Mock; recibos?: any[] } = {}) => {
  const rendiciones: any = {
    getRecibosDisponibles: jest.fn().mockResolvedValue(over.recibos ?? []),
    create: over.create ?? jest.fn().mockResolvedValue({ id: 'ren-1', estado: 'PENDIENTE' }),
    enviarATesoreria: jest.fn(),
    findOne: jest.fn(),
  };
  const vendedores: any = {
    findCobradorVinculado: jest.fn().mockResolvedValue({ id: 'cob-1' }),
    diagnosticarVinculoCobrador: jest.fn(),
  };
  return { service: new MobileCajaService({} as any, rendiciones, vendedores, {} as any), rendiciones };
};

describe('MobileCajaService.recibosDisponibles', () => {
  it('mobile recibosDisponibles sigue devolviendo un array', async () => {
    const recibo = { id: 'r-1', desglose: { efectivo: 1000, cheque: 0, transferencia: 0, tarjeta: 0, total: 1000 } };
    const { service, rendiciones } = crear({ recibos: [recibo] });
    const r = await service.recibosDisponibles('emp-1', 'u-1', '2026-10-05', 'm-pyg');
    expect(Array.isArray(r)).toBe(true);
    expect(r).toEqual([recibo]);
    expect(rendiciones.getRecibosDisponibles).toHaveBeenCalledWith('emp-1', 'cob-1', '2026-10-05', 'm-pyg');
  });
});

describe('MobileCajaService.rendir', () => {
  afterEach(() => jest.useRealTimers());

  it('rendir: crea y envía en un solo create({ enviar: true }); no encadena enviarATesoreria', async () => {
    const { service, rendiciones } = crear();
    const r = await service.rendir('emp-1', 'u-1', {
      moneda_id: 'm-pyg',
      recibo_ids: ['r-1'],
      total_declarado: 90000,
      observaciones: 'Faltan 10.000',
    });
    expect(rendiciones.create).toHaveBeenCalledTimes(1);
    expect(rendiciones.create).toHaveBeenCalledWith(
      'emp-1',
      'u-1',
      expect.objectContaining({
        cobrador_id: 'cob-1',
        moneda_id: 'm-pyg',
        recibo_ids: ['r-1'],
        total_declarado: 90000,
        observaciones_cobrador: 'Faltan 10.000',
      }),
      { enviar: true },
    );
    expect(rendiciones.enviarATesoreria).not.toHaveBeenCalled();
    expect(r).toEqual({ id: 'ren-1', estado: 'PENDIENTE' });
  });

  it('rendir: si falla el envío propaga el error y no hace nada más', async () => {
    const error = new ConflictException(
      'La rendición cambió de estado mientras tanto (ahora: ANULADO). Recargá la pantalla.',
    );
    const { service, rendiciones } = crear({ create: jest.fn().mockRejectedValue(error) });
    await expect(service.rendir('emp-1', 'u-1', { moneda_id: 'm-pyg' })).rejects.toBe(error);
    expect(rendiciones.enviarATesoreria).not.toHaveBeenCalled();
    expect(rendiciones.findOne).not.toHaveBeenCalled();
  });

  it('rendir a las 23:30 del 05/10 en Asunción usa fecha_cobranza 2026-10-05', async () => {
    jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate'] });
    jest.setSystemTime(new Date('2026-10-06T02:30:00Z'));
    const { service, rendiciones } = crear();
    await service.rendir('emp-1', 'u-1', { moneda_id: 'm-pyg' });
    expect(rendiciones.create.mock.calls[0][2].fecha_cobranza).toBe('2026-10-05');
  });
});


describe('MobileCajaService', () => {
  it('cerrar / iniciarCierre / cancelarCierre delegan en Tesorería con los mismos argumentos', async () => {
    const tes: any = {
      cerrarCaja: jest.fn().mockResolvedValue('c'),
      iniciarCierre: jest.fn().mockResolvedValue('i'),
      cancelarCierre: jest.fn().mockResolvedValue('x'),
    };
    const s = new MobileCajaService(tes, {} as any, {} as any, {} as any);
    const dto: any = { monto_contado: 10 };
    expect(await s.cerrar('s1', dto, 'e', 'u')).toBe('c');
    expect(tes.cerrarCaja).toHaveBeenCalledWith('s1', dto, 'e', 'u');
    expect(await s.iniciarCierre('s1', 'e', 'u')).toBe('i');
    expect(tes.iniciarCierre).toHaveBeenCalledWith('s1', 'e', 'u');
    expect(await s.cancelarCierre('s1', 'e', 'u', 'tok')).toBe('x');
    expect(tes.cancelarCierre).toHaveBeenCalledWith('s1', 'e', 'u', 'tok');
  });

  it('disponibles pide a Tesorería las cajas del usuario (misma regla que abrir)', () => {
    const tes: any = { getCajasDisponibles: jest.fn().mockReturnValue('cajas') };
    const s = new MobileCajaService(tes, {} as any, {} as any, {} as any);
    expect(s.disponibles('e', 'u')).toBe('cajas');
    expect(tes.getCajasDisponibles).toHaveBeenCalledWith('e', 'u');
  });

  describe('actual', () => {
    const sesion = { id: 's1', caja_id: 'c1', sucursal_id: 'suc1', cajas: { id: 'c1' } };
    const armar = (ses: any, caja: any, dep: any = { id: 'dep1' }) => {
      const tes: any = { getSesionActiva: jest.fn().mockResolvedValue(ses) };
      const prisma: any = {
        cajas: { findUnique: jest.fn().mockResolvedValue(caja) },
        depositos: { findFirst: jest.fn().mockResolvedValue(dep) },
      };
      return { s: new MobileCajaService(tes, {} as any, {} as any, prisma), tes, prisma };
    };
    it('sin sesión propia → null', async () => {
      expect(await armar(null, null).s.actual('e', 'u')).toBeNull();
    });
    it('agrega caja{nombre,pos_config}, punto_expedicion y sucursal_id', async () => {
      const { s } = armar(sesion, {
        descripcion: 'Caja 1',
        pos_config: { permitir_venta_credito: true, print_mobile_enabled: null, precio_bajo_minimo: null },
        puntos_expedicion: [
          { id: 'p2', punto_expedicion: '002', descripcion: 'B', es_default: false },
          { id: 'p1', punto_expedicion: '001', descripcion: 'A', es_default: true },
        ],
      });
      expect(await s.actual('e', 'u')).toMatchObject({
        id: 's1',
        sucursal_id: 'suc1',
        deposito_id: 'dep1',
        caja: {
          nombre: 'Caja 1',
          pos_config: { permitir_venta_credito: true, print_mobile_enabled: false, precio_bajo_minimo: 'autorizacion' },
        },
        punto_expedicion: { id: 'p1', punto_expedicion: '001', descripcion: 'A' },
      });
    });
    it('deposito_id: el principal activo de la sucursal de la caja; null si no hay', async () => {
      const caja = { descripcion: 'C', pos_config: null, puntos_expedicion: [] };
      const { s, prisma } = armar(sesion, caja);
      expect(await s.actual('e', 'u')).toMatchObject({ deposito_id: 'dep1' });
      expect(prisma.depositos.findFirst).toHaveBeenCalledWith({
        where: { sucursal_id: 'suc1', empresa_id: 'e', es_principal: true, active: true },
      });
      expect(await armar(sesion, caja, null).s.actual('e', 'u')).toMatchObject({ deposito_id: null });
    });
    it('caja sin pos_config ni punto → defaults seguros', async () => {
      const { s } = armar(sesion, { descripcion: 'C', pos_config: null, puntos_expedicion: [] });
      expect(await s.actual('e', 'u')).toMatchObject({
        caja: { pos_config: { permitir_venta_credito: false, print_mobile_enabled: false, precio_bajo_minimo: 'autorizacion' } },
        punto_expedicion: null,
      });
    });
  });
});
