import {
  gym_apto_fisico_modo,
  gym_acceso_resultado as R,
  gym_alcance_sedes,
  gym_duracion_unidad,
  gym_modo_vencido,
  gym_plan_tipo,
  gym_renovacion_desde,
  gym_socio_estado,
} from '@prisma/client';
import { decidirAcceso, EntradaAcceso, MembresiaAcceso, RESULTADOS_PERMITIDOS } from './acceso-reglas';
import { calcularVigencia, diaPy, edadEn, horaPy, sumarMeses } from './fechas-gym';

const MENSUAL = {
  tipo: gym_plan_tipo.PERIODO,
  duracion_valor: 1,
  duracion_unidad: gym_duracion_unidad.MES,
  creditos: null,
  vencimiento_creditos_dias: null,
};

describe('fechas del gimnasio', () => {
  it('el día y la hora son los de Asunción, no los de UTC', () => {
    // 02:30 UTC del 05/11 = 23:30 del 04/11 en Asunción (UTC-3).
    const instante = new Date('2026-11-05T02:30:00Z');
    expect(diaPy(instante)).toBe('2026-11-04');
    expect(horaPy(instante)).toBe('23:30');
  });

  it('sumar meses no se pasa del último día del mes', () => {
    expect(sumarMeses('2026-01-31', 1)).toBe('2026-02-28');
    expect(sumarMeses('2026-11-15', 3)).toBe('2027-02-15');
  });

  it('edad cumplida', () => {
    expect(edadEn('2013-11-05', '2026-11-04')).toBe(12);
    expect(edadEn('2013-11-04', '2026-11-04')).toBe(13);
  });
});

describe('vigencia de una membresía nueva', () => {
  const base = { plan: MENSUAL, periodos: 1, renovacionDesde: gym_renovacion_desde.FIN_ANTERIOR };

  it('primera vez: un mes desde el día de la venta', () => {
    expect(calcularVigencia({ ...base, diaVenta: '2026-11-04', anteriorFin: null })).toEqual({
      fecha_inicio: '2026-11-04',
      fecha_fin: '2026-12-03',
      creditos_totales: null,
    });
  });

  it('renovación anticipada: arranca al día siguiente del vencimiento', () => {
    const v = calcularVigencia({ ...base, diaVenta: '2026-11-04', anteriorFin: '2026-11-10' });
    expect(v.fecha_inicio).toBe('2026-11-11');
    expect(v.fecha_fin).toBe('2026-12-10');
  });

  it('renovó tarde con FIN_ANTERIOR: cuenta desde el vencimiento (los días vencido no son gratis)', () => {
    const v = calcularVigencia({ ...base, diaVenta: '2026-11-04', anteriorFin: '2026-10-25' });
    expect(v.fecha_inicio).toBe('2026-10-26');
    expect(v.fecha_fin).toBe('2026-11-25');
  });

  it('volvió después de más de un período: arranca el día de la venta', () => {
    const v = calcularVigencia({ ...base, diaVenta: '2026-11-04', anteriorFin: '2026-06-30' });
    expect(v.fecha_inicio).toBe('2026-11-04');
  });

  it('renovó tarde con FECHA_PAGO: arranca el día de la venta', () => {
    const v = calcularVigencia({
      ...base,
      renovacionDesde: gym_renovacion_desde.FECHA_PAGO,
      diaVenta: '2026-11-04',
      anteriorFin: '2026-10-25',
    });
    expect(v.fecha_inicio).toBe('2026-11-04');
  });

  it('3 × mensual = un período de 3 meses', () => {
    expect(calcularVigencia({ ...base, periodos: 3, diaVenta: '2026-11-04', anteriorFin: null }).fecha_fin).toBe('2027-02-03');
  });

  it('un pase no se encadena', () => {
    const pase = { ...MENSUAL, tipo: gym_plan_tipo.PASE, duracion_valor: 1, duracion_unidad: gym_duracion_unidad.DIA };
    const v = calcularVigencia({ ...base, plan: pase, diaVenta: '2026-11-04', anteriorFin: '2026-11-20' });
    expect(v).toMatchObject({ fecha_inicio: '2026-11-04', fecha_fin: '2026-11-04' });
  });

  it('paquete de créditos: vence a los N días y multiplica los créditos', () => {
    const pack = { ...MENSUAL, tipo: gym_plan_tipo.CREDITOS, duracion_valor: null, duracion_unidad: null, creditos: 10, vencimiento_creditos_dias: 60 };
    expect(calcularVigencia({ ...base, plan: pack, periodos: 2, diaVenta: '2026-11-04', anteriorFin: null })).toEqual({
      fecha_inicio: '2026-11-04',
      fecha_fin: '2027-01-02',
      creditos_totales: 20,
    });
  });
});

