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

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

/** Mock asíncrono sin `async` (lint `require-await`). */
const resuelve = (f: (...a: any[]) => any) =>
  jest.fn((...a: any[]) => new Promise((res, rej) => { try { res(f(...a)); } catch (e) { rej(e instanceof Error ? e : new Error(String(e))); } }));

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 {
  estado?: string;
  arribo?: string | null;
  existente?: Record<string, any> | null;
  numeroOtro?: Record<string, any> | null;
  despacho?: Record<string, any> | null;
  despachante?: Record<string, any> | null;
  activo?: boolean;
  createError?: unknown;
}

function crear(opts: Opciones = {}) {
  const embarque = {
    id: 'emb-1', empresa_id: EMPRESA, numero: 'IMP-2026-000001', estado: opts.estado ?? 'ARRIBADO', perfil: 'AUTOS',
    fecha_arribo_real: opts.arribo === undefined ? new Date('2026-10-05T00:00:00.000Z') : opts.arribo ? new Date(opts.arribo) : null,
    updated_at: UPDATED_AT, activo: true,
  };
  const despacho = opts.despacho === undefined
    ? { id: 'des-1', empresa_id: EMPRESA, embarque_id: 'emb-1', numero_despacho: 'D-1', fecha_despacho: new Date('2026-10-10T00:00:00.000Z'), despachante_id: null, arancel_gs: 0, iva_importacion_gs: 100, iva_importacion_5_gs: 0, isc_gs: 0, inc_gs: 0, anticipo_ire_gs: 0, tasa_ana_gs: 0, otros_gs: 0, total_tributos_gs: 100, estado: 'BORRADOR', updated_at: UPDATED_AT }
    : opts.despacho;
  const tx: any = {
    $executeRaw: resuelve(() => undefined),
    imp_config_empresa: { findUnique: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: opts.activo ?? true, perfil_activo: 'AUTOS' }) },
    suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue({ id: 's' }) },
    imp_embarques: { findFirst: resuelve(() => embarque), update: jest.fn() },
    imp_embarque_items: { updateMany: jest.fn() },
    imp_componentes_costo: { updateMany: jest.fn(), findMany: jest.fn().mockResolvedValue([]) },
    imp_despachos: {
      findUnique: resuelve(() => opts.existente ?? null),
      findFirst: resuelve((args: any) => (args?.where?.numero_despacho ? opts.numeroOtro ?? null : despacho)),
      findMany: resuelve(() => (despacho ? [{ id: despacho.id, estado: despacho.estado }] : [])),
      create: resuelve((args: any) => {
        if (opts.createError) throw opts.createError;
        return { id: 'des-nuevo', ...args.data };
      }),
      update: resuelve((args: any) => ({ ...despacho, ...args.data })),
      delete: jest.fn(),
      deleteMany: jest.fn(),
    },
    proveedores: { findFirst: jest.fn().mockResolvedValue(opts.despachante === undefined ? { id: 'prov-1', tipo_entidad: 'PROVEEDOR' } : opts.despachante) },
    compra_cab: { count: jest.fn().mockResolvedValue(0) },
    gasto_cab: { count: jest.fn().mockResolvedValue(0) },
    tes_movimientos: { count: jest.fn().mockResolvedValue(0) },
    movimientos_inventario: { count: jest.fn().mockResolvedValue(0) },
    cont_documentos: { count: jest.fn().mockResolvedValue(0) },
    imp_embarques_bitacora: { create: jest.fn() },
  };
  const prisma: any = { $transaction: jest.fn((cb: any) => cb(tx) as Promise<unknown>) };
  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 };
}

const dto = (extra: Record<string, any> = {}): any => ({ numero_despacho: 'D-100', fecha_despacho: '2026-10-10', iva_importacion_gs: 100, ...extra });
const eventos = (tx: any) => tx.imp_embarques_bitacora.create.mock.calls.map((c: any) => c[0].data.evento);

