import { ConflictException, ForbiddenException } from '@nestjs/common';
import { TesoreriaService } from './tesoreria.service';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { aplicarReversionesPendientes, CATEGORIA_DEPOSITO_ANULADO } from './caja-sesion';
import { AnularDepositoCajaDto, CorregirAperturaDto } from './dto/operaciones-caja.dto';

/**
 * Anular un depósito a banco hecho desde la caja (C17): PIN de supervisor
 * (operación anular_deposito), motivo, reversión de los dos lados en una
 * transacción, asiento de reversión por la integración y auditoría.
 */

type Opts = {
  sesion?: Record<string, unknown>;
  sesionActual?: Record<string, unknown> | null;
  movTes?: Record<string, unknown> | null;
  estadoEnTx?: string;
  conciliado?: boolean;
  conciliadoEnTx?: boolean;
  periodo?: Record<string, unknown> | null;
  token?: Record<string, unknown>;
  revertirFalla?: Error;
  autorizacionUsada?: boolean;
  /** Cajas asignadas una por una al usuario (caja compartida). */
  asignadas?: string[];
};

const SESION_ABIERTA = {
  id: 'ses-1',
  caja_id: 'caja-1',
  user_id: 'u-1',
  estado: 'ABIERTA',
  bloqueado: false,
  cajas: { descripcion: 'Caja 1' },
};

function crearServicio(opts: Opts = {}) {
  const sesion = { ...SESION_ABIERTA, ...opts.sesion };
  const movCaja = {
    id: 'dep-1',
    monto: 300000,
    descripcion: 'Depósito a banco: Banco X | Boleta 77',
    comprobante_referencia: '77',
    categoria: 'DEPOSITO_BANCO',
    fecha_mov: new Date('2026-10-25T12:00:00Z'),
    sesiones_caja: sesion,
  };
  const movTes =
    opts.movTes === null
      ? null
      : {
          id: 'tes-1',
          cuenta_id: 'cta-1',
          origen_id: 'dep-1',
          monto: 300000,
          estado: 'CONFIRMADO',
          motivo_anulacion: null,
          anulado_en: null,
          cuenta: { id: 'cta-1', nombre: 'Banco X' },
          ...opts.movTes,
        };

  const tx: any = {
    $queryRaw: jest.fn().mockResolvedValue([]),
    tes_movimientos: {
      findUnique: jest.fn().mockResolvedValue({ estado: opts.estadoEnTx ?? 'CONFIRMADO' }),
      update: jest.fn(({ data }: any) => Promise.resolve(data)),
    },
    tes_extracto_lineas: { findFirst: jest.fn().mockResolvedValue(opts.conciliadoEnTx ? { id: 'l-1' } : null) },
    tes_cuentas: { update: jest.fn() },
    sesiones_caja: {
      findUnique: jest.fn().mockResolvedValue(sesion),
      findFirst: jest.fn().mockResolvedValue(opts.sesionActual ?? null),
      update: jest.fn(),
    },
    tipo_movimiento_cajas: { findFirst: jest.fn().mockResolvedValue({ id: 'tipo-entrada' }) },
    movimiento_cajas: { create: jest.fn(({ data }: any) => Promise.resolve({ id: 'mov-anul', ...data })) },
    caja_reversiones_pendientes: { create: jest.fn() },
    audit_logs: { create: jest.fn().mockResolvedValue({}) },
    autorizaciones_caja: {
      updateMany: jest.fn().mockResolvedValue({ count: opts.autorizacionUsada ? 0 : 1 }),
    },
  };

  const service: any = Object.create(TesoreriaService.prototype);
  service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
  service.auditService = { log: jest.fn().mockResolvedValue(undefined) };
  service.contabilidad = {
    revertirDocumento: opts.revertirFalla
      ? jest.fn().mockRejectedValue(opts.revertirFalla)
      : jest.fn().mockResolvedValue(undefined),
  };
  service.cajasAccesibles = jest.fn().mockResolvedValue([{ id: 'caja-1' }]);
  service.jwtService = {
    verifyAsync: jest.fn(() =>
      Promise.resolve({
      tipo: 'autorizacion_caja',
      empresa_id: 'emp-1',
      sub: 'sup-1',
      operacion: 'anular_deposito',
      contexto: { movimiento_caja_id: 'dep-1' },
      autorizacion_id: 'aut-1',
      ...opts.token,
      }),
    ),
  };
  service.prisma = {
    movimiento_cajas: {
      findFirst: jest.fn().mockResolvedValue(movCaja),
      findMany: jest.fn().mockResolvedValue([movCaja]),
    },
    tes_movimientos: {
      findFirst: jest.fn().mockResolvedValue(movTes),
      findMany: jest.fn().mockResolvedValue(movTes ? [movTes] : []),
    },
    tes_extracto_lineas: { findFirst: jest.fn().mockResolvedValue(opts.conciliado ? { id: 'l-1' } : null) },
    cont_documentos: {
      findFirst: jest.fn().mockResolvedValue(opts.periodo ? { asiento: { periodo_id: 'per-1' } } : null),
    },
    cont_periodos: { findUnique: jest.fn().mockResolvedValue(opts.periodo ?? null) },
    sesiones_caja: { findFirst: jest.fn().mockResolvedValue(sesion) },
    asignacion_sucursal_caja_usuario: {
      findFirst: jest.fn(async ({ where }: any) => ((opts.asignadas ?? []).includes(where.caja_id) ? { id: 'asig' } : null)),
    },
    autorizaciones_caja: { findFirst: jest.fn().mockResolvedValue(null) },
    $transaction: jest.fn((fn: any) => fn(tx)),
  };
  return { service, tx };
}

