import { ArgumentMetadata, ValidationPipe } from '@nestjs/common';
import { CreateConceptoCostoDto, CreateTasaIscDto, UpdateConceptoCostoDto, UpdateTasaIscDto } from './dto/importaciones.dto';
import { ImportacionesIscService } from './services/importaciones-isc.service';
import { ImportacionesService } from './services/importaciones.service';

jest.mock('src/stock/tipos-movimiento-inventario', () => ({
  tipoMovimientoInventarioId: jest.fn((_tx: unknown, codigo: string) => Promise.resolve(`tipo-${codigo}`)),
}));

const EMPRESA = 'emp-1';
const UPDATED_AT = new Date('2026-10-01T12:00:00.000Z');

const cuerpo = async (promesa: Promise<unknown>) => {
  try {
    await promesa;
  } catch (e: any) {
    return { status: e.getStatus?.(), ...e.getResponse() };
  }
  throw new Error('No lanzó');
};

const dia = (s: string) => new Date(s);
const tasa = (extra: Record<string, any> = {}) => ({
  id: 'isc-1', empresa_id: EMPRESA, anio_desde: 2015, anio_hasta: 2020, cc_desde: 1000, cc_hasta: 1500, tasa_isc_pct: 10,
  descripcion: 'Livianos', vigente_desde: dia('2026-01-01'), vigente_hasta: null, activo: true, updated_at: UPDATED_AT, ...extra,
});
const dtoTasa = (extra: Record<string, any> = {}): any => ({
  anio_desde: 2015, anio_hasta: 2020, cc_desde: 1000, cc_hasta: 1500, tasa_isc_pct: 10, vigente_desde: '2026-01-01', ...extra,
});

function crearTx(opts: { moduloActivo?: boolean; conceptos?: any[]; tasas?: any[]; monedas?: string[] } = {}) {
  const log: string[] = [];
  const conceptos = opts.conceptos ?? [];
  const tasas = opts.tasas ?? [];
  const tx: any = {
    $executeRaw: jest.fn((_s: TemplateStringsArray, ...v: any[]) => {
      log.push(`lock:${String(v[0])}`);
      return Promise.resolve(1);
    }),
    imp_config_empresa: { findUnique: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: opts.moduloActivo ?? true }) },
    imp_conceptos_costo: {
      findFirst: jest.fn((args: any) => {
        const w = args.where;
        if (w.id && typeof w.id === 'string') return Promise.resolve(conceptos.find((c) => c.id === w.id && (w.activo === undefined || c.activo === w.activo)) ?? null);
        return Promise.resolve(conceptos.find((c) => c.codigo === w.codigo && c.id !== w.id?.not) ?? null);
      }),
      create: jest.fn((args: any) => Promise.resolve({ id: 'nuevo', ...args.data })),
      update: jest.fn((args: any) => Promise.resolve({ ...conceptos.find((c) => c.id === args.where.id), ...args.data })),
    },
    imp_isc_vehiculos: {
      findFirst: jest.fn((args: any) => {
        if (args.where.id && typeof args.where.id === 'string') return Promise.resolve(tasas.find((t) => t.id === args.where.id) ?? null);
        return Promise.resolve(tasas.find((t) => t.activo) ?? null); // el filtro real lo afirma el test del where
      }),
      create: jest.fn((args: any) => Promise.resolve({ id: 'nueva', ...args.data })),
      update: jest.fn((args: any) => Promise.resolve({ ...args.data })),
      delete: jest.fn(),
    },
    moneda: { findFirst: jest.fn((args: any) => Promise.resolve((opts.monedas ?? ['PYG', 'USD']).includes(args.where.codigo) ? { id: 'm' } : null)) },
  };
  const prisma: any = { $transaction: jest.fn((cb: any) => cb(tx) as Promise<unknown>), imp_conceptos_costo: { findMany: jest.fn().mockResolvedValue([]) } };
  return { tx, prisma, log };
}

