import { ArgumentMetadata, ValidationPipe } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { CreateEmbarqueDto, UpdateEmbarqueDto } from '../dto/importaciones.dto';
import { ImportacionesService } from './importaciones.service';

jest.mock('src/stock/tipos-movimiento-inventario', () => ({
  tipoMovimientoInventarioId: jest.fn(async (_tx: unknown, codigo: string) => `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ó');
};

interface Opciones {
  moduloActivo?: boolean;
  perfilActivo?: string;
  embarque?: Record<string, any> | null;
  ultimoNumero?: string | null;
  proveedor?: Record<string, any> | null;
  moneda?: Record<string, any> | null;
  createError?: unknown;
  contar?: Record<string, number>;
  componentes?: any[];
  despachos?: any[];
  activosPerfil?: number;
}

function crear(opts: Opciones = {}) {
  const log: string[] = [];
  const embarque = opts.embarque === undefined ? { id: 'emb-1', empresa_id: EMPRESA, numero: 'IMP-2026-000001', estado: 'BORRADOR', perfil: 'AUTOS', proveedor_id: 'prov-1', moneda_id: 'mon-1', origen_pais: 'KR', updated_at: UPDATED_AT, activo: true } : opts.embarque;
  const contar = opts.contar ?? {};
  const tx: any = {
    $executeRaw: jest.fn(async (strings: TemplateStringsArray, ...valores: any[]) => {
      log.push(`lock:${String(valores[0])}`);
    }),
    imp_config_empresa: {
      findUnique: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: opts.moduloActivo ?? true, perfil_activo: opts.perfilActivo ?? 'AUTOS' }),
      update: jest.fn(async () => ({ modulo_operativo_activo: true, perfil_activo: 'CONSUMO_MASIVO' })),
    },
    suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue({ id: 's' }) },
    proveedores: { findFirst: jest.fn().mockResolvedValue(opts.proveedor === undefined ? { id: 'prov-1', tipo_entidad: 'PROVEEDOR' } : opts.proveedor) },
    moneda: { findUnique: jest.fn().mockResolvedValue(opts.moneda === undefined ? { id: 'mon-1' } : opts.moneda) },
    imp_embarques: {
      findFirst: jest.fn(async (args: any) => (args?.where?.numero?.startsWith ? (opts.ultimoNumero ? { numero: opts.ultimoNumero } : null) : embarque)),
      create: jest.fn(async (args: any) => {
        log.push('create');
        if (opts.createError) throw opts.createError;
        return { id: 'emb-nuevo', ...args.data };
      }),
      update: jest.fn(),
      count: jest.fn().mockResolvedValue(opts.activosPerfil ?? 0),
    },
    imp_embarque_items: { updateMany: jest.fn() },
    imp_componentes_costo: { updateMany: jest.fn(), findMany: jest.fn().mockResolvedValue(opts.componentes ?? []) },
    imp_despachos: { findMany: jest.fn().mockResolvedValue(opts.despachos ?? []), deleteMany: jest.fn() },
    compra_cab: { count: jest.fn().mockResolvedValue(contar.FACTURA ?? 0) },
    gasto_cab: { count: jest.fn().mockResolvedValue(contar.GASTO ?? 0) },
    tes_movimientos: { count: jest.fn().mockResolvedValue(contar.TESORERIA ?? 0) },
    movimientos_inventario: { count: jest.fn().mockResolvedValue(contar.STOCK ?? 0) },
    cont_documentos: { count: jest.fn().mockResolvedValue(contar.ASIENTO ?? 0) },
    imp_embarques_bitacora: { create: jest.fn() },
  };
  const prisma: any = { $transaction: jest.fn(async (cb: any) => cb(tx)) };
  const service = new ImportacionesService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, {} as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'emb-1' } as any);
  return { service, tx, log };
}

const dtoCrear = (extra: Record<string, any> = {}): any => ({
  proveedor_id: 'prov-1',
  moneda_id: 'mon-1',
  origen_pais: 'KR',
  ...extra,
});

describe('ImportacionesService - cabecera', () => {
  afterEach(() => jest.useRealTimers());

  describe('create', () => {
    it('sin moneda → MONEDA_REQUERIDA con campo', async () => {
      const { service } = crear();
      const e = await cuerpo(service.create(dtoCrear({ moneda_id: undefined }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'MONEDA_REQUERIDA', campo: 'moneda_id' });
    });

    it('sin país → PAIS_REQUERIDO con campo', async () => {
      const { service } = crear();
      const e = await cuerpo(service.create(dtoCrear({ origen_pais: '  ' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'PAIS_REQUERIDO', campo: 'origen_pais' });
    });

    it('proveedor ACREEDOR_VARIO → PROVEEDOR_ACREEDOR_VARIO', async () => {
      const { service } = crear({ proveedor: { id: 'prov-1', tipo_entidad: 'ACREEDOR_VARIO' } });
      const e = await cuerpo(service.create(dtoCrear(), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'PROVEEDOR_ACREEDOR_VARIO', campo: 'proveedor_id' });
    });

    it('ETA antes del embarque → FECHAS_FUERA_DE_ORDEN con campo fecha_eta', async () => {
      const { service } = crear();
      const e = await cuerpo(service.create(dtoCrear({ fecha_embarque: '2026-10-10', fecha_eta: '2026-10-01' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'FECHAS_FUERA_DE_ORDEN', campo: 'fecha_eta' });
    });

    it('el número toma imp-num: antes de leer el máximo y sale del máximo del año', async () => {
      jest.useFakeTimers({ now: new Date('2026-10-15T15:00:00Z'), doNotFake: ['nextTick', 'setImmediate', 'setTimeout'] });
      const { service, tx, log } = crear({ ultimoNumero: 'IMP-2026-000041' });
      await service.create(dtoCrear(), EMPRESA, 'u-1');
      expect(log[0]).toBe(`lock:imp-num:${EMPRESA}`);
      expect(log.indexOf('create')).toBeGreaterThan(0);
      expect(tx.imp_embarques.create.mock.calls[0][0].data.numero).toBe('IMP-2026-000042');
    });

    it('el número usa el año de hoyComoFechaPY a las 01:30 UTC del 01/01', async () => {
      jest.useFakeTimers({ now: new Date('2027-01-01T01:30:00Z'), doNotFake: ['nextTick', 'setImmediate', 'setTimeout'] });
      const { service, tx } = crear();
      await service.create(dtoCrear(), EMPRESA, 'u-1');
      expect(tx.imp_embarques.create.mock.calls[0][0].data.numero).toBe('IMP-2026-000001');
      expect(tx.imp_embarques.findFirst.mock.calls[0][0].where.numero.startsWith).toBe('IMP-2026-');
    });

    it('P2002 del número → 409 NUMERO_DUPLICADO', async () => {
      const p2002 = new Prisma.PrismaClientKnownRequestError('duplicado', { code: 'P2002', clientVersion: 'x' });
      const { service } = crear({ createError: p2002 });
      const e = await cuerpo(service.create(dtoCrear(), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'NUMERO_DUPLICADO' });
    });
  });

  describe('update', () => {
    const upd = (extra: Record<string, any> = {}): any => ({ updated_at: UPDATED_AT.toISOString(), ...extra });

    it('sin updated_at → 400 CAMPO_REQUERIDO con campo updated_at', async () => {
      const { service } = crear();
      const e = await cuerpo(service.update('emb-1', { notas: 'x' } as any, EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'CAMPO_REQUERIDO', campo: 'updated_at' });
    });

    it('editar con updated_at viejo → DATOS_CAMBIADOS (toma el lock del embarque y relee)', async () => {
      const { service, log } = crear();
      const e = await cuerpo(service.update('emb-1', upd({ updated_at: '2026-09-01T00:00:00.000Z', notas: 'x' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'DATOS_CAMBIADOS' });
      expect(log[0]).toBe('lock:imp:emb-1');
    });

    it('null en la BD y null en el cuerpo cuentan iguales', async () => {
      const { service, tx } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'BORRADOR', perfil: 'AUTOS', proveedor_id: 'prov-1', moneda_id: 'mon-1', notas: null, updated_at: null } });
      await service.update('emb-1', { updated_at: null, notas: 'hola' } as any, EMPRESA, 'u-1');
      expect(tx.imp_embarques.update).toHaveBeenCalled();
    });

    it('cambiar proveedor en EN_DESPACHO → CAMPO_NO_EDITABLE con campo proveedor_id', async () => {
      const { service } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'EN_DESPACHO', perfil: 'AUTOS', proveedor_id: 'prov-1', moneda_id: 'mon-1', updated_at: UPDATED_AT } });
      const e = await cuerpo(service.update('emb-1', upd({ proveedor_id: 'prov-2' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'CAMPO_NO_EDITABLE', campo: 'proveedor_id' });
    });

    it('cambiar notas en DESPACHADO pasa', async () => {
      const { service, tx } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'DESPACHADO', perfil: 'AUTOS', proveedor_id: 'prov-1', moneda_id: 'mon-1', notas: null, updated_at: UPDATED_AT } });
      await service.update('emb-1', upd({ notas: 'nota nueva' }), EMPRESA, 'u-1');
      expect(tx.imp_embarques.update).toHaveBeenCalled();
    });

    it('mandar el mismo proveedor en DESPACHADO no cuenta como cambio', async () => {
      const { service, tx } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'DESPACHADO', perfil: 'AUTOS', proveedor_id: 'prov-1', moneda_id: 'mon-1', notas: null, updated_at: UPDATED_AT } });
      await service.update('emb-1', upd({ proveedor_id: 'prov-1', notas: 'n' }), EMPRESA, 'u-1');
      expect(tx.imp_embarques.update).toHaveBeenCalled();
    });

    it('embarque con fechas fuera de orden ya guardadas: editar notas pasa; cambiar la ETA a otra fuera de orden → FECHAS_FUERA_DE_ORDEN', async () => {
      const legado = { id: 'emb-1', empresa_id: EMPRESA, estado: 'BORRADOR', perfil: 'AUTOS', proveedor_id: 'prov-1', moneda_id: 'mon-1', notas: null, fecha_embarque: new Date('2026-10-10'), fecha_eta: new Date('2026-10-01'), updated_at: UPDATED_AT };
      const a = crear({ embarque: legado });
      await a.service.update('emb-1', upd({ notas: 'ok' }), EMPRESA, 'u-1');
      expect(a.tx.imp_embarques.update).toHaveBeenCalled();
      const b = crear({ embarque: legado });
      const e = await cuerpo(b.service.update('emb-1', upd({ fecha_eta: '2026-09-20' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ codigo: 'FECHAS_FUERA_DE_ORDEN', campo: 'fecha_eta' });
    });

    it('editar CERRADO → EMBARQUE_NO_EDITABLE', async () => {
      const { service } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'CERRADO', perfil: 'AUTOS', proveedor_id: 'prov-1', updated_at: UPDATED_AT } });
      const e = await cuerpo(service.update('emb-1', upd({ notas: 'x' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'EMBARQUE_NO_EDITABLE' });
    });

    it('embarque de otro perfil → PERFIL_DISTINTO', async () => {
      const { service } = crear({ perfilActivo: 'CONSUMO_MASIVO' });
      const e = await cuerpo(service.update('emb-1', upd({ notas: 'x' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'PERFIL_DISTINTO', message: 'Solo se pueden editar embarques del perfil activo (Consumo masivo) de la empresa.' });
    });

    it('alta con un perfil distinto del activo → PERFIL_DISTINTO con las etiquetas, no los valores crudos', async () => {
      const { service } = crear({ perfilActivo: 'CONSUMO_MASIVO' });
      const e = await cuerpo(service.create(dtoCrear({ perfil: 'AUTOS' }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'PERFIL_DISTINTO', campo: 'perfil' });
      expect(e.message).toBe('El perfil del embarque (Autos) debe coincidir con el perfil activo de la empresa (Consumo masivo).');
    });
  });

  describe('updateEstado', () => {
    it.each(['LIBERADO', 'DESPACHADO'])('PATCH a %s → TRANSICION_NO_PERMITIDA con estado_actual', async (destino) => {
      const { service } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'EN_DESPACHO', perfil: 'AUTOS' } });
      const e = await cuerpo(service.updateEstado('emb-1', { estado: destino }, EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'TRANSICION_NO_PERMITIDA', estado_actual: 'EN_DESPACHO', estado_pedido: destino });
    });

    it('EN_TRANSITO → BORRADOR pasa, con el lock y el evento ESTADO_CAMBIO', async () => {
      const { service, tx, log } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'EN_TRANSITO', perfil: 'AUTOS' } });
      await service.updateEstado('emb-1', { estado: 'BORRADOR' }, EMPRESA, 'u-1');
      expect(log[0]).toBe('lock:imp:emb-1');
      expect(tx.imp_embarques.update.mock.calls[0][0].data.estado).toBe('BORRADOR');
      expect(tx.imp_embarques_bitacora.create.mock.calls[0][0].data.evento).toBe('ESTADO_CAMBIO');
    });
  });

  describe('módulo operativo apagado', () => {
    it.each([
      ['create', (s: ImportacionesService) => s.create(dtoCrear(), EMPRESA, 'u-1')],
      ['update', (s: ImportacionesService) => s.update('emb-1', { updated_at: UPDATED_AT.toISOString(), notas: 'x' } as any, EMPRESA, 'u-1')],
      ['updateEstado', (s: ImportacionesService) => s.updateEstado('emb-1', { estado: 'EN_TRANSITO' }, EMPRESA, 'u-1')],
      ['remove', (s: ImportacionesService) => s.remove('emb-1', EMPRESA, 'u-1')],
      ['addItem', (s: ImportacionesService) => s.addItem('emb-1', {} as any, EMPRESA, 'u-1')],
      ['addCosto', (s: ImportacionesService) => s.addCosto('emb-1', {} as any, EMPRESA, 'u-1')],
      ['createDespacho', (s: ImportacionesService) => s.createDespacho('emb-1', {} as any, EMPRESA, 'u-1')],
      ['confirmarDespacho', (s: ImportacionesService) => s.confirmarDespacho('emb-1', 'd-1', EMPRESA, 'u-1')],
      ['liberarEmbarque', (s: ImportacionesService) => s.liberarEmbarque('emb-1', {} as any, EMPRESA, 'u-1')],
      ['revertirLiberacion', (s: ImportacionesService) => s.revertirLiberacion('emb-1', {} as any, EMPRESA, 'u-1')],
    ])('%s → MODULO_INACTIVO', async (_n, llamar) => {
      const { service } = crear({ moduloActivo: false });
      const e = await cuerpo(llamar(service));
      expect(e).toMatchObject({ codigo: 'MODULO_INACTIVO' });
    });
  });

  describe('remove', () => {
    it('eliminar BORRADOR apaga cabecera, ítems y costos', async () => {
      const { service, tx, log } = crear();
      const res = await service.remove('emb-1', EMPRESA, 'u-1');
      expect(res).toEqual({ message: 'Embarque eliminado' });
      expect(log[0]).toBe('lock:imp:emb-1');
      expect(tx.imp_embarque_items.updateMany.mock.calls[0][0].data.activo).toBe(false);
      expect(tx.imp_componentes_costo.updateMany.mock.calls[0][0].data.activo).toBe(false);
      expect(tx.imp_embarques.update.mock.calls[0][0].data.activo).toBe(false);
    });

    it('eliminar ARRIBADO con una CxP → EMBARQUE_CON_MOVIMIENTOS con [CXP]', async () => {
      const { service, tx } = crear({
        embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'ARRIBADO', perfil: 'AUTOS' },
        componentes: [{ id: 'c-1', cuenta_pagar_id: 'cxp-1' }, { id: 'c-2', cuenta_pagar_id: null }],
      });
      const e = await cuerpo(service.remove('emb-1', EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'EMBARQUE_CON_MOVIMIENTOS', movimientos: ['CXP'] });
      expect(tx.imp_embarques.update).not.toHaveBeenCalled();
    });

    it('eliminar LIBERADO → EMBARQUE_CON_MOVIMIENTOS aunque no haya movimientos (F20)', async () => {
      const { service } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'LIBERADO', perfil: 'AUTOS' } });
      const e = await cuerpo(service.remove('emb-1', EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'EMBARQUE_CON_MOVIMIENTOS', movimientos: [] });
    });

    it('facturas y gastos con anulado NULL cuentan como movimiento (OR anulado false o null)', async () => {
      const { service, tx } = crear({ embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'BORRADOR', perfil: 'AUTOS' }, contar: { FACTURA: 1, GASTO: 1 } });
      await cuerpo(service.remove('emb-1', EMPRESA, 'u-1'));
      expect(tx.compra_cab.count.mock.calls[0][0].where.OR).toEqual([{ anulado: false }, { anulado: null }]);
      expect(tx.gasto_cab.count.mock.calls[0][0].where.OR).toEqual([{ anulado: false }, { anulado: null }]);
    });

    it('arma los movimientos de despacho, facturas, gastos, tesorería, stock y asientos', async () => {
      const { service } = crear({
        embarque: { id: 'emb-1', empresa_id: EMPRESA, estado: 'EN_DESPACHO', perfil: 'AUTOS' },
        despachos: [{ id: 'd-1', estado: 'CONFIRMADO' }],
        contar: { FACTURA: 1, GASTO: 1, TESORERIA: 1, STOCK: 1, ASIENTO: 1 },
      });
      const e = await cuerpo(service.remove('emb-1', EMPRESA, 'u-1'));
      expect(e.movimientos).toEqual(['DESPACHO_CONFIRMADO', 'FACTURA', 'GASTO', 'TESORERIA', 'STOCK', 'ASIENTO']);
    });
  });

  describe('updateConfig', () => {
    it('cambiar el perfil con embarques activos → PERFIL_CON_EMBARQUES_ACTIVOS', async () => {
      const { service } = crear({ activosPerfil: 2 });
      const e = await cuerpo(service.updateConfig(EMPRESA, { perfil_activo: 'CONSUMO_MASIVO' } as any, 'u-1'));
      expect(e).toMatchObject({ status: 409, codigo: 'PERFIL_CON_EMBARQUES_ACTIVOS' });
    });
  });
});

describe('DTO con el ValidationPipe real (B29)', () => {
  const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
  const meta = (metatype: any): ArgumentMetadata => ({ type: 'body', metatype });

  it('sin moneda_id ni origen_pais el cuerpo llega al servicio (los códigos los lanza el servicio)', async () => {
    const r: any = await pipe.transform({ proveedor_id: '8b6c1ad4-3f3c-4f5e-9d0a-0c5a7c7a1111' }, meta(CreateEmbarqueDto));
    expect(r.moneda_id).toBeUndefined();
    expect(r.origen_pais).toBeUndefined();
  });

  it('con cuenta_pagar_id da 400', async () => {
    await expect(
      pipe.transform({ proveedor_id: '8b6c1ad4-3f3c-4f5e-9d0a-0c5a7c7a1111', cuenta_pagar_id: 'x' }, meta(CreateEmbarqueDto)),
    ).rejects.toMatchObject({ status: 400 });
  });

  it('updated_at no ISO da 400 y null o ISO pasan', async () => {
    const patch = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true, skipMissingProperties: true });
    await expect(patch.transform({ updated_at: 'ayer' }, meta(UpdateEmbarqueDto))).rejects.toMatchObject({ status: 400 });
    await expect(patch.transform({ updated_at: null }, meta(UpdateEmbarqueDto))).resolves.toBeDefined();
    await expect(patch.transform({ updated_at: '2026-10-01T12:00:00.000Z' }, meta(UpdateEmbarqueDto))).resolves.toBeDefined();
  });
});
