/**
 * Marcar declarada (PATCH /retenciones/:id/declarar, COB_RET_RETENCION_EDITAR):
 *  - `periodo` que no es AAAA-MM → 400 `PERIODO_INVALIDO` (antes se guardaba cualquier texto).
 *  - Retención de otra empresa o inexistente → 404 `RETENCION_NO_ENCONTRADA`.
 *  - Sucursal del recibo fuera del alcance del usuario → 403 `SUCURSAL_FUERA_DE_ALCANCE` (con alcance restringido, un
 *    recibo sin sucursal tampoco entra: el Libro no lo muestra).
 *  - Recibo anulado → 409 `RECIBO_ANULADO`; en otro estado que no sea emitido → 409 `RECIBO_NO_EMITIDO`.
 *  - `:id` que no es uuid → 400 (ParseUUIDPipe), no 500 por el cast en Postgres.
 *  El alcance se mira antes que el estado: no se cuenta nada de un recibo que el usuario no ve.
 */
import { BadRequestException, ConflictException, ForbiddenException, NotFoundException, ParseUUIDPipe } from '@nestjs/common';
import { ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
import { RecibosService } from './recibos.service';
import { RetencionesController } from './retenciones.controller';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));

const RET = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
const SUC_A = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
const SUC_B = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
const restringido = (sucursalIds: string[]) => ({ sucursalIds, puntosEstablecimiento: [], depositoIds: [] });

function prismaCon(filas: any[], actualizadas = 1) {
  return {
    $queryRaw: jest.fn().mockResolvedValue(filas),
    $executeRaw: jest.fn().mockResolvedValue(actualizadas),
    empresas_sucursales: { findFirst: jest.fn().mockResolvedValue({ id: SUC_A }) },
  };
}
const servicio = (prisma: any) => new RecibosService(prisma, {} as any, {} as any);
const recibo = (over: Partial<{ estado: string; sucursal_id: string | null }> = {}) => [
  { id: RET, estado: 'emitido', sucursal_id: SUC_A, ...over },
];
async function error(p: Promise<unknown>) {
  try {
    await p;
  } catch (e) {
    return e as any;
  }
  throw new Error('no falló');
}

beforeEach(() => {
  (alcanceSucursalUsuario as jest.Mock).mockReset().mockResolvedValue(null);
});

describe('marcarDeclarada', () => {
  it.each(['', '2026-13', '2026-1', '11-2026', '2026-11-01', 'cualquiera'])('periodo %p → 400 PERIODO_INVALIDO sin tocar la base', async (periodo) => {
    const prisma = prismaCon(recibo());
    const e = await error(servicio(prisma).marcarDeclarada('emp', RET, periodo, 'usr'));
    expect(e).toBeInstanceOf(BadRequestException);
    expect(e.getResponse()).toMatchObject({ codigo: 'PERIODO_INVALIDO', campo: 'periodo' });
    expect(prisma.$queryRaw).not.toHaveBeenCalled();
    expect(prisma.$executeRaw).not.toHaveBeenCalled();
  });

  it('retención inexistente o de otra empresa → 404 RETENCION_NO_ENCONTRADA', async () => {
    const prisma = prismaCon([]);
    const e = await error(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr'));
    expect(e).toBeInstanceOf(NotFoundException);
    expect(e.getResponse()).toMatchObject({ codigo: 'RETENCION_NO_ENCONTRADA' });
    expect(prisma.$executeRaw).not.toHaveBeenCalled();
  });

  it('recibo de una sucursal fuera del alcance → 403 SUCURSAL_FUERA_DE_ALCANCE', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_B]));
    const prisma = prismaCon(recibo({ estado: 'anulado' }));
    const e = await error(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr'));
    expect(e).toBeInstanceOf(ForbiddenException);
    expect(e.getResponse()).toMatchObject({ codigo: 'SUCURSAL_FUERA_DE_ALCANCE' });
    expect(alcanceSucursalUsuario).toHaveBeenCalledWith(prisma, 'usr', 'emp');
    expect(prisma.$executeRaw).not.toHaveBeenCalled();
  });

  it('con alcance restringido, un recibo sin sucursal → 403', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon(recibo({ sucursal_id: null }));
    const e = await error(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr'));
    expect(e).toBeInstanceOf(ForbiddenException);
    expect(e.getResponse()).toMatchObject({ codigo: 'SUCURSAL_FUERA_DE_ALCANCE' });
  });

  it('recibo anulado → 409 RECIBO_ANULADO', async () => {
    const prisma = prismaCon(recibo({ estado: 'anulado' }));
    const e = await error(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr'));
    expect(e).toBeInstanceOf(ConflictException);
    expect(e.getResponse()).toMatchObject({ codigo: 'RECIBO_ANULADO' });
    expect(prisma.$executeRaw).not.toHaveBeenCalled();
  });

  it('recibo en otro estado → 409 RECIBO_NO_EMITIDO', async () => {
    const prisma = prismaCon(recibo({ estado: 'borrador' }));
    const e = await error(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr'));
    expect(e).toBeInstanceOf(ConflictException);
    expect(e.getResponse()).toMatchObject({ codigo: 'RECIBO_NO_EMITIDO' });
  });

  it('se anuló entre la lectura y el UPDATE (0 filas) → 409 RECIBO_NO_EMITIDO', async () => {
    const prisma = prismaCon(recibo(), 0);
    const e = await error(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr'));
    expect(e).toBeInstanceOf(ConflictException);
    expect(e.getResponse()).toMatchObject({ codigo: 'RECIBO_NO_EMITIDO' });
  });

  it('emitido y en alcance: guarda el período (UPDATE condicionado a recibo emitido)', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(restringido([SUC_A]));
    const prisma = prismaCon(recibo());
    await expect(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr')).resolves.toEqual({ ok: true });
    const call = prisma.$executeRaw.mock.calls[0];
    expect(call.slice(1)).toEqual(expect.arrayContaining(['2026-11', RET]));
    expect(call[0].join('?')).toMatch(/estado = 'emitido'/);
  });

  it('admin (alcance null): sucursal de la empresa pasa', async () => {
    const prisma = prismaCon(recibo());
    await expect(servicio(prisma).marcarDeclarada('emp', RET, '2026-11', 'usr')).resolves.toEqual({ ok: true });
  });

  it('controller: pasa empresa, id, periodo y user.id', async () => {
    const svc = { marcarDeclarada: jest.fn().mockResolvedValue({ ok: true }) };
    const ctrl = new RetencionesController(svc as any);
    await ctrl.declarar({ id: 'usr', empresa_id: 'emp' } as any, RET, '2026-11');
    expect(svc.marcarDeclarada).toHaveBeenCalledWith('emp', RET, '2026-11', 'usr');
  });

  it(':id con ParseUUIDPipe (400 en vez de 500 con un id que no es uuid)', () => {
    const args = Reflect.getMetadata(ROUTE_ARGS_METADATA, RetencionesController, 'declarar') ?? {};
    const delId = Object.values(args as Record<string, { data?: string; pipes?: unknown[] }>).find((a) => a.data === 'id');
    expect(delId).toBeDefined();
    expect(delId!.pipes).toContain(ParseUUIDPipe);
  });
});
