import { ForbiddenException, Injectable } from '@nestjs/common';
import { AuditService } from 'src/audit/audit.service';
import { privilegiosDelUsuario } from 'src/auth/guards/algun-privilegio.guard';
import { solicitudInvalida } from 'src/common/utils/error-estructurado';
import { PrismaService } from 'src/prisma/prisma.service';
import { filtroUsuarioHabilitado } from 'src/users/estado-usuario';
import { AsignarAprobadoresDto } from './dto/aprobadores-config.dto';

const PRIVILEGIO_USUARIOS_VER = 'ADM_USR_USUARIO_VER';
const PRIVILEGIO_USUARIOS_EDITAR = 'ADM_USR_USUARIO_EDITAR';

/**
 * Asignar aprobadores (D10): qué usuarios tienen cada perfil de nivel de aprobación. Toca `usuario_perfiles`, así que además del
 * permiso de la configuración de Compras (que pide el controller) exige el de Usuarios: ver para leer, editar para escribir
 * (`RequirePermission` admite uno solo). Solo toca los perfiles de nivel de esta empresa: no pisa los demás perfiles del usuario.
 */
@Injectable()
export class AprobadoresConfigService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly auditService: AuditService,
  ) {}

  private async exigirPermisoUsuarios(usuarioId: string, escribe: boolean) {
    const privilegios = await privilegiosDelUsuario(this.prisma, usuarioId, 'ADMINISTRACION');
    const alcanza =
      privilegios === 'TODOS' ||
      privilegios.has(PRIVILEGIO_USUARIOS_EDITAR) ||
      (!escribe && privilegios.has(PRIVILEGIO_USUARIOS_VER));
    if (!alcanza) {
      throw new ForbiddenException({
        message: escribe
          ? 'Para asignar aprobadores necesitás poder editar usuarios (Administración › Usuarios).'
          : 'Para ver los aprobadores necesitás poder ver usuarios (Administración › Usuarios).',
        codigo: 'PERMISO_USUARIOS_REQUERIDO',
      });
    }
  }

  /** Perfiles de cualquier nivel guardado (activo o no) y todos los usuarios habilitados de la empresa, con sus perfiles de nivel. */
  async getAprobadores(empresaId: string, usuarioId: string) {
    await this.exigirPermisoUsuarios(usuarioId, false);
    const niveles = await this.prisma.requisicion_aprobacion_config.findMany({
      // Solo perfiles de la propia empresa: un nivel viejo con un perfil global o ajeno no se ofrece ni se asigna.
      where: { empresa_id: empresaId, perfiles: { empresa_id: empresaId } },
      select: { perfil_id: true },
      distinct: ['perfil_id'],
    });
    const idsNivel = niveles.map((n) => n.perfil_id);
    const [perfiles, usuarios] = await Promise.all([
      this.prisma.perfiles.findMany({
        where: { id: { in: idsNivel }, empresa_id: empresaId },
        select: { id: true, perfil: true, desc_perfil: true },
        orderBy: [{ desc_perfil: 'asc' }, { perfil: 'asc' }],
      }),
      this.prisma.usuario.findMany({
        where: { empresa_id: empresaId, ...filtroUsuarioHabilitado },
        select: {
          id: true,
          username: true,
          nombres: true,
          apellidos: true,
          usuario_perfiles: { where: { perfil_id: { in: idsNivel } }, select: { perfil_id: true } },
        },
        orderBy: [{ nombres: 'asc' }, { username: 'asc' }],
      }),
    ]);
    return {
      perfiles,
      usuarios: usuarios.map(({ usuario_perfiles, ...u }) => ({
        ...u,
        perfil_ids: usuario_perfiles.map((p) => p.perfil_id).filter((id): id is string => Boolean(id)),
      })),
    };
  }

  /**
   * Agrega los perfiles marcados y saca los desmarcados, solo entre los perfiles de nivel. Todo o nada: se valida todo antes de
   * escribir y las escrituras van en una transacción. Deja una sola constancia con el antes y el después por usuario.
   */
  async asignarAprobadores(empresaId: string, dto: AsignarAprobadoresDto, usuarioId: string) {
    await this.exigirPermisoUsuarios(usuarioId, true);
    return this.prisma.$transaction(async (tx) => {
      const nivelesGuardados = await tx.requisicion_aprobacion_config.findMany({
        // Solo perfiles de la propia empresa: un nivel viejo con un perfil global o ajeno no se asigna.
        where: { empresa_id: empresaId, perfiles: { empresa_id: empresaId } },
        select: { perfil_id: true },
        distinct: ['perfil_id'],
      });
      const perfilesDeNivel = new Set(nivelesGuardados.map((n) => n.perfil_id));

      const vistos = new Set<string>();
      dto.asignaciones.forEach((a, i) => {
        if (vistos.has(a.usuario_id)) {
          throw solicitudInvalida({ message: 'Un usuario no puede estar dos veces en el mismo guardado.', codigo: 'USUARIO_REPETIDO', campo: 'usuario_id', linea: i + 1 });
        }
        vistos.add(a.usuario_id);
      });

      const habilitados = await tx.usuario.findMany({
        where: { id: { in: [...vistos] }, empresa_id: empresaId, ...filtroUsuarioHabilitado },
        select: { id: true },
      });
      const idsHabilitados = new Set(habilitados.map((u) => u.id));
      dto.asignaciones.forEach((a, i) => {
        if (!idsHabilitados.has(a.usuario_id)) {
          throw solicitudInvalida({ message: 'El usuario no existe en la empresa o no está activo.', codigo: 'USUARIO_NO_ENCONTRADO', campo: 'usuario_id', linea: i + 1 });
        }
        if (a.perfil_ids.some((p) => !perfilesDeNivel.has(p))) {
          throw solicitudInvalida({ message: 'Uno de los perfiles no es de ningún nivel de aprobación.', codigo: 'PERFIL_NO_ES_DE_NIVEL', campo: 'perfil_ids', linea: i + 1 });
        }
      });

      const actuales = await tx.usuario_perfiles.findMany({
        where: { user_id: { in: [...vistos] }, perfil_id: { in: [...perfilesDeNivel] } },
        select: { user_id: true, perfil_id: true },
      });
      const antes: Record<string, string[]> = {};
      const despues: Record<string, string[]> = {};
      let actualizados = 0;
      for (const a of dto.asignaciones) {
        const tenia = new Set(actuales.filter((x) => x.user_id === a.usuario_id).map((x) => x.perfil_id as string));
        const quiere = new Set(a.perfil_ids);
        const sacar = [...tenia].filter((p) => !quiere.has(p));
        const agregar = [...quiere].filter((p) => !tenia.has(p));
        antes[a.usuario_id] = [...tenia].sort();
        despues[a.usuario_id] = [...quiere].sort();
        if (!sacar.length && !agregar.length) continue;
        if (sacar.length) await tx.usuario_perfiles.deleteMany({ where: { user_id: a.usuario_id, perfil_id: { in: sacar } } });
        if (agregar.length) await tx.usuario_perfiles.createMany({ data: agregar.map((perfil_id) => ({ user_id: a.usuario_id, perfil_id })) });
        actualizados++;
      }

      // Un guardado sin cambios no deja fila de auditoría (como Opciones).
      if (actualizados > 0) {
        await this.auditService.logEnTransaccion(tx, {
          empresa_id: empresaId,
          user_id: usuarioId,
          action: 'APROBADORES_ASIGNADOS',
          entity_type: 'usuario_perfiles',
          old_value: antes,
          new_value: despues,
        });
      }
      return { usuarios_actualizados: actualizados };
    });
  }
}
