import { ConflictException, UnauthorizedException } from '@nestjs/common';
import * as bcrypt from 'bcrypt';
import { AuthService } from 'src/auth/auth.service';
import { UsersService } from './users.service';
import { activeSegunEstado, camposEstadoUsuario, filtroUsuarioHabilitado, usuarioHabilitado } from './estado-usuario';

/**
 * U11: un solo estado del usuario. U21: no se desactiva con caja abierta.
 * H11: reactivar controla el límite del plan. U9: email repetido = 409.
 */
describe('estado único del usuario', () => {
  it('habilitado solo con estado Activo y active distinto de false', () => {
    expect(usuarioHabilitado({ estado: 'Activo', active: true })).toBe(true);
    expect(usuarioHabilitado({ estado: 'Activo', active: null })).toBe(true);
    expect(usuarioHabilitado({ estado: 'Activo', active: false })).toBe(false);
    expect(usuarioHabilitado({ estado: 'Inactivo', active: true })).toBe(false);
    expect(usuarioHabilitado({ estado: 'Pendiente', active: true })).toBe(false);
  });

  it('activar/desactivar escribe los dos campos', () => {
    expect(camposEstadoUsuario(true)).toEqual({ estado: 'Activo', active: true });
    expect(camposEstadoUsuario(false)).toEqual({ estado: 'Inactivo', active: false });
    expect(activeSegunEstado('Inactivo')).toBe(false);
    expect(activeSegunEstado('Pendiente')).toBe(true);
  });
});

describe('filtroUsuarioHabilitado', () => {
  it('es el where de Prisma que incluye a los active NULL (NOT active = false los excluiría en SQL)', () => {
    expect(filtroUsuarioHabilitado).toEqual({ estado: 'Activo', OR: [{ active: true }, { active: null }] });
    // Nada de NOT sobre una columna nullable: Prisma lo traduce a `NOT "active" = false`, que es NULL para los NULL.
    expect(JSON.stringify(filtroUsuarioHabilitado)).not.toContain('NOT');
  });

  it('cubre los mismos estados que usuarioHabilitado: Activo con active true o null; nunca false ni otro estado', () => {
    const acepta = (u: { estado?: string | null; active?: boolean | null }) =>
      u.estado === filtroUsuarioHabilitado.estado && filtroUsuarioHabilitado.OR.some((c) => c.active === (u.active ?? null));
    for (const estado of ['Activo', 'Inactivo', 'Bloqueado', 'Eliminado', 'Pendiente', null]) {
      for (const active of [true, false, null]) {
        expect(acepta({ estado, active })).toBe(usuarioHabilitado({ estado, active }));
      }
    }
  });
});

describe('UsersService.activarDesactivar', () => {
  const crear = (usuario: Record<string, unknown>, sesion: unknown = null) => {
    const service = Object.create(UsersService.prototype) as any;
    service.logger = { log: jest.fn(), error: jest.fn() };
    service.auditService = { log: jest.fn() };
    service.planLimits = { checkLimit: jest.fn().mockResolvedValue(undefined) };
    service.assertUsuarioEnAlcance = jest.fn().mockResolvedValue(usuario);
    service.prisma = {
      usuario: {
        findUnique: jest.fn().mockResolvedValue({ username: 'cajero1', empresa_id: 'emp', ...usuario }),
        update: jest.fn(async ({ data }: any) => ({ id: 'u1', ...data })),
      },
      sesiones_caja: { findFirst: jest.fn().mockResolvedValue(sesion) },
    };
    return service;
  };

  it('desactivar escribe Inactivo + active=false', async () => {
    const service = crear({ estado: 'Activo', active: true });
    await service.activarDesactivar('u1', 'actor', 'emp');
    expect(service.prisma.usuario.update).toHaveBeenCalledWith({
      where: { id: 'u1' },
      data: { estado: 'Inactivo', active: false },
    });
  });

  it('un usuario "Activo" con active=false (estado mezclado) se ACTIVA, y controla el plan', async () => {
    const service = crear({ estado: 'Activo', active: false });
    await service.activarDesactivar('u1', 'actor', 'emp');
    expect(service.planLimits.checkLimit).toHaveBeenCalledWith('emp', 'usuarios');
    expect(service.prisma.usuario.update).toHaveBeenCalledWith({
      where: { id: 'u1' },
      data: { estado: 'Activo', active: true },
    });
  });

  it('reactivar con el plan lleno no activa', async () => {
    const service = crear({ estado: 'Inactivo', active: false });
    service.planLimits.checkLimit.mockRejectedValue(new Error('Límite de usuarios alcanzado'));
    await expect(service.activarDesactivar('u1', 'actor', 'emp')).rejects.toThrow();
    expect(service.prisma.usuario.update).not.toHaveBeenCalled();
  });

  it('con una caja abierta no se desactiva y dice cuál', async () => {
    const service = crear(
      { estado: 'Activo', active: true },
      { cajas: { descripcion: 'Caja 1', empresas_sucursales: { descripcion: 'Matriz' } } },
    );
    const err = await service.activarDesactivar('u1', 'actor', 'emp').catch((e: unknown) => e);
    expect(err).toBeInstanceOf(ConflictException);
    expect((err as Error).message).toContain('«Caja 1» (Matriz)');
    expect(service.prisma.usuario.update).not.toHaveBeenCalled();
  });
});

