import { BloqueosDePlan, SIN_BLOQUEOS_DE_PLAN } from 'src/auth/guards/acceso-por-plan';
import { IMP_ESTADOS_EMBARQUE } from './dto/importaciones.dto';
import {
  ACCION_PRINCIPAL,
  ETIQUETA_ESTADO,
  EstadoAcciones,
  EstadoEmbarque,
  PRIVILEGIOS_DE_ACCIONES,
  SUBMODULO_DE_ACCION,
  SUBMODULOS_DE_ACCIONES,
  TRANSICIONES_PATCH,
  accionesPermitidas,
  transicionPatchPermitida,
} from './estados-embarque';

const TODOS = new Set([
  'IMP_EMB_EMBARQUE_EDITAR', 'IMP_EMB_EMBARQUE_ELIMINAR', 'IMP_EMB_EMBARQUE_CERRAR', 'IMP_COS_COSTO_CREAR',
  'IMP_DES_DESPACHO_CREAR', 'IMP_DES_DESPACHO_EDITAR', 'IMP_DES_DESPACHO_ELIMINAR', 'IMP_DES_DESPACHO_PROCESAR',
]);

const base = (parcial: Partial<EstadoAcciones> = {}): EstadoAcciones => ({
  estado: 'BORRADOR',
  modulo_operativo_activo: true,
  tiene_contabilidad: false,
  despacho: null,
  asiento_cierre_estado: null,
  perfil_distinto: false,
  ...parcial,
});
const SIN_PLAN = SIN_BLOQUEOS_DE_PLAN;
const buscar = (r: ReturnType<typeof accionesPermitidas>, accion: string) => r.find((a) => a.accion === accion);

