Function bodies 439 total

function generarJugadores() {
  const jugadores: {
    documento: string;
    nombre: string;
    apellido: string;
    genero: 'MASCULINO' | 'FEMENINO';
    email: string;
    telefono: string;
    ciudad: string;
  }[] = [];

  // 48 hombres (docs 2000001-2000048)
  for (let i = 0; i < 48; i++) {
    const doc = `${2000001 + i}`;
    jugadores.push({
      documento: doc,
      nombre: nombresM[i],
      apellido: apellidos[i],
      genero: 'MASCULINO',
      email: `jugador.m${i + 1}@test.com`,
      telefono: `+5959820${String(i + 1).padStart(5, '0')}`,
      ciudad: ciudades[i % ciudades.length],
    });
  }

  // 48 mujeres (docs 3000001-3000048)
  for (let i = 0; i < 48; i++) {
    const doc = `${3000001 + i}`;
    jugadores.push({
      documento: doc,
      nombre: nombresF[i],
      apellido: apellidos[i],
      genero: 'FEMENINO',
      email: `jugadora.f${i + 1}@test.com`,
      telefono: `+5959830${String(i + 1).padStart(5, '0')}`,
      ciudad: ciudades[i % ciudades.leng

  async function inscribirParejas(
    players: any[],
    startIdx: number,
    categoryId: string,
    targetPairs: number,
  ) {
    let created = 0;

    for (let i = startIdx; i < players.length - 1 && created < targetPairs; i += 2) {
      const j1 = players[i];
      const j2 = players[i + 1];

      // Verificar si ya existe pareja inscrita en esta categoría del torneo
      const existingInscripcion = await prisma.inscripcion.findFirst({
        where: {
          tournamentId: torneo.id,
          categoryId,
          pareja: {
            OR: [
              { jugador1Id: j1.id, jugador2Id: j2.id },
              { jugador1Id: j2.id, jugador2Id: j1.id },
            ],
          },
        },
      });

      if (existingInscripcion) {
        created++;
        continue;
      }

      const pareja = await prisma.pareja.create({
        data: {
          jugador1Id: j1.id,
          jugador2Id: j2.id,
          jugador2Documento: j2.documento,
        },
      });

      c

async function main() {
  const tournamentId = process.argv[2];
  if (!tournamentId) {
    console.error('❌ Uso: npx ts-node prisma/seed-torneo-masivo.ts <tournamentId>');
    process.exit(1);
  }

  // ── 1. Fetch tournament + categories ──
  const torneo = await prisma.tournament.findUnique({
    where: { id: tournamentId },
    include: {
      categorias: { include: { category: true } },
      modalidades: true,
    },
  });

  if (!torneo) {
    console.error(`❌ Torneo "${tournamentId}" no encontrado`);
    process.exit(1);
  }

  console.log(`\n🏆 Torneo: "${torneo.nombre}" (${torneo.estado})`);
  console.log(`   Categorías: ${torneo.categorias.length}`);

  // Map category name patterns to TournamentCategory IDs
  const catMap: Record<string, { tcId: string; catId: string; catName: string }> = {};
  for (const tc of torneo.categorias) {
    const name = tc.category.nombre.toLowerCase();
    catMap[`${tc.category.tipo}_${name}`] = {
      tcId: tc.id,
      catId: tc.categoryId,
 

  function findCat(genero: 'MASCULINO' | 'FEMENINO', shortName: string) {
    // shortName = "8va", "7ma", "6ta", "5ta", "4ta", "3ra", "2da", "1ra"
    const entries = Object.entries(catMap);
    for (const [key, val] of entries) {
      if (key.startsWith(genero) && val.catName.toLowerCase().includes(shortName.toLowerCase())) {
        return val;
      }
    }
    return null;
  }

async function createPlayers(
  count: number,
  genero: 'MASCULINO' | 'FEMENINO',
  docStart: number,
  namePool: string[],
  passwordHash: string,
  roleId: string,
): Promise<{ id: string; documento: string }[]> {

async function createPairsAndInscribe(
  players: { id: string; documento: string }[],
  startIdx: number,
  targetPairs: number,
  tournamentId: string,
  categoryId: string,
  modalidad: string,
  monto: number,
  comision: number,
): Promise<number> {
  let created = 0;

  for (let i = 0; i < targetPairs; i++) {
    const p1 = players[startIdx + i * 2];
    const p2 = players[startIdx + i * 2 + 1];

    if (!p1 || !p2) {
      console.error(`   ⚠️  No hay suficientes jugadores (necesitaba índice ${startIdx + i * 2 + 1})`);
      break;
    }

    // Check duplicate
    const existing = await prisma.inscripcion.findFirst({
      where: {
        tournamentId,
        categoryId,
        pareja: {
          OR: [
            { jugador1Id: p1.id, jugador2Id: p2.id },
            { jugador1Id: p2.id, jugador2Id: p1.id },
          ],
        },
      },
    });

    if (existing) {
      created++;
      continue;
    }

    const pareja = await prisma.pareja.create({
      data: {
    

  obtenerUsuarios(
    @Query('search') search?: string,
    @Query('estado') estado?: string,
  ) {
    return this.adminService.obtenerUsuarios(search, estado);
  }

  obtenerUsuariosPremium(
    @Query('search') search?: string,
    @Query('estado') estado?: string,
  ) {
    return this.adminService.obtenerUsuariosPremium(search, estado);
  }

  seedTestData(
    @Param('id') id: string,
    @Body() dto: SeedTestDataDto,
  ) {
    return this.adminService.seedTestData(id, dto.parejasPorCategoria);
  }

  async obtenerTorneosPendientes() {
    const torneos = await this.prisma.tournament.findMany({
      where: {
        estado: 'PENDIENTE_APROBACION',
      },
      include: {
        organizador: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
            email: true,
            telefono: true,
          },
        },
        categorias: {
          include: {
            category: true,
          },
        },
        modalidades: true,
      },
      orderBy: {
        createdAt: 'desc',
      },
    });

    return torneos;
  }

  async aprobarTorneo(id: string) {
    const torneo = await this.prisma.tournament.findUnique({
      where: { id },
    });

    if (!torneo) {
      throw new NotFoundException('Torneo no encontrado');
    }

    await this.prisma.tournament.update({
      where: { id },
      data: {
        estado: 'PUBLICADO',
      },
    });

    // TODO: Notificar al organizador

    return { message: 'Torneo aprobado' };
  }

  async rechazarTorneo(id: string, motivo: string) {
    const torneo = await this.prisma.tournament.findUnique({
      where: { id },
    });

    if (!torneo) {
      throw new NotFoundException('Torneo no encontrado');
    }

    await this.prisma.tournament.update({
      where: { id },
      data: {
        estado: 'RECHAZADO',
      },
    });

    // TODO: Notificar al organizador con el motivo

    return { message: 'Torneo rechazado' };
  }

  async obtenerSolicitudesOrganizador(estado?: string) {
    const where: any = {};
    if (estado) {
      where.estado = estado;
    }

    const solicitudes = await this.prisma.solicitudOrganizador.findMany({
      where,
      include: {
        user: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
            email: true,
            telefono: true,
            ciudad: true,
          },
        },
      },
      orderBy: {
        createdAt: 'desc',
      },
    });

    return solicitudes;
  }

  async aprobarSolicitudOrganizador(id: string) {
    const solicitud = await this.prisma.solicitudOrganizador.findUnique({
      where: { id },
      include: { user: true },
    });

    if (!solicitud) {
      throw new NotFoundException('Solicitud no encontrada');
    }

    // Buscar rol de organizador
    const rolOrganizador = await this.prisma.role.findUnique({
      where: { nombre: 'organizador' },
    });

    if (!rolOrganizador) {
      throw new NotFoundException('Rol organizador no encontrado');
    }

    // Asignar rol
    await this.prisma.userRole.create({
      data: {
        userId: solicitud.userId,
        roleId: rolOrganizador.id,
      },
    });

    // Actualizar solicitud
    await this.prisma.solicitudOrganizador.update({
      where: { id },
      data: { estado: 'APROBADA' },
    });

    // TODO: Notificar al usuario

    return { message: 'Solicitud aprobada' };
  }

  async rechazarSolicitudOrganizador(id: string, motivo: string) {
    const solicitud = await this.prisma.solicitudOrganizador.findUnique({
      where: { id },
    });

    if (!solicitud) {
      throw new NotFoundException('Solicitud no encontrada');
    }

    await this.prisma.solicitudOrganizador.update({
      where: { id },
      data: {
        estado: 'RECHAZADA',
        motivo,
      },
    });

    // TODO: Notificar al usuario con el motivo

    return { message: 'Solicitud rechazada' };
  }

  async obtenerFotosModeracion() {
    const fotos = await this.prisma.foto.findMany({
      where: {
        estadoModeracion: 'PENDIENTE',
      },
      include: {
        user: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
            email: true,
          },
        },
        tournament: {
          select: {
            id: true,
            nombre: true,
          },
        },
      },
      orderBy: {
        createdAt: 'desc',
      },
    });

    return fotos;
  }

  async aprobarFoto(id: string) {
    const foto = await this.prisma.foto.findUnique({
      where: { id },
    });

    if (!foto) {
      throw new NotFoundException('Foto no encontrada');
    }

    await this.prisma.foto.update({
      where: { id },
      data: {
        estadoModeracion: 'APROBADA',
      },
    });

    return { message: 'Foto aprobada' };
  }

  async eliminarFotoInapropiada(id: string, motivo: string) {
    const foto = await this.prisma.foto.findUnique({
      where: { id },
    });

    if (!foto) {
      throw new NotFoundException('Foto no encontrada');
    }

    await this.prisma.foto.update({
      where: { id },
      data: {
        estadoModeracion: 'RECHAZADA',
      },
    });

    // Crear registro en moderación
    await this.prisma.fotoPerfilModeracion.create({
      data: {
        userId: foto.userId,
        fotoUrl: foto.urlImagen,
        estado: 'RECHAZADA',
        motivoRechazo: motivo,
      },
    });

    // TODO: Notificar al usuario

    return { message: 'Foto eliminada' };
  }

  async obtenerUsuarios(search?: string, estado?: string) {
    const where: any = {};

    if (search) {
      where.OR = [
        { nombre: { contains: search, mode: 'insensitive' } },
        { apellido: { contains: search, mode: 'insensitive' } },
        { email: { contains: search, mode: 'insensitive' } },
        { documento: { contains: search } },
      ];
    }

    if (estado) {
      where.estado = estado;
    }

    const usuarios = await this.prisma.user.findMany({
      where,
      select: {
        id: true,
        nombre: true,
        apellido: true,
        documento: true,
        email: true,
        telefono: true,
        ciudad: true,
        estado: true,
        esPremium: true,
        createdAt: true,
      },
      orderBy: {
        createdAt: 'desc',
      },
      take: 100,
    });

    return usuarios;
  }

  async suspenderUsuario(id: string, motivo: string) {
    const usuario = await this.prisma.user.findUnique({
      where: { id },
    });

    if (!usuario) {
      throw new NotFoundException('Usuario no encontrado');
    }

    await this.prisma.user.update({
      where: { id },
      data: { estado: 'SUSPENDIDO' },
    });

    // TODO: Notificar al usuario con el motivo

    return { message: 'Usuario suspendido' };
  }

  async activarUsuario(id: string) {
    const usuario = await this.prisma.user.findUnique({
      where: { id },
    });

    if (!usuario) {
      throw new NotFoundException('Usuario no encontrado');
    }

    await this.prisma.user.update({
      where: { id },
      data: { estado: 'ACTIVO' },
    });

    return { message: 'Usuario activado' };
  }

  async obtenerReportesFotos(estado?: string) {
    const where: any = {};
    if (estado) {
      where.estado = estado;
    }

    const reportes = await this.prisma.reporteFoto.findMany({
      where,
      include: {
        foto: {
          include: {
            user: {
              select: {
                id: true,
                nombre: true,
                apellido: true,
              },
            },
          },
        },
        user: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
          },
        },
      },
      orderBy: {
        createdAt: 'desc',
      },
    });

    return reportes;
  }

  async obtenerReportesUsuarios(estado?: string) {
    const where: any = {};
    if (estado) {
      where.estado = estado;
    }

    const reportes = await this.prisma.reporte.findMany({
      where,
      include: {
        reportador: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
          },
        },
        reportado: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
          },
        },
      },
      orderBy: {
        createdAt: 'desc',
      },
    });

    return reportes;
  }

  async resolverReporteFoto(id: string, accion: string) {
    const reporte = await this.prisma.reporteFoto.findUnique({
      where: { id },
      include: { foto: true },
    });

    if (!reporte) {
      throw new NotFoundException('Reporte no encontrado');
    }

    if (accion === 'ELIMINAR_FOTO') {
      await this.eliminarFotoInapropiada(reporte.fotoId, 'Reportada como inapropiada');
    }

    await this.prisma.reporteFoto.update({
      where: { id },
      data: { estado: 'APROBADA' },
    });

    return { message: 'Reporte resuelto' };
  }

  async resolverReporteUsuario(id: string, accion: string) {
    const reporte = await this.prisma.reporte.findUnique({
      where: { id },
    });

    if (!reporte) {
      throw new NotFoundException('Reporte no encontrado');
    }

    if (accion === 'SUSPENDER') {
      await this.suspenderUsuario(reporte.reportadoId, 'Reportado por múltiples usuarios');
    }

    await this.prisma.reporte.update({
      where: { id },
      data: { estado: 'APROBADA' },
    });

    return { message: 'Reporte resuelto' };
  }

  async obtenerSuscripciones(estado?: string) {
    const where: any = {};
    if (estado) {
      where.estado = estado;
    }

    const suscripciones = await this.prisma.suscripcion.findMany({
      where,
      include: {
        user: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
            email: true,
          },
        },
        plan: true,
      },
      orderBy: {
        createdAt: 'desc',
      },
    });

    return suscripciones;
  }

  async extenderSuscripcion(id: string, dias: number) {
    const suscripcion = await this.prisma.suscripcion.findUnique({
      where: { id },
    });

    if (!suscripcion) {
      throw new NotFoundException('Suscripción no encontrada');
    }

    const nuevaFechaFin = new Date(suscripcion.fechaFin);
    nuevaFechaFin.setDate(nuevaFechaFin.getDate() + dias);

    // If subscription was VENCIDA, reactivate it and set user as premium
    const updateData: any = {
      fechaFin: nuevaFechaFin,
      fechaRenovacion: nuevaFechaFin,
    };
    if (suscripcion.estado === 'VENCIDA') {
      updateData.estado = 'ACTIVA';
    }

    await this.prisma.suscripcion.update({
      where: { id },
      data: updateData,
    });

    // Ensure user is premium (especially if reactivated from VENCIDA)
    await this.prisma.user.update({
      where: { id: suscripcion.userId },
      data: { esPremium: true },
    });

    return { message: `Suscripción extendida por ${dias} días` };
  }

  async obtenerConfiguracionPuntos() {
    const configuracion = await this.prisma.configuracionPuntos.findMany({
      orderBy: {
        puntosBase: 'desc',
      },
    });

    return configuracion;
  }

  async actualizarConfiguracionPuntos(id: string, data: any) {
    const config = await this.prisma.configuracionPuntos.findUnique({
      where: { id },
    });

    if (!config) {
      throw new NotFoundException('Configuración no encontrada');
    }

    await this.prisma.configuracionPuntos.update({
      where: { id },
      data: {
        puntosBase: data.puntosBase,
        multiplicador: data.multiplicador,
      },
    });

    return { message: 'Configuración actualizada' };
  }

  async crearCupon(data: any) {
    const cupon = await this.prisma.cupon.create({
      data: {
        codigo: data.codigo,
        tipo: data.tipo,
        valor: data.valor,
        fechaInicio: new Date(data.fechaInicio),
        fechaExpiracion: new Date(data.fechaExpiracion),
        limiteUsos: data.limiteUsos,
      },
    });

    return cupon;
  }

  async obtenerCupones() {
    const cupones = await this.prisma.cupon.findMany({
      orderBy: {
        createdAt: 'desc',
      },
    });

    return cupones;
  }

  async desactivarCupon(id: string) {
    await this.prisma.cupon.update({
      where: { id },
      data: { estado: 'INACTIVO' },
    });

    return { message: 'Cupón desactivado' };
  }

  async obtenerMetricasDashboard() {
    const totalUsuarios = await this.prisma.user.count();
    const usuariosPremium = await this.prisma.user.count({
      where: { esPremium: true },
    });
    const totalTorneos = await this.prisma.tournament.count();
    const torneosPendientes = await this.prisma.tournament.count({
      where: { estado: 'PENDIENTE_APROBACION' },
    });

    return {
      totalUsuarios,
      usuariosPremium,
      totalTorneos,
      torneosPendientes,
    };
  }

  async obtenerMetricasUsuarios() {
    const porEstado = await this.prisma.user.groupBy({
      by: ['estado'],
      _count: true,
    });

    const porGenero = await this.prisma.user.groupBy({
      by: ['genero'],
      _count: true,
    });

    return {
      porEstado,
      porGenero,
    };
  }

  async obtenerMetricasTorneos() {
    const porEstado = await this.prisma.tournament.groupBy({
      by: ['estado'],
      _count: true,
    });

    return { porEstado };
  }

  async obtenerMetricasIngresos() {
    // Calcular ingresos totales de suscripciones
    const suscripciones = await this.prisma.suscripcion.findMany({
      where: { estado: 'ACTIVA' },
    });

    const mrrSuscripciones = suscripciones.reduce((acc, sub) => {
      const precioMensual = sub.periodo === 'MENSUAL'
        ? sub.precio.toNumber()
        : sub.precio.toNumber() / 12;
      return acc + precioMensual;
    }, 0);

    // Calcular ingresos de comisiones
    const pagos = await this.prisma.pago.findMany({
      where: { estado: 'CONFIRMADO' },
    });

    const totalComisiones = pagos.reduce((acc, pago) => {
      return acc + pago.comision.toNumber();
    }, 0);

    return {
      mrr: mrrSuscripciones,
      totalComisiones,
      suscripcionesActivas: suscripciones.length,
    };
  }

  async obtenerUsuariosPremium(search?: string, estado?: string) {
    const where: any = { esPremium: true };

    if (search) {
      where.AND = [
        { esPremium: true },
        {
          OR: [
            { nombre: { contains: search, mode: 'insensitive' } },
            { apellido: { contains: search, mode: 'insensitive' } },
            { email: { contains: search, mode: 'insensitive' } },
            { documento: { contains: search } },
          ],
        },
      ];
      delete where.esPremium;
    }

    const usuarios = await this.prisma.user.findMany({
      where,
      select: {
        id: true,
        nombre: true,
        apellido: true,
        documento: true,
        email: true,
        telefono: true,
        ciudad: true,
        genero: true,
        fotoUrl: true,
        esPremium: true,
        createdAt: true,
        suscripciones: {
          orderBy: { createdAt: 'desc' },
          take: 1,
          include: {
            plan: true,
        

  async obtenerMetricasPremium() {
    const now = new Date();
    const hace30Dias = new Date(now);
    hace30Dias.setDate(hace30Dias.getDate() - 30);
    const hace60Dias = new Date(now);
    hace60Dias.setDate(hace60Dias.getDate() - 60);

    // Conteos básicos
    const totalPremium = await this.prisma.user.count({ where: { esPremium: true } });
    const totalUsuarios = await this.prisma.user.count();
    const suscripcionesActivas = await this.prisma.suscripcion.count({ where: { estado: 'ACTIVA' } });
    const suscripcionesPendientes = await this.prisma.suscripcion.count({ where: { estado: 'PENDIENTE_PAGO' } });

    // Nuevos premium últimos 30 días
    const nuevosPremium30d = await this.prisma.suscripcion.count({
      where: {
        estado: 'ACTIVA',
        createdAt: { gte: hace30Dias },
      },
    });

    // Cancelaciones últimos 30 días
    const cancelaciones30d = await this.prisma.suscripcion.count({
      where: {
        estado: { in: ['CANCELADA', 'VENCIDA'] },

  async obtenerTendenciasSuscripciones() {
    const meses: {
      mes: string;
      nuevas: number;
      canceladas: number;
      ingresos: number;
    }[] = [];

    const now = new Date();

    for (let i = 11; i >= 0; i--) {
      const inicio = new Date(now.getFullYear(), now.getMonth() - i, 1);
      const fin = new Date(now.getFullYear(), now.getMonth() - i + 1, 0, 23, 59, 59);

      const nuevas = await this.prisma.suscripcion.count({
        where: {
          createdAt: { gte: inicio, lte: fin },
          estado: { not: 'PENDIENTE_PAGO' },
        },
      });

      const canceladas = await this.prisma.suscripcion.count({
        where: {
          estado: { in: ['CANCELADA', 'VENCIDA'] },
          updatedAt: { gte: inicio, lte: fin },
        },
      });

      // Revenue del mes (suscripciones creadas ese mes)
      const susMes = await this.prisma.suscripcion.findMany({
        where: {
          createdAt: { gte: inicio, lte: fin },
          estado: { in: ['ACTI

  async obtenerActividadPremium() {
    const suscripciones = await this.prisma.suscripcion.findMany({
      orderBy: { updatedAt: 'desc' },
      take: 20,
      include: {
        user: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
            email: true,
            fotoUrl: true,
          },
        },
        plan: {
          select: {
            nombre: true,
          },
        },
      },
    });

    return suscripciones.map((s) => ({
      id: s.id,
      usuario: s.user,
      plan: s.plan?.nombre,
      estado: s.estado,
      precio: s.precio.toNumber(),
      fechaInicio: s.fechaInicio,
      fechaFin: s.fechaFin,
      autoRenovar: s.autoRenovar,
      cuponAplicado: s.cuponAplicado,
      createdAt: s.createdAt,
      updatedAt: s.updatedAt,
    }));
  }

  async otorgarPremiumManual(userId: string, dias: number, motivo: string) {
    const user = await this.prisma.user.findUnique({
      where: { id: userId },
    });

    if (!user) {
      throw new NotFoundException('Usuario no encontrado');
    }

    // Buscar plan premium
    const plan = await this.prisma.planPremium.findFirst({
      where: { activo: true },
    });

    if (!plan) {
      throw new NotFoundException('No hay plan premium activo');
    }

    // Cancelar suscripciones activas/pendientes existentes para evitar duplicados
    await this.prisma.suscripcion.updateMany({
      where: { userId, estado: { in: ['ACTIVA', 'PENDIENTE_PAGO'] } },
      data: { estado: 'CANCELADA' },
    });

    const now = new Date();
    const fechaFin = new Date(now);
    fechaFin.setDate(fechaFin.getDate() + dias);

    // Crear suscripción cortesía
    const suscripcion = await this.prisma.suscripcion.create({
      data: {
        userId,
        planId: plan.id,
        periodo: 'ME

  async revocarPremium(userId: string) {
    const user = await this.prisma.user.findUnique({
      where: { id: userId },
    });

    if (!user) {
      throw new NotFoundException('Usuario no encontrado');
    }

    // Cancelar suscripciones activas y pendientes
    await this.prisma.suscripcion.updateMany({
      where: { userId, estado: { in: ['ACTIVA', 'PENDIENTE_PAGO'] } },
      data: { estado: 'CANCELADA' },
    });

    // Quitar premium
    await this.prisma.user.update({
      where: { id: userId },
      data: { esPremium: false },
    });

    return {
      message: `Premium revocado para ${user.nombre} ${user.apellido}`,
    };
  }

  async obtenerEstadisticasCupones() {
    const cupones = await this.prisma.cupon.findMany({
      orderBy: { createdAt: 'desc' },
    });

    const totalCupones = cupones.length;
    const cuponesActivos = cupones.filter((c) => c.estado === 'ACTIVO').length;
    const totalUsos = cupones.reduce((acc, c) => acc + c.usosActuales, 0);
    const descuentoTotal = cupones.reduce((acc, c) => {
      if (c.tipo === 'PORCENTAJE') return acc; // Can't calculate exact amount for percentage
      return acc + c.valor.toNumber() * c.usosActuales;
    }, 0);

    // Top cupones por uso
    const topCupones = [...cupones]
      .sort((a, b) => b.usosActuales - a.usosActuales)
      .slice(0, 5)
      .map((c) => ({
        codigo: c.codigo,
        tipo: c.tipo,
        valor: c.valor.toNumber(),
        usos: c.usosActuales,
        limite: c.limiteUsos,
        estado: c.estado,
      }));

    return {
      totalCupones,
      cuponesActivos,
      totalUsos,
      descuentoTotal,
      topCup

  async promoverOrganizadorPorDocumento(documento: string) {
    // Buscar usuario por documento
    const user = await this.prisma.user.findUnique({
      where: { documento },
      include: {
        roles: {
          include: { role: true },
        },
      },
    });

    if (!user) {
      throw new NotFoundException(
        `No se encontró usuario con documento: ${documento}`,
      );
    }

    // Verificar si ya es organizador
    const yaEsOrganizador = user.roles.some(
      (ur) => ur.role.nombre === 'organizador',
    );
    if (yaEsOrganizador) {
      throw new ConflictException(
        `${user.nombre} ${user.apellido} ya tiene rol de organizador`,
      );
    }

    // Buscar rol de organizador
    const rolOrganizador = await this.prisma.role.findUnique({
      where: { nombre: 'organizador' },
    });

    if (!rolOrganizador) {
      throw new NotFoundException('Rol organizador no encontrado');
    }

    // Asignar rol
    await this.prisma.userRole.create({
 

  async actualizarConfiguracionSistema(clave: string, valor: string) {
    const config = await this.prisma.configuracionSistema.findUnique({
      where: { clave },
    });

    if (!config) {
      throw new NotFoundException(
        `Configuración '${clave}' no encontrada`,
      );
    }

    // Validar que el valor sea numérico para comisiones
    if (clave === 'COMISION_INSCRIPCION') {
      const numVal = parseFloat(valor);
      if (isNaN(numVal) || numVal < 0 || numVal > 100) {
        throw new BadRequestException(
          'El porcentaje de comisión debe ser un número entre 0 y 100',
        );
      }
    }

    await this.prisma.configuracionSistema.update({
      where: { clave },
      data: { valor },
    });

    return { message: `Configuración '${clave}' actualizada a: ${valor}` };
  }

  async obtenerValorConfiguracion(clave: string): Promise<string | null> {
    const config = await this.prisma.configuracionSistema.findUnique({
      where: { clave },
    });
    return config?.valor ?? null;
  }

  async setComisionTorneo(tournamentId: string, comisionPorcentaje: number | null) {
    const tournament = await this.prisma.tournament.findUnique({
      where: { id: tournamentId },
    });
    if (!tournament) throw new NotFoundException('Torneo no encontrado');

    if (comisionPorcentaje !== null) {
      if (comisionPorcentaje < 0 || comisionPorcentaje > 100) {
        throw new BadRequestException('La comisión debe estar entre 0 y 100');
      }
    }

    await this.prisma.tournament.update({
      where: { id: tournamentId },
      data: { comisionPorcentaje },
    });

    return {
      message: comisionPorcentaje !== null
        ? `Comisión del torneo configurada a ${comisionPorcentaje}%`
        : 'Comisión del torneo eliminada (usará la configuración global)',
      comisionPorcentaje,
    };
  }

  async getComisionTorneo(tournamentId: string) {
    const tournament = await this.prisma.tournament.findUnique({
      where: { id: tournamentId },
      select: { id: true, nombre: true, comisionPorcentaje: true },
    });
    if (!tournament) throw new NotFoundException('Torneo no encontrado');

    const globalConfig = await this.prisma.configuracionSistema.findUnique({
      where: { clave: 'COMISION_INSCRIPCION' },
    });

    return {
      tournamentId: tournament.id,
      nombre: tournament.nombre,
      comisionPorcentaje: tournament.comisionPorcentaje,
      comisionGlobal: globalConfig ? parseFloat(globalConfig.valor) : 5,
      usandoGlobal: tournament.comisionPorcentaje === null,
    };
  }

  async obtenerFinanzasDashboard() {
    // Comisión fija actual
    const configComision = await this.prisma.configuracionSistema.findUnique({
      where: { clave: 'COMISION_FIJA_POR_JUGADOR' },
    });
    const comisionFijaPorJugador = configComision ? parseFloat(configComision.valor) : 5000;

    // Total comisiones de pagos confirmados
    const pagosConfirmados = await this.prisma.pago.findMany({
      where: { estado: 'CONFIRMADO' },
      select: { comision: true, inscripcionId: true },
    });

    const totalIngresosComisiones = pagosConfirmados.reduce(
      (acc, p) => acc + p.comision.toNumber(), 0,
    );

    // Pagos confirmados del mes actual
    const now = new Date();
    const inicioMes = new Date(now.getFullYear(), now.getMonth(), 1);
    const pagosMes = await this.prisma.pago.findMany({
      where: {
        estado: 'CONFIRMADO',
        fechaConfirm: { gte: inicioMes },
      },
      select: { comision: true },
    });
    const comisionesMes = pagosMes.reduc

  async obtenerFinanzasTorneos(estado?: string) {
    const where: any = {};
    if (estado) {
      where.estado = estado;
    }

    const torneos = await this.prisma.tournament.findMany({
      where,
      select: {
        id: true,
        nombre: true,
        flyerUrl: true,
        estado: true,
        fechaInicio: true,
        fechaFin: true,
        costoInscripcion: true,
        createdAt: true,
        inscripciones: {
          select: {
            id: true,
            estado: true,
            pagos: {
              where: { estado: 'CONFIRMADO' },
              select: { comision: true },
            },
          },
        },
      },
      orderBy: { createdAt: 'desc' },
    });

    return torneos.map((t) => {
      let inscripcionesConfirmadas = 0;
      let comisionesGeneradas = 0;

      for (const insc of t.inscripciones) {
        if (insc.estado === 'CONFIRMADA') {
          inscripcionesConfirmadas++;
        }
        for (const pago of insc.pagos) {