function crearConceptos(opts: Parameters<typeof crearTx>[0] = {}) {
  const base = crearTx(opts);
  const service = new ImportacionesService(base.prisma, {} as any, {} as any, {} as any, {} as any, {} as any, {} as any);
  return { ...base, service };
}

function crearIsc(opts: Parameters<typeof crearTx>[0] = {}) {
  const base = crearTx(opts);
  const importaciones = new ImportacionesService(base.prisma, {} as any, {} as any, {} as any, {} as any, {} as any, {} as any);
  return { ...base, service: new ImportacionesIscService(base.prisma, importaciones) };
}

const concepto = (extra: Record<string, any> = {}) => ({ id: 'con-1', empresa_id: EMPRESA, codigo: 'FLETE_AEREO', nombre: 'Flete aéreo', es_sistema: false, activo: true, updated_at: UPDATED_AT, ...extra });
const dtoConcepto = (extra: Record<string, any> = {}): any => ({ codigo: 'FLETE_AEREO', nombre: 'Flete aéreo', ...extra });

describe('Importaciones - conceptos de costo', () => {
  it('código repetido (de la empresa o de sistema) → CONCEPTO_CODIGO_DUPLICADO 409 con campo codigo', async () => {
    const { service, tx } = crearConceptos({ conceptos: [concepto()] });
    const e = await cuerpo(service.crearConcepto(dtoConcepto({ codigo: ' flete_aereo ' }), EMPRESA));
    expect(e).toMatchObject({ status: 409, codigo: 'CONCEPTO_CODIGO_DUPLICADO', campo: 'codigo' });
    expect(tx.imp_conceptos_costo.create).not.toHaveBeenCalled();
    expect(tx.imp_conceptos_costo.findFirst.mock.calls[0][0].where.OR).toEqual([{ empresa_id: EMPRESA }, { empresa_id: null }]);
  });

  it('editar uno de sistema → CONCEPTO_DE_SISTEMA 409 (fila 18); desactivarlo también', async () => {
    const sistema = concepto({ id: 'con-sis', empresa_id: null, es_sistema: true, codigo: 'FOB' });
    const { service } = crearConceptos({ conceptos: [sistema] });
    expect(await cuerpo(service.actualizarConcepto('con-sis', { nombre: 'X', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA))).toMatchObject({ status: 409, codigo: 'CONCEPTO_DE_SISTEMA' });
    expect(await cuerpo(service.eliminarConcepto('con-sis', EMPRESA))).toMatchObject({ status: 409, codigo: 'CONCEPTO_DE_SISTEMA' });
  });

  it('el concepto de otra empresa no existe para esta (404)', async () => {
    const { service } = crearConceptos({ conceptos: [] });
    expect(await cuerpo(service.actualizarConcepto('con-x', { updated_at: null } as any, EMPRESA))).toMatchObject({ status: 404 });
  });

  it("moneda_default 'GS' → 400 con campo moneda_default; PYG y USD pasan", async () => {
    const { service, tx } = crearConceptos();
    expect(await cuerpo(service.crearConcepto(dtoConcepto({ moneda_default: 'GS' }), EMPRESA))).toMatchObject({ status: 400, codigo: 'MONEDA_INVALIDA', campo: 'moneda_default' });
    await service.crearConcepto(dtoConcepto({ moneda_default: 'PYG' }), EMPRESA);
    expect(tx.imp_conceptos_costo.create.mock.calls[0][0].data.moneda_default).toBe('PYG');
    expect(tx.moneda.findFirst.mock.calls[0][0].where).toMatchObject({ codigo: 'GS', empresa_monedas: { some: { empresa_id: EMPRESA } } });
  });

  it('el alta guarda aplica_perfil, afecta_costo y orden', async () => {
    const { service, tx } = crearConceptos();
    await service.crearConcepto(dtoConcepto({ aplica_perfil: 'AUTOS', afecta_costo: false, orden: 40 }), EMPRESA);
    expect(tx.imp_conceptos_costo.create.mock.calls[0][0].data).toMatchObject({ aplica_perfil: 'AUTOS', afecta_costo: false, orden: 40, es_sistema: false, empresa_id: EMPRESA });
    await service.crearConcepto(dtoConcepto({ codigo: 'OTRO' }), EMPRESA);
    expect(tx.imp_conceptos_costo.create.mock.calls[1][0].data).toMatchObject({ afecta_costo: true, orden: 0 });
  });

  it('editar: sin updated_at → CAMPO_REQUERIDO; con otro → DATOS_CAMBIADOS; con el vigente guarda aplica_perfil, afecta_costo y orden', async () => {
    const { service, tx } = crearConceptos({ conceptos: [concepto()] });
    expect(await cuerpo(service.actualizarConcepto('con-1', { nombre: 'Y' } as any, EMPRESA))).toMatchObject({ status: 400, codigo: 'CAMPO_REQUERIDO', campo: 'updated_at' });
    expect(await cuerpo(service.actualizarConcepto('con-1', { nombre: 'Y', updated_at: '2026-10-02T00:00:00.000Z' } as any, EMPRESA))).toMatchObject({ status: 409, codigo: 'DATOS_CAMBIADOS' });
    await service.actualizarConcepto('con-1', { aplica_perfil: 'AUTOS', afecta_costo: false, orden: 7, updated_at: UPDATED_AT.toISOString() } as any, EMPRESA);
    expect(tx.imp_conceptos_costo.update.mock.calls[0][0].data).toMatchObject({ aplica_perfil: 'AUTOS', afecta_costo: false, orden: 7 });
  });

  it('cambiar el código a uno que ya existe → CONCEPTO_CODIGO_DUPLICADO; dejar el mismo no valida', async () => {
    const { service } = crearConceptos({ conceptos: [concepto(), concepto({ id: 'con-2', codigo: 'SEGURO' })] });
    const upd = UPDATED_AT.toISOString();
    expect(await cuerpo(service.actualizarConcepto('con-1', { codigo: 'SEGURO', updated_at: upd } as any, EMPRESA))).toMatchObject({ status: 409, codigo: 'CONCEPTO_CODIGO_DUPLICADO' });
    await expect(service.actualizarConcepto('con-1', { codigo: 'flete_aereo', updated_at: upd } as any, EMPRESA)).resolves.toBeDefined();
  });

  it('con el módulo operativo apagado, alta, edición y baja siguen (spec punto 6: «catálogos siguen»; Task 16 ronda 1)', async () => {
    const { service, tx } = crearConceptos({ moduloActivo: false, conceptos: [concepto()] });
    await expect(service.crearConcepto(dtoConcepto({ codigo: 'SEGURO_LOCAL' }), EMPRESA)).resolves.toBeDefined();
    await expect(service.actualizarConcepto('con-1', { nombre: 'Flete aéreo', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA)).resolves.toBeDefined();
    await expect(service.eliminarConcepto('con-1', EMPRESA)).resolves.toBeDefined();
    expect(tx.imp_conceptos_costo.create).toHaveBeenCalled();
    expect(tx.imp_conceptos_costo.update).toHaveBeenCalled();
  });

  it('las escrituras toman el lock de catálogos de la empresa', async () => {
    const { service, log } = crearConceptos();
    await service.crearConcepto(dtoConcepto(), EMPRESA);
    expect(log).toContain(`lock:imp-cat:${EMPRESA}`);
  });

  it('GET /conceptos?perfil=AUTOS devuelve los de AUTOS y los sin perfil, solo activos, de la empresa y de sistema', async () => {
    const { service, prisma } = crearConceptos();
    await service.getConceptos(EMPRESA, 'AUTOS');
    const args = prisma.imp_conceptos_costo.findMany.mock.calls[0][0];
    expect(args.where.activo).toBe(true);
    expect(args.where.OR).toEqual([{ empresa_id: EMPRESA }, { empresa_id: null, es_sistema: true }]);
    expect(args.where.AND).toEqual([{ OR: [{ aplica_perfil: null }, { aplica_perfil: 'AUTOS' }] }]);
    await service.getConceptos(EMPRESA);
    expect(prisma.imp_conceptos_costo.findMany.mock.calls[1][0].where.AND).toBeUndefined();
  });
});

describe('Importaciones - tasas ISC', () => {
  it('vigente_hasta antes de vigente_desde → VIGENCIA_INVALIDA con campo vigente_hasta', async () => {
    const { service } = crearIsc();
    expect(await cuerpo(service.create(EMPRESA, dtoTasa({ vigente_hasta: '2025-12-31' })))).toMatchObject({ status: 400, codigo: 'VIGENCIA_INVALIDA', campo: 'vigente_hasta' });
  });

  it('año o cilindrada invertidos → RANGO_ISC_INVALIDO', async () => {
    const { service } = crearIsc();
    expect(await cuerpo(service.create(EMPRESA, dtoTasa({ anio_hasta: 2010 })))).toMatchObject({ status: 400, codigo: 'RANGO_ISC_INVALIDO', campo: 'anio_hasta' });
    expect(await cuerpo(service.create(EMPRESA, dtoTasa({ cc_hasta: 900 })))).toMatchObject({ status: 400, codigo: 'RANGO_ISC_INVALIDO', campo: 'cc_hasta' });
  });

  it('rango superpuesto con una activa vigente → RANGO_ISC_SUPERPUESTO 409; el filtro cruza año, cilindrada y vigencia de la empresa', async () => {
    const { service, tx } = crearIsc({ tasas: [tasa()] });
    const e = await cuerpo(service.create(EMPRESA, dtoTasa({ anio_desde: 2018, anio_hasta: 2024, cc_desde: 1200, cc_hasta: 2000 })));
    expect(e).toMatchObject({ status: 409, codigo: 'RANGO_ISC_SUPERPUESTO', tasa_id: 'isc-1' });
    expect(tx.imp_isc_vehiculos.create).not.toHaveBeenCalled();
    expect(tx.imp_isc_vehiculos.findFirst.mock.calls[0][0].where).toMatchObject({
      empresa_id: EMPRESA, activo: true,
      anio_desde: { lte: 2024 }, anio_hasta: { gte: 2018 }, cc_desde: { lte: 2000 }, cc_hasta: { gte: 1200 },
      OR: [{ vigente_hasta: null }, { vigente_hasta: { gte: dia('2026-01-01') } }],
    });
  });

  it('sin choque se crea; una tasa nueva inactiva no valida superposición; con vigente_hasta el filtro acota el inicio', async () => {
    const libre = crearIsc();
    await libre.service.create(EMPRESA, dtoTasa({ vigente_hasta: '2026-12-31' }));
    expect(libre.tx.imp_isc_vehiculos.findFirst.mock.calls[0][0].where.vigente_desde).toEqual({ lte: dia('2026-12-31') });
    expect(libre.tx.imp_isc_vehiculos.create).toHaveBeenCalledTimes(1);
    const inactiva = crearIsc({ tasas: [tasa()] });
    await inactiva.service.create(EMPRESA, dtoTasa({ activo: false }));
    expect(inactiva.tx.imp_isc_vehiculos.create).toHaveBeenCalledTimes(1);
  });

  it('editar una de sistema → TASA_DE_SISTEMA 409 (fila 19); borrarla también', async () => {
    const { service } = crearIsc({ tasas: [tasa({ id: 'isc-sis', empresa_id: null })] });
    expect(await cuerpo(service.update(EMPRESA, 'isc-sis', { tasa_isc_pct: 5, updated_at: UPDATED_AT.toISOString() } as any))).toMatchObject({ status: 409, codigo: 'TASA_DE_SISTEMA' });
    expect(await cuerpo(service.remove(EMPRESA, 'isc-sis'))).toMatchObject({ status: 409, codigo: 'TASA_DE_SISTEMA' });
  });

  it('editar: sin updated_at → CAMPO_REQUERIDO; con otro → DATOS_CAMBIADOS; con el vigente guarda y excluye la propia del choque', async () => {
    const { service, tx } = crearIsc({ tasas: [tasa()] });
    expect(await cuerpo(service.update(EMPRESA, 'isc-1', { tasa_isc_pct: 5 } as any))).toMatchObject({ status: 400, codigo: 'CAMPO_REQUERIDO', campo: 'updated_at' });
    expect(await cuerpo(service.update(EMPRESA, 'isc-1', { tasa_isc_pct: 5, updated_at: '2026-10-02T00:00:00.000Z' } as any))).toMatchObject({ status: 409, codigo: 'DATOS_CAMBIADOS' });
    tx.imp_isc_vehiculos.findFirst.mockImplementation((args: any) => Promise.resolve(typeof args.where.id === 'string' ? tasa() : null));
    await service.update(EMPRESA, 'isc-1', { tasa_isc_pct: 5, updated_at: UPDATED_AT.toISOString() } as any);
    expect(tx.imp_isc_vehiculos.update.mock.calls[0][0].data).toMatchObject({ tasa_isc_pct: 5 });
    expect(tx.imp_isc_vehiculos.findFirst.mock.calls.at(-1)[0].where.id).toEqual({ not: 'isc-1' });
  });

  it('editar a una vigencia inválida usa lo guardado: bajar vigente_desde por encima del hasta → VIGENCIA_INVALIDA', async () => {
    const { service } = crearIsc({ tasas: [tasa({ vigente_hasta: dia('2026-06-30') })] });
    expect(await cuerpo(service.update(EMPRESA, 'isc-1', { vigente_desde: '2026-09-01', updated_at: UPDATED_AT.toISOString() } as any))).toMatchObject({ status: 400, codigo: 'VIGENCIA_INVALIDA' });
  });

  it('con el módulo operativo apagado, alta, edición y baja siguen (spec punto 6: «catálogos siguen»; Task 16 ronda 1)', async () => {
    // Tasa guardada inactiva: así el alta y la edición no chocan con la superposición (eso lo prueban los otros casos).
    const { service, tx } = crearIsc({ moduloActivo: false, tasas: [tasa({ activo: false })] });
    await expect(service.create(EMPRESA, dtoTasa())).resolves.toBeDefined();
    await expect(service.update(EMPRESA, 'isc-1', { descripcion: 'Livianos 2', updated_at: UPDATED_AT.toISOString() } as any)).resolves.toBeDefined();
    await expect(service.remove(EMPRESA, 'isc-1')).resolves.toBeDefined();
    expect(tx.imp_isc_vehiculos.create).toHaveBeenCalled();
  });
});

describe('Importaciones - DTO de catálogos con el pipe real', () => {
  const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
  const patch = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true, skipMissingProperties: true });
  const meta = (metatype: any): ArgumentMetadata => ({ type: 'body', metatype });

  it('el concepto acepta afecta_costo y orden, y moneda_default en código ISO', async () => {
    await expect(pipe.transform({ codigo: 'X_1', nombre: 'X', afecta_costo: false, orden: 3, moneda_default: 'PYG' }, meta(CreateConceptoCostoDto))).resolves.toBeDefined();
    await expect(pipe.transform({ codigo: 'X_1', nombre: 'X', moneda_default: 'GS' }, meta(CreateConceptoCostoDto))).rejects.toMatchObject({ status: 400 });
    await expect(pipe.transform({ codigo: 'X_1', nombre: 'X', orden: -1 }, meta(CreateConceptoCostoDto))).rejects.toMatchObject({ status: 400 });
  });

  it('los PATCH de concepto y tasa aceptan updated_at ISO o null y rechazan otro texto', async () => {
    for (const dto of [UpdateConceptoCostoDto, UpdateTasaIscDto]) {
      await expect(patch.transform({ updated_at: '2026-10-01T12:00:00.000Z' }, meta(dto))).resolves.toBeDefined();
      await expect(patch.transform({ updated_at: null }, meta(dto))).resolves.toBeDefined();
      await expect(patch.transform({ updated_at: 'ayer' }, meta(dto))).rejects.toMatchObject({ status: 400 });
    }
    await expect(pipe.transform(dtoTasa(), meta(CreateTasaIscDto))).resolves.toBeDefined();
  });
});