describe('estados-embarque', () => {
  it('trae las etiquetas del enum del front para los 8 estados', () => {
    expect(ETIQUETA_ESTADO).toEqual({
      BORRADOR: 'Borrador', EN_TRANSITO: 'En tránsito', ARRIBADO: 'Arribado', EN_DESPACHO: 'En despacho',
      DESPACHADO: 'Despachado', LIBERADO: 'Liberado', CERRADO: 'Cerrado', SELLADO: 'Sellado',
    });
  });

  it('PATCH solo acepta BORRADOR→EN_TRANSITO, EN_TRANSITO→ARRIBADO, EN_TRANSITO→BORRADOR, ARRIBADO→EN_TRANSITO (tabla 8×8)', () => {
    const permitidas = new Set(['BORRADOR>EN_TRANSITO', 'EN_TRANSITO>ARRIBADO', 'EN_TRANSITO>BORRADOR', 'ARRIBADO>EN_TRANSITO']);
    for (const desde of IMP_ESTADOS_EMBARQUE) {
      for (const hasta of IMP_ESTADOS_EMBARQUE) {
        expect([desde, hasta, transicionPatchPermitida(desde, hasta)]).toEqual([desde, hasta, permitidas.has(`${desde}>${hasta}`)]);
      }
    }
    expect(Object.keys(TRANSICIONES_PATCH).sort()).toEqual([...IMP_ESTADOS_EMBARQUE].sort());
  });

  it('acción principal por estado', () => {
    expect(ACCION_PRINCIPAL).toEqual({
      BORRADOR: 'marcar_en_transito', EN_TRANSITO: 'marcar_arribado', ARRIBADO: 'cargar_despacho', EN_DESPACHO: 'confirmar_despacho',
      DESPACHADO: 'liberar', LIBERADO: 'cerrar', CERRADO: 'sellar', SELLADO: null,
    });
  });

  it('solo vienen las acciones del estado y con todos los permisos están permitidas', () => {
    const r = accionesPermitidas(base({ estado: 'BORRADOR' }), TODOS, SIN_PLAN);
    expect(r.map((a) => a.accion)).toEqual(['editar', 'eliminar', 'marcar_en_transito', 'agregar_item', 'agregar_costo']);
    expect(r.every((a) => a.permitida)).toBe(true);
    const arr = accionesPermitidas(base({ estado: 'ARRIBADO' }), TODOS, SIN_PLAN).map((a) => a.accion);
    expect(arr).toContain('volver_a_en_transito');
    expect(arr).toContain('cargar_despacho');
    expect(arr).not.toContain('liberar');
    const des = accionesPermitidas(base({ estado: 'EN_DESPACHO', despacho: { estado: 'BORRADOR', asiento_estado: null } }), TODOS, SIN_PLAN).map((a) => a.accion);
    expect(des).toEqual(expect.arrayContaining(['editar_despacho', 'eliminar_despacho', 'confirmar_despacho']));
  });

  it('EN_DESPACHO sin despacho (legado o ida y vuelta) ofrece cargar_despacho y no las del despacho; con despacho, no lo ofrece (P2)', () => {
    const sin = accionesPermitidas(base({ estado: 'EN_DESPACHO', despacho: null }), TODOS, SIN_PLAN).map((a) => a.accion);
    expect(sin).toContain('cargar_despacho');
    expect(sin).not.toContain('editar_despacho');
    expect(sin).not.toContain('confirmar_despacho');
    expect(sin).not.toContain('eliminar_despacho');
    const con = accionesPermitidas(base({ estado: 'EN_DESPACHO', despacho: { estado: 'BORRADOR', asiento_estado: null } }), TODOS, SIN_PLAN).map((a) => a.accion);
    expect(con).not.toContain('cargar_despacho');
    const sinPermiso = new Set([...TODOS].filter((p) => p !== 'IMP_DES_DESPACHO_CREAR'));
    expect(buscar(accionesPermitidas(base({ estado: 'EN_DESPACHO', despacho: null }), sinPermiso, SIN_PLAN), 'cargar_despacho')).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
  });

  it('LIBERADO sin CERRAR: liberar no viene y revertir viene con permitida false y SIN_PERMISO', () => {
    const permisos = new Set([...TODOS].filter((p) => p !== 'IMP_EMB_EMBARQUE_CERRAR'));
    const r = accionesPermitidas(base({ estado: 'LIBERADO' }), permisos, SIN_PLAN);
    expect(buscar(r, 'liberar')).toBeUndefined();
    expect(buscar(r, 'revertir_liberacion')).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
    expect(buscar(r, 'revertir_liberacion')?.motivo).toBeTruthy();
    expect(buscar(r, 'cerrar')).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
  });

  it('módulo apagado: todas las de escritura false con MODULO_INACTIVO, los reintentos siguen', () => {
    const r = accionesPermitidas(
      base({ estado: 'DESPACHADO', modulo_operativo_activo: false, tiene_contabilidad: true, despacho: { estado: 'CONFIRMADO', asiento_estado: 'PENDIENTE' } }),
      TODOS,
      SIN_PLAN,
    );
    for (const a of r) {
      if (a.accion === 'reintentar_asiento_despacho') expect(a).toMatchObject({ permitida: true });
      else expect(a).toMatchObject({ permitida: false, codigo: 'MODULO_INACTIVO' });
    }
    expect(buscar(r, 'reintentar_asiento_despacho')).toBeDefined();
  });

  it('DESPACHADO con asiento PENDIENTE y Contabilidad: liberar false con ASIENTO_DESPACHO_PENDIENTE; sin Contabilidad, true', () => {
    const despacho = { estado: 'CONFIRMADO', asiento_estado: 'PENDIENTE' };
    const con = accionesPermitidas(base({ estado: 'DESPACHADO', tiene_contabilidad: true, despacho }), TODOS, SIN_PLAN);
    expect(buscar(con, 'liberar')).toMatchObject({ permitida: false, codigo: 'ASIENTO_DESPACHO_PENDIENTE' });
    expect(buscar(con, 'reintentar_asiento_despacho')).toMatchObject({ permitida: true });
    const sin = accionesPermitidas(base({ estado: 'DESPACHADO', tiene_contabilidad: false, despacho }), TODOS, SIN_PLAN);
    expect(buscar(sin, 'liberar')).toMatchObject({ permitida: true });
    expect(buscar(sin, 'reintentar_asiento_despacho')).toBeUndefined();
    const ok = accionesPermitidas(base({ estado: 'DESPACHADO', tiene_contabilidad: true, despacho: { estado: 'CONFIRMADO', asiento_estado: 'GENERADO' } }), TODOS, SIN_PLAN);
    expect(buscar(ok, 'liberar')).toMatchObject({ permitida: true });
  });

  it('F20: eliminar desde DESPACHADO viene false (EMBARQUE_CON_MOVIMIENTOS) sin leer movimientos; antes, true', () => {
    expect(buscar(accionesPermitidas(base({ estado: 'EN_DESPACHO', despacho: { estado: 'BORRADOR', asiento_estado: null } }), TODOS, SIN_PLAN), 'eliminar')).toMatchObject({ permitida: true });
    expect(buscar(accionesPermitidas(base({ estado: 'DESPACHADO', despacho: { estado: 'CONFIRMADO', asiento_estado: 'GENERADO' } }), TODOS, SIN_PLAN), 'eliminar')).toMatchObject({
      permitida: false,
      codigo: 'EMBARQUE_CON_MOVIMIENTOS',
    });
  });

  it('LIBERADO con salidas posteriores: revertir false con REVERSION_CON_SALIDAS', () => {
    const r = accionesPermitidas(base({ estado: 'LIBERADO', hay_salidas_posteriores: true }), TODOS, SIN_PLAN);
    expect(buscar(r, 'revertir_liberacion')).toMatchObject({ permitida: false, codigo: 'REVERSION_CON_SALIDAS' });
    expect(buscar(r, 'cerrar')).toMatchObject({ permitida: true });
  });

  it('CERRADO con asiento de cierre PENDIENTE y Contabilidad: sellar false con ASIENTO_CIERRE_PENDIENTE y se ofrece reintentar', () => {
    const r = accionesPermitidas(base({ estado: 'CERRADO', tiene_contabilidad: true, asiento_cierre_estado: 'PENDIENTE' }), TODOS, SIN_PLAN);
    expect(buscar(r, 'sellar')).toMatchObject({ permitida: false, codigo: 'ASIENTO_CIERRE_PENDIENTE' });
    expect(buscar(r, 'reintentar_asiento_cierre')).toMatchObject({ permitida: true });
    expect(buscar(r, 'reabrir')).toMatchObject({ permitida: true });
    const sinConta = accionesPermitidas(base({ estado: 'CERRADO', tiene_contabilidad: false, asiento_cierre_estado: null }), TODOS, SIN_PLAN);
    expect(buscar(sinConta, 'sellar')).toMatchObject({ permitida: true });
    expect(buscar(sinConta, 'reintentar_asiento_cierre')).toBeUndefined();
  });

  it('CERRADO y SELLADO legados con el asiento del despacho pendiente ofrecen reintentarlo (parked T5); con el asiento resuelto, no', () => {
    const pendiente = { estado: 'CONFIRMADO', asiento_estado: 'PENDIENTE' };
    for (const estado of ['CERRADO', 'SELLADO'] as const) {
      const r = accionesPermitidas(base({ estado, tiene_contabilidad: true, despacho: pendiente, asiento_cierre_estado: 'GENERADO' }), TODOS, SIN_PLAN);
      expect(buscar(r, 'reintentar_asiento_despacho')).toMatchObject({ permitida: true });
      const ok = accionesPermitidas(base({ estado, tiene_contabilidad: true, despacho: { estado: 'CONFIRMADO', asiento_estado: 'GENERADO' } }), TODOS, SIN_PLAN);
      expect(buscar(ok, 'reintentar_asiento_despacho')).toBeUndefined();
      const sinConta = accionesPermitidas(base({ estado, tiene_contabilidad: false, despacho: pendiente }), TODOS, SIN_PLAN);
      expect(buscar(sinConta, 'reintentar_asiento_despacho')).toBeUndefined();
    }
  });

  it('perfil distinto bloquea editar con PERFIL_DISTINTO; CERRADO no es editable', () => {
    expect(buscar(accionesPermitidas(base({ estado: 'BORRADOR', perfil_distinto: true }), TODOS, SIN_PLAN), 'editar')).toMatchObject({ permitida: false, codigo: 'PERFIL_DISTINTO' });
    expect(buscar(accionesPermitidas(base({ estado: 'CERRADO' }), TODOS, SIN_PLAN), 'editar')).toMatchObject({ permitida: false, codigo: 'EMBARQUE_NO_EDITABLE' });
  });

  it('los motivos usan las etiquetas del enum, nunca los valores crudos', () => {
    const r = accionesPermitidas(base({ estado: 'DESPACHADO', despacho: { estado: 'CONFIRMADO', asiento_estado: 'GENERADO' } }), new Set(), SIN_PLAN);
    for (const a of r) if (a.motivo) expect(a.motivo).not.toMatch(/EN_TRANSITO|EN_DESPACHO|DESPACHADO|LIBERADO|CERRADO|SELLADO|BORRADOR/);
    const estados: EstadoEmbarque[] = [...IMP_ESTADOS_EMBARQUE];
    expect(estados).toHaveLength(8);
  });

  describe('plan de la empresa (SubmoduloGuard y capa 1.2 de PermissionGuard)', () => {
    const MSG_SUB = 'El submódulo "IMP_DESPACHOS" está deshabilitado para esta empresa';
    const MSG_ADDON = 'El submódulo "IMP_COSTOS" requiere un addon no contratado en su plan';
    const plan = (p: Partial<{ submodulos: Record<string, string>; privilegios: Record<string, string> }>): BloqueosDePlan => ({
      submodulos: new Map(Object.entries(p.submodulos ?? {})),
      privilegios: new Map(Object.entries(p.privilegios ?? {})),
    });

    it('cada acción va con el submódulo del endpoint (tabla de la Global) y las listas cubren todas', () => {
      expect(SUBMODULO_DE_ACCION).toMatchObject({
        editar: 'IMP_EMBARQUES', agregar_item: 'IMP_EMBARQUES', liberar: 'IMP_EMBARQUES', reintentar_asiento_cierre: 'IMP_EMBARQUES',
        agregar_costo: 'IMP_COSTOS', cargar_despacho: 'IMP_DESPACHOS', confirmar_despacho: 'IMP_DESPACHOS', reintentar_asiento_despacho: 'IMP_DESPACHOS',
      });
      expect([...SUBMODULOS_DE_ACCIONES].sort()).toEqual(['IMP_COSTOS', 'IMP_DESPACHOS', 'IMP_EMBARQUES']);
      expect(PRIVILEGIOS_DE_ACCIONES).toEqual(expect.arrayContaining([...TODOS]));
    });

    it('submódulo excluido: sus acciones false con SUBMODULO_NO_DISPONIBLE y el mensaje del guard; las demás siguen', () => {
      const despacho = { estado: 'BORRADOR', asiento_estado: null };
      const r = accionesPermitidas(base({ estado: 'EN_DESPACHO', despacho }), TODOS, plan({ submodulos: { IMP_DESPACHOS: MSG_SUB } }));
      for (const a of ['editar_despacho', 'eliminar_despacho', 'confirmar_despacho']) {
        expect(buscar(r, a)).toEqual({ accion: a, permitida: false, codigo: 'SUBMODULO_NO_DISPONIBLE', motivo: MSG_SUB });
      }
      expect(buscar(r, 'editar')).toMatchObject({ permitida: true });
      expect(buscar(r, 'agregar_costo')).toMatchObject({ permitida: true });
    });

    it('el plan va antes que el módulo apagado y que el permiso (el guard corta antes que el servicio)', () => {
      const pendiente = { estado: 'CONFIRMADO', asiento_estado: 'PENDIENTE' };
      const apagado = accionesPermitidas(
        base({ estado: 'DESPACHADO', modulo_operativo_activo: false, tiene_contabilidad: true, despacho: pendiente }),
        new Set(),
        plan({ submodulos: { IMP_DESPACHOS: MSG_SUB } }),
      );
      expect(buscar(apagado, 'reintentar_asiento_despacho')).toMatchObject({ permitida: false, codigo: 'SUBMODULO_NO_DISPONIBLE' });
      expect(buscar(apagado, 'editar')).toMatchObject({ permitida: false, codigo: 'MODULO_INACTIVO' });
    });

    it('privilegio de un addon no contratado (capa 1.2): la acción con ese privilegio false, también con TODOS (superadmin)', () => {
      const r = accionesPermitidas(base({ estado: 'BORRADOR' }), 'TODOS', plan({ privilegios: { IMP_COS_COSTO_CREAR: MSG_ADDON } }));
      expect(buscar(r, 'agregar_costo')).toEqual({ accion: 'agregar_costo', permitida: false, codigo: 'SUBMODULO_NO_DISPONIBLE', motivo: MSG_ADDON });
      expect(buscar(r, 'agregar_item')).toMatchObject({ permitida: true });
    });
  });
});