const DTO = { motivo: 'Cuenta equivocada', token_autorizacion: 'tok' };

describe('Anular depósito a banco desde la caja', () => {
  it('con la sesión abierta: anula el ingreso, baja el saldo y devuelve el efectivo a la misma sesión', async () => {
    const { service, tx } = crearServicio();
    const r = await service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1');

    expect(r.data.efecto).toBe('MISMA_SESION');
    expect(tx.$queryRaw).toHaveBeenCalled(); // lock del ingreso
    expect(tx.tes_movimientos.update).toHaveBeenCalledWith(
      expect.objectContaining({
        where: { id: 'tes-1' },
        data: expect.objectContaining({ estado: 'ANULADO', anulado_por: 'u-1' }),
      }),
    );
    expect(tx.tes_cuentas.update).toHaveBeenCalledWith({
      where: { id: 'cta-1' },
      data: { saldo_actual: { decrement: 300000 } },
    });
    expect(tx.sesiones_caja.update).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'ses-1' }, data: expect.objectContaining({ monto_entradas_manual: { increment: 300000 } }) }),
    );
    const entrada = tx.movimiento_cajas.create.mock.calls[0][0].data;
    expect(entrada).toMatchObject({ sesion_id: 'ses-1', categoria: CATEGORIA_DEPOSITO_ANULADO, referencia: 'dep-1', monto: 300000 });
    expect(entrada.descripcion).toContain('Cuenta equivocada');
    // Asiento de reversión por la integración existente, sobre el ingreso.
    expect(service.contabilidad.revertirDocumento).toHaveBeenCalledWith('tes_movimientos', 'tes-1', 'u-1');
    expect(service.auditService.log).toHaveBeenCalledWith(
      expect.objectContaining({
        action: 'ANULAR',
        entity_type: 'deposito_banco_caja',
        entity_id: 'dep-1',
        new_value: expect.objectContaining({ motivo: 'Cuenta equivocada', autorizado_por: 'sup-1', efecto_caja: 'MISMA_SESION' }),
      }),
    );
    expect(r.aviso_contable).toBeNull();
    expect(r.message).toContain('volvió a «Caja 1»');
  });

  it('con la sesión cerrada y la caja abierta de nuevo: la entrada va a la sesión abierta (el arqueo cerrado no se toca)', async () => {
    const { service, tx } = crearServicio({
      sesion: { estado: 'CERRADA' },
      sesionActual: { id: 'ses-2', bloqueado: false },
    });
    const r = await service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1');
    expect(r.data.efecto).toBe('SESION_ACTUAL');
    expect(tx.movimiento_cajas.create.mock.calls[0][0].data.sesion_id).toBe('ses-2');
    expect(tx.sesiones_caja.update.mock.calls[0][0].where).toEqual({ id: 'ses-2' });
    expect(tx.caja_reversiones_pendientes.create).not.toHaveBeenCalled();
  });

  it('con la caja cerrada: queda pendiente y entra al cajón en la próxima apertura', async () => {
    const { service, tx } = crearServicio({ sesion: { estado: 'CERRADA' }, sesionActual: null });
    const r = await service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1');
    expect(r.data.efecto).toBe('PENDIENTE_APERTURA');
    expect(tx.movimiento_cajas.create).not.toHaveBeenCalled();
    expect(tx.caja_reversiones_pendientes.create).toHaveBeenCalledWith({
      data: expect.objectContaining({ origen: 'DEPOSITO_BANCO', referencia_id: 'dep-1', caja_id: 'caja-1', monto: 300000 }),
    });
    expect(r.message).toContain('cuando se abra');
  });

  it('al abrir, el pendiente de un depósito anulado ENTRA al cajón (no sale)', async () => {
    const tx: any = {
      caja_reversiones_pendientes: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'p-1', origen: 'DEPOSITO_BANCO', referencia_id: 'dep-1', monto: 300000, medio_pago_codigo: 1, descripcion: 'Anulación depósito a banco' },
        ]),
        update: jest.fn(),
      },
      tipo_movimiento_cajas: { findFirst: jest.fn().mockResolvedValue({ id: 'tipo' }) },
      sesiones_caja: { update: jest.fn() },
      movimiento_cajas: { create: jest.fn() },
    };
    const aplicadas = await aplicarReversionesPendientes(tx, { cajaId: 'caja-1', sesionId: 'ses-9', empresaId: 'emp-1', usuarioId: 'u-1' });
    expect(aplicadas).toEqual([expect.objectContaining({ monto: 300000, sale_del_cajon: false, entra_al_cajon: true })]);
    expect(tx.sesiones_caja.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ monto_entradas_manual: { increment: 300000 } }) }),
    );
    expect(tx.movimiento_cajas.create.mock.calls[0][0].data).toMatchObject({ categoria: CATEGORIA_DEPOSITO_ANULADO, sesion_id: 'ses-9' });
    expect(tx.caja_reversiones_pendientes.update).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'p-1' }, data: expect.objectContaining({ sesion_aplicada_id: 'ses-9' }) }),
    );
  });

  it('el motivo no puede ser solo espacios (E2E: quedaba vacío en la auditoría)', async () => {
    const vacio = await validate(plainToInstance(AnularDepositoCajaDto, { motivo: '   ', token_autorizacion: 't' }));
    expect(vacio.map((e) => e.property)).toContain('motivo');
    const ok = await validate(plainToInstance(AnularDepositoCajaDto, { motivo: 'Cuenta equivocada', token_autorizacion: 't' }));
    expect(ok).toHaveLength(0);
  });

  it('corregir apertura tampoco acepta un motivo de solo espacios', async () => {
    const vacio = await validate(plainToInstance(CorregirAperturaDto, { monto_apertura: 1, motivo: '  ', token_autorizacion: 't' }));
    expect(vacio.map((e) => e.property)).toContain('motivo');
  });

  it('el mensaje de «ya anulado» muestra el motivo sin repetir el prefijo de Tesorería (E2E)', async () => {
    const { service } = crearServicio({
      movTes: { estado: 'ANULADO', motivo_anulacion: 'Depósito anulado desde la caja: Boleta repetida' },
    });
    await expect(service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(
      'Este depósito ya fue anulado (motivo: «Boleta repetida»): no se puede anular dos veces.',
    );
  });

  it('la autorización se consume en la transacción; un token ya usado da 403 y no anula nada', async () => {
    const ok = crearServicio();
    await ok.service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1');
    expect(ok.tx.autorizaciones_caja.updateMany).toHaveBeenCalledWith({
      where: { id: 'aut-1', empresa_id: 'emp-1', estado: 'aprobada' },
      data: { estado: 'utilizada' },
    });

    const usada = crearServicio({ autorizacionUsada: true });
    await expect(usada.service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/Esta autorización ya se usó/);
    expect(usada.tx.tes_movimientos.update).not.toHaveBeenCalled();
    expect(usada.tx.movimiento_cajas.create).not.toHaveBeenCalled();
  });

  it('no se anula dos veces', async () => {
    const { service } = crearServicio({ movTes: { estado: 'ANULADO', motivo_anulacion: 'x' } });
    await expect(service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/no se puede anular dos veces/);
    expect(service.prisma.$transaction).not.toHaveBeenCalled();
  });

  it('dos anulaciones a la vez: la segunda ve el ingreso ya anulado dentro de la transacción', async () => {
    const { service, tx } = crearServicio({ estadoEnTx: 'ANULADO' });
    await expect(service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/ya fue anulado/);
    expect(tx.tes_movimientos.update).not.toHaveBeenCalled();
  });

  it('no se anula si el ingreso ya está conciliado: dice dónde desconciliar', async () => {
    const { service } = crearServicio({ conciliado: true });
    const p = service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1');
    await expect(p).rejects.toThrow(ConflictException);
    await expect(service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/Tesorería › Conciliación/);
    expect(service.prisma.$transaction).not.toHaveBeenCalled();
  });

  it('no se anula si el asiento del depósito está en un período cerrado (antes de mover plata)', async () => {
    const { service } = crearServicio({ periodo: { estado: 'CERRADO', mes: 9, anio: 2026 } });
    await expect(service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/09\/2026.*Contabilidad › Ejercicios/);
    expect(service.prisma.$transaction).not.toHaveBeenCalled();
  });

  it('el PIN tiene que ser de anular_deposito y para ESE depósito', async () => {
    const otraOperacion = crearServicio({ token: { operacion: 'corregir_apertura' } });
    await expect(otraOperacion.service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(ForbiddenException);

    const otroDeposito = crearServicio({ token: { contexto: { movimiento_caja_id: 'dep-2' } } });
    await expect(otroDeposito.service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/otro depósito/);
    expect(otroDeposito.service.prisma.$transaction).not.toHaveBeenCalled();
  });

  it('una caja EN CIERRE no recibe la entrada: se termina o cancela el cierre primero', async () => {
    const { service } = crearServicio({ sesion: { bloqueado: true } });
    await expect(service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/EN CIERRE/);
  });

  it('si el asiento de reversión falla, la anulación queda y se avisa dónde revisarlo', async () => {
    const { service } = crearServicio({ revertirFalla: new Error('período sin abrir') });
    const r = await service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1');
    expect(r.aviso_contable).toMatch(/período sin abrir.*Contabilidad › Conciliación/);
  });

  it('caja que abrió otro usuario, aunque tenga acceso a toda la sucursal: 403 antes de mirar el PIN', async () => {
    const { service } = crearServicio({ sesion: { user_id: 'otro' } });
    await expect(service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1')).rejects.toThrow(/no podés mover plata en la caja de otro usuario/);
    expect(service.jwtService.verifyAsync).not.toHaveBeenCalled();
  });

  it('caja compartida (asignada específicamente): anula y deja auditado el uso', async () => {
    const { service, tx } = crearServicio({ sesion: { user_id: 'otro' }, asignadas: ['caja-1'] });
    await service.anularDeposito('dep-1', DTO, 'emp-1', 'u-1');
    expect(tx.audit_logs.create).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({ entity_type: 'uso_caja_compartida', entity_id: 'dep-1', user_id: 'u-1' }),
      }),
    );
  });

  it('el listado de depósitos de la caja dice si se puede anular y por qué no', async () => {
    const ok = crearServicio();
    const r = await ok.service.getDepositosCaja('caja-1', 'emp-1', 'u-1');
    expect(ok.service.prisma.movimiento_cajas.findMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: expect.objectContaining({ categoria: 'DEPOSITO_BANCO', sesiones_caja: { caja_id: 'caja-1' } }) }),
    );
    expect(r.items[0]).toMatchObject({ id: 'dep-1', anulable: true, motivo_no_anulable: null, anulado: false, boleta: '77' });

    const anulado = crearServicio({ movTes: { estado: 'ANULADO' } });
    const r2 = await anulado.service.getDepositosCaja('caja-1', 'emp-1', 'u-1');
    expect(r2.items[0]).toMatchObject({ anulado: true, anulable: false });
    expect(r2.items[0].motivo_no_anulable).toMatch(/dos veces/);

    const ajena = crearServicio();
    await expect(ajena.service.getDepositosCaja('caja-otra', 'emp-1', 'u-1')).rejects.toThrow(ForbiddenException);
  });
});