describe('UsersService email repetido', () => {
  it('assertEmailDisponible responde 409 si otro usuario lo tiene', async () => {
    const service = Object.create(UsersService.prototype) as any;
    service.prisma = { usuario: { findFirst: jest.fn().mockResolvedValue({ id: 'otro' }) } };
    await expect(service.assertEmailDisponible('a@b.com', 'u1')).rejects.toBeInstanceOf(ConflictException);
    expect(service.prisma.usuario.findFirst).toHaveBeenCalledWith({
      where: { email: { equals: 'a@b.com', mode: 'insensitive' }, NOT: { id: 'u1' } },
      select: { id: true },
    });
  });

  it('email vacío no consulta', async () => {
    const service = Object.create(UsersService.prototype) as any;
    service.prisma = { usuario: { findFirst: jest.fn() } };
    await service.assertEmailDisponible('  ');
    expect(service.prisma.usuario.findFirst).not.toHaveBeenCalled();
  });
});

describe('UsersService.actualizarMiPerfil', () => {
  const crear = async () => {
    const service = Object.create(UsersService.prototype) as any;
    service.auditService = { log: jest.fn() };
    service.prisma = {
      usuario: {
        findUnique: jest.fn().mockResolvedValue({
          id: 'u1',
          username: 'cajero1',
          empresa_id: 'emp',
          password: await bcrypt.hash('vieja123', 4),
        }),
        findFirst: jest.fn().mockResolvedValue(null),
        update: jest.fn(async ({ data }: any) => ({ id: 'u1', ...data })),
      },
    };
    return service;
  };

  it('cambia la contraseña con la actual correcta', async () => {
    const service = await crear();
    await service.actualizarMiPerfil('u1', { password_actual: 'vieja123', password_nueva: 'nueva123' });
    const data = service.prisma.usuario.update.mock.calls[0][0].data;
    expect(await bcrypt.compare('nueva123', data.password)).toBe(true);
  });

  it('sin la contraseña actual o con una incorrecta no la cambia', async () => {
    const service = await crear();
    await expect(service.actualizarMiPerfil('u1', { password_nueva: 'nueva123' })).rejects.toThrow('contraseña actual');
    await expect(
      service.actualizarMiPerfil('u1', { password_actual: 'otra', password_nueva: 'nueva123' }),
    ).rejects.toThrow('no es correcta');
    expect(service.prisma.usuario.update).not.toHaveBeenCalled();
  });
});

describe('AuthService.login / refresh con el estado único', () => {
  const crear = async (usuario: Record<string, unknown>) => {
    const service = Object.create(AuthService.prototype) as any;
    service.prisma = {
      usuario: {
        findFirst: jest.fn().mockResolvedValue({ id: 'u1', username: 'x', password: await bcrypt.hash('clave123', 4), ...usuario }),
        findUnique: jest.fn().mockResolvedValue({ id: 'u1', username: 'x', empresa_id: 'emp', ...usuario }),
      },
    };
    service.jwtService = { verifyAsync: jest.fn().mockResolvedValue({ sub: 'u1', jti: 'j1' }) };
    service.redis = { get: jest.fn().mockResolvedValue('u1'), del: jest.fn() };
    service.config = { get: jest.fn() };
    return service;
  };

  it('desactivado desde la lista (active=false): el login lo rechaza con mensaje claro', async () => {
    const service = await crear({ estado: 'Activo', active: false });
    const err = await service.login({ usuario: 'x', password: 'clave123' }).catch((e: unknown) => e);
    expect(err).toBeInstanceOf(UnauthorizedException);
    expect((err as Error).message).toContain('Usuario desactivado');
  });

  it('con contraseña incorrecta no revela que está desactivado', async () => {
    const service = await crear({ estado: 'Inactivo', active: false });
    await expect(service.login({ usuario: 'x', password: 'mala' })).rejects.toThrow('Credenciales inválidas');
  });

  it('refresh de un usuario desactivado después de entrar: no renueva', async () => {
    const service = await crear({ estado: 'Inactivo', active: false });
    await expect(service.refresh('token')).rejects.toThrow('Usuario desactivado');
  });
});