describe('decisión del ingreso', () => {
  const plan = (extra: Partial<MembresiaAcceso['plan']> = {}): MembresiaAcceso['plan'] => ({
    nombre: 'Mensual',
    tipo: gym_plan_tipo.PERIODO,
    alcance_sedes: gym_alcance_sedes.SEDE_BASE,
    sedes_permitidas: [],
    hora_desde: null,
    hora_hasta: null,
    ...extra,
  });
  const memb = (extra: Partial<MembresiaAcceso> = {}): MembresiaAcceso => ({
    id: 'm1',
    fecha_inicio: '2026-10-05',
    fecha_fin: '2026-11-04',
    sede_base_id: 'sede-a',
    creditos_totales: null,
    creditos_usados: 0,
    ultimo_credito_fecha: null,
    plan: plan(),
    ...extra,
  });
  const entrada = (extra: Partial<EntradaAcceso> = {}): EntradaAcceso => ({
    socio: { estado: gym_socio_estado.ACTIVO, sede_base_id: 'sede-a' },
    membresias: [memb()],
    sedeId: 'sede-a',
    dia: '2026-11-04',
    hora: '18:00',
    config: { modo_vencido: gym_modo_vencido.AVISAR, dias_gracia: 0, minutos_antipassback: 0 },
    minutosDesdeUltimoIngreso: null,
    ...extra,
  });

  describe('apto físico', () => {
    const conApto = (modo: gym_apto_fisico_modo, vence: string | null, extra: Partial<EntradaAcceso> = {}) =>
      entrada({
        socio: { estado: gym_socio_estado.ACTIVO, sede_base_id: 'sede-a', apto_fisico_vence: vence },
        config: { modo_vencido: gym_modo_vencido.AVISAR, dias_gracia: 0, minutos_antipassback: 0, apto_fisico_modo: modo },
        ...extra,
      });
    it('OFF (primer cliente): no cambia nada aunque no tenga apto', () => {
      expect(decidirAcceso(conApto(gym_apto_fisico_modo.OFF, null)).resultado).toBe(R.PERMITIDO);
    });
    it('vigente: no cambia nada', () => {
      expect(decidirAcceso(conApto(gym_apto_fisico_modo.BLOQUEAR, '2026-12-31')).resultado).toBe(R.PERMITIDO);
    });
    it('AVISAR sin apto: entra en amarillo con el aviso', () => {
      const d = decidirAcceso(conApto(gym_apto_fisico_modo.AVISAR, null));
      expect(d).toMatchObject({ resultado: R.ALERTA_APTO, semaforo: 'AMARILLO', membresia_id: 'm1' });
      expect(d.mensaje).toContain('No presentó el apto físico');
    });
    it('AVISAR con plan vencido: conserva ALERTA_VENCIDA (alimenta su reporte) y suma el aviso', () => {
      const d = decidirAcceso(conApto(gym_apto_fisico_modo.AVISAR, '2026-11-01', { dia: '2026-11-09' }));
      expect(d.resultado).toBe(R.ALERTA_VENCIDA);
      expect(d.mensaje).toContain('El apto físico venció el 01/11/2026');
    });
    it('BLOQUEAR vencido: rojo', () => {
      const d = decidirAcceso(conApto(gym_apto_fisico_modo.BLOQUEAR, '2026-11-03'));
      expect(d).toMatchObject({ resultado: R.RECHAZADO_APTO, semaforo: 'ROJO' });
    });
    it('un rechazo por otra causa queda como está', () => {
      const d = decidirAcceso(conApto(gym_apto_fisico_modo.BLOQUEAR, null, { sedeId: 'sede-b' }));
      expect(d.resultado).toBe(R.RECHAZADO_SEDE);
    });
  });

  it('vigente: verde', () => {
    const d = decidirAcceso(entrada());
    expect(d).toMatchObject({ resultado: R.PERMITIDO, semaforo: 'VERDE', membresia_id: 'm1' });
    expect(d.mensaje).toContain('vence hoy');
  });

  it('vencido con AVISAR (primer cliente): amarillo, entra, con los días de atraso', () => {
    const d = decidirAcceso(entrada({ dia: '2026-11-09' }));
    expect(d).toMatchObject({ resultado: R.ALERTA_VENCIDA, semaforo: 'AMARILLO', dias_vencida: 5 });
    expect(d.mensaje).toContain('vencido hace 5 días');
  });

  it('GRACIA_Y_BLOQUEO: amarillo dentro de la gracia, rojo después', () => {
    const config = { modo_vencido: gym_modo_vencido.GRACIA_Y_BLOQUEO, dias_gracia: 3, minutos_antipassback: 0 };
    expect(decidirAcceso(entrada({ config, dia: '2026-11-07' })).resultado).toBe(R.ALERTA_GRACIA);
    expect(decidirAcceso(entrada({ config, dia: '2026-11-08' })).resultado).toBe(R.RECHAZADO_VENCIDA);
  });

  it('BLOQUEAR: rojo desde el día siguiente', () => {
    const config = { modo_vencido: gym_modo_vencido.BLOQUEAR, dias_gracia: 0, minutos_antipassback: 0 };
    expect(decidirAcceso(entrada({ config, dia: '2026-11-05' })).semaforo).toBe('ROJO');
  });

  it('otra sede con plan SEDE_BASE: rojo; con TODAS: verde', () => {
    expect(decidirAcceso(entrada({ sedeId: 'sede-b' })).resultado).toBe(R.RECHAZADO_SEDE);
    const todas = memb({ plan: plan({ alcance_sedes: gym_alcance_sedes.TODAS }) });
    expect(decidirAcceso(entrada({ sedeId: 'sede-b', membresias: [todas] })).resultado).toBe(R.PERMITIDO);
  });

  it('fuera de la franja horaria: rojo (también con franja que cruza la medianoche)', () => {
    const manana = memb({ plan: plan({ hora_desde: '06:00', hora_hasta: '14:00' }) });
    expect(decidirAcceso(entrada({ membresias: [manana] })).resultado).toBe(R.RECHAZADO_FRANJA);
    const noche = memb({ plan: plan({ hora_desde: '22:00', hora_hasta: '06:00' }) });
    expect(decidirAcceso(entrada({ membresias: [noche], hora: '23:30' })).resultado).toBe(R.PERMITIDO);
  });

  it('socio suspendido y antipassback: rojo', () => {
    expect(decidirAcceso(entrada({ socio: { estado: gym_socio_estado.SUSPENDIDO, sede_base_id: null } })).resultado).toBe(
      R.RECHAZADO_SOCIO,
    );
    const config = { modo_vencido: gym_modo_vencido.AVISAR, dias_gracia: 0, minutos_antipassback: 30 };
    expect(decidirAcceso(entrada({ config, minutosDesdeUltimoIngreso: 10 })).resultado).toBe(R.RECHAZADO_ANTIPASSBACK);
  });

  it('paquete de créditos: descuenta uno, y no otra vez el mismo día', () => {
    const pack = memb({ plan: plan({ tipo: gym_plan_tipo.CREDITOS, nombre: 'Pilates x8' }), creditos_totales: 8, creditos_usados: 2 });
    expect(decidirAcceso(entrada({ membresias: [pack] }))).toMatchObject({ resultado: R.PERMITIDO, consumir_credito: true });
    const hoy = { ...pack, ultimo_credito_fecha: '2026-11-04' };
    expect(decidirAcceso(entrada({ membresias: [hoy] }))).toMatchObject({ resultado: R.PERMITIDO, consumir_credito: false });
    const agotado = { ...pack, creditos_usados: 8 };
    expect(decidirAcceso(entrada({ membresias: [agotado] })).resultado).toBe(R.RECHAZADO_SIN_CREDITOS);
  });

  it('el pase de la semana que viene todavía no vale', () => {
    const futura = memb({ fecha_inicio: '2026-11-10', fecha_fin: '2026-11-10', plan: plan({ tipo: gym_plan_tipo.PASE, nombre: 'Pase diario' }) });
    const d = decidirAcceso(entrada({ membresias: [futura] }));
    expect(d.resultado).toBe(R.RECHAZADO_SIN_MEMBRESIA);
    expect(d.mensaje).toContain('empieza el 10/11/2026');
  });

  it('sin nada: rojo', () => {
    expect(decidirAcceso(entrada({ membresias: [] })).resultado).toBe(R.RECHAZADO_SIN_MEMBRESIA);
  });

  describe('socio sin plan con «dejar pasar con aviso»', () => {
    const conAviso = { modo_vencido: gym_modo_vencido.BLOQUEAR, dias_gracia: 0, minutos_antipassback: 0, sin_plan_con_aviso: true };

    it('entra en amarillo, sin membresía asociada, y cuenta como ingreso permitido', () => {
      const d = decidirAcceso(entrada({ membresias: [], config: conAviso }));
      expect(d).toMatchObject({ resultado: R.ALERTA_SIN_PLAN, semaforo: 'AMARILLO', membresia_id: null, consumir_credito: false });
      expect(d.mensaje).toContain('No tiene un plan activo');
      expect(RESULTADOS_PERMITIDOS).toContain(R.ALERTA_SIN_PLAN);
    });

    it('no afloja nada más: suspendido, plan futuro, paquete agotado y vencido con BLOQUEAR siguen sin entrar', () => {
      const suspendido = { estado: gym_socio_estado.SUSPENDIDO, sede_base_id: 'sede-a' };
      expect(decidirAcceso(entrada({ membresias: [], socio: suspendido, config: conAviso })).resultado).toBe(R.RECHAZADO_SOCIO);
      const futura = memb({ fecha_inicio: '2026-11-10', fecha_fin: '2026-12-09' });
      expect(decidirAcceso(entrada({ membresias: [futura], config: conAviso })).resultado).toBe(R.RECHAZADO_SIN_MEMBRESIA);
      const vencida = memb({ fecha_inicio: '2026-09-01', fecha_fin: '2026-10-01' });
      expect(decidirAcceso(entrada({ membresias: [vencida], config: conAviso })).resultado).toBe(R.RECHAZADO_VENCIDA);
    });

    it('con apto físico en BLOQUEAR, sin apto tampoco entra', () => {
      const d = decidirAcceso(
        entrada({
          membresias: [],
          socio: { estado: gym_socio_estado.ACTIVO, sede_base_id: 'sede-a', apto_fisico_vence: null },
          config: { ...conAviso, apto_fisico_modo: gym_apto_fisico_modo.BLOQUEAR },
        }),
      );
      expect(d.resultado).toBe(R.RECHAZADO_APTO);
    });
  });
});