describe('Importaciones - crear despacho', () => {
  afterEach(() => jest.useRealTimers());

  it('crear en ARRIBADO pasa el embarque a EN_DESPACHO con evento', async () => {
    const { service, tx } = crear({ estado: 'ARRIBADO' });
    await service.createDespacho('emb-1', dto(), EMPRESA, 'u-1');
    expect(tx.imp_embarques.update).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ estado: 'EN_DESPACHO' }) }));
    expect(eventos(tx)).toEqual(['ESTADO_CAMBIO', 'DESPACHO_CREADO']);
  });

  it('crear en EN_DESPACHO no mueve el estado', async () => {
    const { service, tx } = crear({ estado: 'EN_DESPACHO' });
    await service.createDespacho('emb-1', dto(), EMPRESA, 'u-1');
    expect(tx.imp_embarques.update).not.toHaveBeenCalled();
  });

  it('crear en DESPACHADO → ESTADO_CAMBIADO con estado_actual', async () => {
    const { service } = crear({ estado: 'DESPACHADO' });
    const e = await cuerpo(service.createDespacho('emb-1', dto(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO', estado_actual: 'DESPACHADO' });
  });

  it('embarque con despacho → DESPACHO_YA_EXISTE', async () => {
    const { service } = crear({ existente: { id: 'des-0' } });
    const e = await cuerpo(service.createDespacho('emb-1', dto(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'DESPACHO_YA_EXISTE' });
  });

  it('número repetido en otro embarque → DESPACHO_NUMERO_DUPLICADO con campo, sin distinguir mayúsculas', async () => {
    const { service, tx } = crear({ numeroOtro: { id: 'des-9' } });
    const e = await cuerpo(service.createDespacho('emb-1', dto(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'DESPACHO_NUMERO_DUPLICADO', campo: 'numero_despacho' });
    const donde = tx.imp_despachos.findFirst.mock.calls[0][0].where;
    expect(donde).toMatchObject({ empresa_id: EMPRESA, numero_despacho: { equals: 'D-100', mode: 'insensitive' } });
  });

  it('P2002 del índice único (carrera) → DESPACHO_NUMERO_DUPLICADO', async () => {
    const p2002 = new Prisma.PrismaClientKnownRequestError('dup', { code: 'P2002', clientVersion: 'x' });
    const { service } = crear({ createError: p2002 });
    const e = await cuerpo(service.createDespacho('emb-1', dto(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'DESPACHO_NUMERO_DUPLICADO', campo: 'numero_despacho' });
  });

  it('fecha de mañana (Paraguay) → FECHA_DESPACHO_INVALIDA', async () => {
    jest.useFakeTimers({ now: new Date('2026-10-20T15:00:00.000Z') });
    const { service } = crear({ arribo: '2026-10-05' });
    const e = await cuerpo(service.createDespacho('emb-1', dto({ fecha_despacho: '2026-10-21' }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'FECHA_DESPACHO_INVALIDA', campo: 'fecha_despacho' });
  });

  it('a las 01:30 UTC el hoy de Paraguay sigue siendo el día anterior: la fecha de ese día no es futura', async () => {
    jest.useFakeTimers({ now: new Date('2026-10-21T01:30:00.000Z') });
    const { service, tx } = crear({ arribo: '2026-10-05' });
    await service.createDespacho('emb-1', dto({ fecha_despacho: '2026-10-20' }), EMPRESA, 'u-1');
    expect(tx.imp_despachos.create).toHaveBeenCalledTimes(1);
    const e = await cuerpo(service.createDespacho('emb-1', dto({ fecha_despacho: '2026-10-21' }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ codigo: 'FECHA_DESPACHO_INVALIDA' });
  });

  it('un instante con zona se compara como día de Paraguay: 2026-10-31T01:30Z es el 30 y no es futuro', async () => {
    jest.useFakeTimers({ now: new Date('2026-10-30T15:00:00.000Z') });
    const { service, tx } = crear({ arribo: '2026-10-05' });
    await service.createDespacho('emb-1', dto({ fecha_despacho: '2026-10-31T01:30:00Z' }), EMPRESA, 'u-1');
    expect(tx.imp_despachos.create).toHaveBeenCalledTimes(1);
    const e = await cuerpo(service.createDespacho('emb-1', dto({ fecha_despacho: '2026-10-31T04:00:00Z' }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ codigo: 'FECHA_DESPACHO_INVALIDA' });
  });

  it('el lock imp: se toma antes de releer el embarque', async () => {
    const { service, tx } = crear();
    const orden: string[] = [];
    tx.$executeRaw.mockImplementation(() => { orden.push('lock'); return Promise.resolve(); });
    const leer = tx.imp_embarques.findFirst;
    tx.imp_embarques.findFirst = jest.fn((...a: any[]) => { orden.push('leer'); return leer(...a) as Promise<unknown>; });
    await service.createDespacho('emb-1', dto(), EMPRESA, 'u-1');
    expect(orden.slice(0, 2)).toEqual(['lock', 'leer']);
  });

  it('el módulo operativo se verifica una sola vez por operación', async () => {
    const { service, tx } = crear({ estado: 'EN_DESPACHO' });
    await service.removeDespacho('emb-1', 'des-1', EMPRESA, 'u-1');
    expect(tx.imp_config_empresa.findUnique).toHaveBeenCalledTimes(1);
  });

  it('P2002 sobre el índice del embarque (carrera) → DESPACHO_YA_EXISTE', async () => {
    const p2002 = new Prisma.PrismaClientKnownRequestError('dup', { code: 'P2002', clientVersion: 'x', meta: { target: 'uk_imp_despachos_embarque' } });
    const { service } = crear({ createError: p2002 });
    const e = await cuerpo(service.createDespacho('emb-1', dto(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'DESPACHO_YA_EXISTE' });
  });

  it('antes del arribo real → FECHA_DESPACHO_INVALIDA', async () => {
    const { service } = crear({ arribo: '2026-10-05' });
    const e = await cuerpo(service.createDespacho('emb-1', dto({ fecha_despacho: '2026-10-04' }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'FECHA_DESPACHO_INVALIDA', campo: 'fecha_despacho' });
  });

  it('arancel -1 → TRIBUTO_NEGATIVO con campo arancel_gs', async () => {
    const { service } = crear();
    const e = await cuerpo(service.createDespacho('emb-1', dto({ arancel_gs: -1 }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'TRIBUTO_NEGATIVO', campo: 'arancel_gs' });
  });

  it('IVA al 5 % mayor al IVA total → IVA_5_SUPERA_TOTAL', async () => {
    const { service } = crear();
    const e = await cuerpo(service.createDespacho('emb-1', dto({ iva_importacion_gs: 100, iva_importacion_5_gs: 101 }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'IVA_5_SUPERA_TOTAL', campo: 'iva_importacion_5_gs' });
  });

  it('guarda el IVA al 5 % y lo suma una sola vez al total de tributos', async () => {
    const { service, tx } = crear();
    await service.createDespacho('emb-1', dto({ iva_importacion_gs: 100, iva_importacion_5_gs: 40, arancel_gs: 10 }), EMPRESA, 'u-1');
    expect(tx.imp_despachos.create.mock.calls[0][0].data).toMatchObject({ iva_importacion_5_gs: 40, total_tributos_gs: 110 });
  });

  it('despachante acreedor vario → PROVEEDOR_ACREEDOR_VARIO con campo despachante_id', async () => {
    const { service } = crear({ despachante: { id: 'prov-1', tipo_entidad: 'ACREEDOR_VARIO' } });
    const e = await cuerpo(service.createDespacho('emb-1', dto({ despachante_id: 'prov-1' }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'PROVEEDOR_ACREEDOR_VARIO', campo: 'despachante_id' });
  });

  it('módulo apagado → MODULO_INACTIVO', async () => {
    const { service } = crear({ activo: false });
    const e = await cuerpo(service.createDespacho('emb-1', dto(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ codigo: 'MODULO_INACTIVO' });
  });
});

describe('Importaciones - editar y eliminar despacho', () => {
  it('PATCH sin updated_at → CAMPO_REQUERIDO; con otro → DATOS_CAMBIADOS', async () => {
    const { service } = crear();
    expect(await cuerpo(service.updateDespacho('emb-1', 'des-1', { notas: 'x' } as any, EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'CAMPO_REQUERIDO', campo: 'updated_at' });
    expect(await cuerpo(service.updateDespacho('emb-1', 'des-1', { notas: 'x', updated_at: '2026-09-01T00:00:00.000Z' } as any, EMPRESA, 'u-1'))).toMatchObject({ status: 409, codigo: 'DATOS_CAMBIADOS' });
  });

  it('PATCH de un despacho CONFIRMADO → DESPACHO_NO_BORRADOR', async () => {
    const { service } = crear({ despacho: { id: 'des-1', estado: 'CONFIRMADO', updated_at: UPDATED_AT } });
    const e = await cuerpo(service.updateDespacho('emb-1', 'des-1', { notas: 'x', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'DESPACHO_NO_BORRADOR' });
  });

  it('PATCH valida sobre lo ya guardado: bajar el IVA total por debajo del IVA 5 % → IVA_5_SUPERA_TOTAL', async () => {
    const { service } = crear({ despacho: { id: 'des-1', estado: 'BORRADOR', numero_despacho: 'D-1', fecha_despacho: new Date('2026-10-10'), iva_importacion_gs: 100, iva_importacion_5_gs: 80, updated_at: UPDATED_AT } });
    const e = await cuerpo(service.updateDespacho('emb-1', 'des-1', { iva_importacion_gs: 50, updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1'));
    expect(e).toMatchObject({ codigo: 'IVA_5_SUPERA_TOTAL' });
  });

  it('PATCH con número de otro despacho → DESPACHO_NUMERO_DUPLICADO (excluye al propio)', async () => {
    const { service, tx } = crear({ numeroOtro: { id: 'des-9' } });
    const e = await cuerpo(service.updateDespacho('emb-1', 'des-1', { numero_despacho: 'D-9', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'DESPACHO_NUMERO_DUPLICADO', campo: 'numero_despacho' });
    expect(tx.imp_despachos.findFirst.mock.calls.find((c: any) => c[0].where.numero_despacho)[0].where).toMatchObject({ id: { not: 'des-1' } });
  });

  it('eliminar el BORRADOR vuelve el embarque de EN_DESPACHO a ARRIBADO con evento', async () => {
    const { service, tx } = crear({ estado: 'EN_DESPACHO' });
    await service.removeDespacho('emb-1', 'des-1', EMPRESA, 'u-1');
    expect(tx.imp_despachos.delete).toHaveBeenCalledWith({ where: { id: 'des-1' } });
    expect(tx.imp_embarques.update).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ estado: 'ARRIBADO' }) }));
    expect(tx.imp_embarques_bitacora.create.mock.calls.map((c: any) => [c[0].data.evento, c[0].data.estado_anterior, c[0].data.estado_nuevo])).toContainEqual(['ESTADO_CAMBIO', 'EN_DESPACHO', 'ARRIBADO']);
  });

  it('eliminar un despacho CONFIRMADO → DESPACHO_NO_BORRADOR', async () => {
    const { service, tx } = crear({ estado: 'DESPACHADO', despacho: { id: 'des-1', estado: 'CONFIRMADO', updated_at: UPDATED_AT } });
    const e = await cuerpo(service.removeDespacho('emb-1', 'des-1', EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'DESPACHO_NO_BORRADOR' });
    expect(tx.imp_despachos.delete).not.toHaveBeenCalled();
  });

  it('módulo apagado → MODULO_INACTIVO al editar y al eliminar', async () => {
    const { service } = crear({ activo: false });
    expect(await cuerpo(service.removeDespacho('emb-1', 'des-1', EMPRESA, 'u-1'))).toMatchObject({ codigo: 'MODULO_INACTIVO' });
    expect(await cuerpo(service.updateDespacho('emb-1', 'des-1', { updated_at: null } as any, EMPRESA, 'u-1'))).toMatchObject({ codigo: 'MODULO_INACTIVO' });
  });
});

describe('Importaciones - eliminar embarque con despacho en BORRADOR', () => {
  it('elimina también su despacho BORRADOR en la misma transacción', async () => {
    const { service, tx } = crear({ estado: 'EN_DESPACHO' });
    await service.remove('emb-1', EMPRESA, 'u-1');
    expect(tx.imp_despachos.deleteMany).toHaveBeenCalledWith({ where: { embarque_id: 'emb-1', empresa_id: EMPRESA, estado: 'BORRADOR' } });
  });

  it('con despacho CONFIRMADO se rechaza y no borra nada', async () => {
    const { service, tx } = crear({ estado: 'DESPACHADO', despacho: { id: 'des-1', estado: 'CONFIRMADO', updated_at: UPDATED_AT } });
    const e = await cuerpo(service.remove('emb-1', EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'EMBARQUE_CON_MOVIMIENTOS' });
    expect(tx.imp_despachos.deleteMany).not.toHaveBeenCalled();
  });
});

describe('DTO del despacho', () => {
  const pipe = new ValidationPipe({ transform: true });
  const meta = (metatype: any): ArgumentMetadata => ({ type: 'body', metatype });
  it('no rechaza tributos negativos (lo hace el servicio con TRIBUTO_NEGATIVO) y acepta iva_importacion_5_gs', async () => {
    const r: any = await pipe.transform({ numero_despacho: 'D-1', fecha_despacho: '2026-10-10', arancel_gs: -1, iva_importacion_5_gs: 5 }, meta(CreateDespachoDto));
    expect(r.arancel_gs).toBe(-1);
    expect(r.iva_importacion_5_gs).toBe(5);
  });
  it('el PATCH acepta updated_at', async () => {
    const r: any = await new ValidationPipe({ transform: true, skipMissingProperties: true }).transform({ updated_at: '2026-10-01T12:00:00.000Z' }, meta(UpdateDespachoDto));
    expect(r.updated_at).toBe('2026-10-01T12:00:00.000Z');
  });
});
