import { BadRequestException, ConflictException } from '@nestjs/common';
import { ActividadesGymService } from './actividades-gym.service';
import { PlanesGymService } from './planes-gym.service';
import { ServiciosGymService } from './servicios-gym.service';
import { StaffGymService } from '../staff/staff-gym.service';
import { SedesGymService } from '../sedes/sedes-gym.service';

/** Reactivar un plan, servicio o actividad dado de baja (la baja ya no es definitiva). */
describe('gimnasio — reactivar el catálogo', () => {
  const EMP = 'emp-1';
  const audit = { log: jest.fn().mockResolvedValue(undefined) };

  const tabla = (registro: Record<string, unknown> | null, choque: Record<string, unknown> | null = null) => ({
    // Primero busca el registro; después, si otro activo tiene el mismo nombre.
    findFirst: jest.fn().mockResolvedValueOnce(registro).mockResolvedValueOnce(choque),
    update: jest.fn(({ data }: any) => Promise.resolve({ ...registro, ...data })),
  });

  it('actividad dada de baja: vuelve activa y queda en la auditoría', async () => {
    const gym_actividades = tabla({ id: 'a1', empresa_id: EMP, nombre: 'Pilates', activo: false });
    const svc = new ActividadesGymService({ gym_actividades } as any, audit as any);
    const r = await svc.reactivar('a1', EMP, 'u1');
    expect(r.activo).toBe(true);
    expect(gym_actividades.findFirst.mock.calls[0][0].where).toMatchObject({ id: 'a1', empresa_id: EMP });
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({ action: 'REACTIVAR', entity_type: 'gym_actividad' }),
    );
  });

  it('si otra actividad activa ya usa el nombre, 409 y no cambia nada', async () => {
    const gym_actividades = tabla({ id: 'a1', empresa_id: EMP, nombre: 'Pilates', activo: false }, { id: 'a2' });
    const svc = new ActividadesGymService({ gym_actividades } as any, audit as any);
    await expect(svc.reactivar('a1', EMP)).rejects.toBeInstanceOf(ConflictException);
    expect(gym_actividades.update).not.toHaveBeenCalled();
  });

  it('una activa no se toca', async () => {
    const gym_actividades = tabla({ id: 'a1', empresa_id: EMP, nombre: 'Pilates', activo: true });
    const svc = new ActividadesGymService({ gym_actividades } as any, audit as any);
    await svc.reactivar('a1', EMP);
    expect(gym_actividades.update).not.toHaveBeenCalled();
  });

  it('plan con una actividad que sigue de baja: 400 que lo dice', async () => {
    const plan = {
      id: 'p1',
      empresa_id: EMP,
      nombre: 'Mensual',
      activo: false,
      sedes_permitidas: [],
      actividades_incluidas: ['a-baja'],
      creditos_actividades: [],
      matricula_producto_id: null,
    };
    const prisma: any = {
      gym_planes: tabla(plan),
      gym_sedes: { findMany: jest.fn().mockResolvedValue([]) },
      gym_actividades: { findMany: jest.fn().mockResolvedValue([]) },
    };
    const svc = new PlanesGymService(prisma, audit as any, {} as any);
    await expect(svc.reactivar('p1', EMP)).rejects.toBeInstanceOf(BadRequestException);
    expect(prisma.gym_planes.update).not.toHaveBeenCalled();
  });

  it('servicio con sus salas activas: vuelve activo', async () => {
    const servicio = {
      id: 's1',
      empresa_id: EMP,
      nombre: 'Masaje',
      activo: false,
      modalidad: 'TURNO',
      actividad_id: null,
      sala_ids: ['c1'],
    };
    const prisma: any = {
      gym_servicios: tabla(servicio),
      gym_salas: {
        findMany: jest
          .fn()
          .mockResolvedValueOnce([{ id: 'c1' }])
          .mockResolvedValueOnce([{ nombre: 'Cabina 1', tipo: 'CABINA' }]),
      },
    };
    const svc = new ServiciosGymService(prisma, audit as any, {} as any);
    const r = await svc.reactivar('s1', EMP);
    expect(r.activo).toBe(true);
    expect(prisma.gym_salas.findMany.mock.calls[0][0].where).toMatchObject({ empresa_id: EMP, activo: true });
  });

  it('staff: si otra persona activa tiene la cédula, 409; si no, vuelve activa sin el pin', async () => {
    const persona = { id: 'st1', empresa_id: EMP, nombre: 'Teresa', ci: '1234567', activo: false, pin_hash: 'x', empleado_id: null, actividad_ids: [], servicio_ids: [], sede_ids: [] };
    const conChoque: any = { gym_staff: tabla(persona, { nombre: 'Otra' }) };
    await expect(new StaffGymService(conChoque, audit as any).reactivar('st1', EMP)).rejects.toBeInstanceOf(ConflictException);
    const libre: any = { gym_staff: tabla(persona) };
    const r: any = await new StaffGymService(libre, audit as any).reactivar('st1', EMP);
    expect(r.activo).toBe(true);
    expect(r.pin_hash).toBeUndefined();
    expect(r.tiene_pin).toBe(true);
  });

  it('sala: con la sede dada de baja, 409 que pide reactivarla primero', async () => {
    const prisma: any = {
      gym_salas: tabla({ id: 'c1', empresa_id: EMP, sede_id: 'sd1', nombre: 'Cabina 1', activo: false }),
      gym_sedes: { findFirst: jest.fn().mockResolvedValue({ id: 'sd1', empresa_id: EMP, activo: false }) },
    };
    await expect(new SedesGymService(prisma, audit as any).reactivarSala('c1', EMP)).rejects.toThrow('reactivala primero');
    expect(prisma.gym_salas.update).not.toHaveBeenCalled();
  });

  it('sede: si su sucursal ya es otra sede activa, 409', async () => {
    const prisma: any = {
      gym_sedes: tabla({ id: 'sd1', empresa_id: EMP, sucursal_id: 'su1', deposito_id: null, caja_id: null, nombre: 'Centro', activo: false }, { nombre: 'Otra' }),
    };
    await expect(new SedesGymService(prisma, audit as any).reactivar('sd1', EMP)).rejects.toBeInstanceOf(ConflictException);
  });
});
