import { Injectable } from '@nestjs/common';
import { gym_acceso_resultado, gym_membresia_origen, gym_plan_tipo, gym_socio_estado } from '@prisma/client';
import { PrismaService } from 'src/prisma/prisma.service';
import { startOfDayAsuncion } from 'src/utils/utilidades';
import { RESULTADOS_PERMITIDOS, situacionDeAcceso } from '../common/acceso-reglas';
import { aFecha, diaPy, horaPy, sumarDias } from '../common/fechas-gym';
import { documentoDe } from '../common/socio-utils';
import { limitesDelDia } from '../recepcion/accesos-gym.service';
import { ReservasGymService } from '../clases/reservas-gym.service';
import { membresiaPlana } from '../socios/socios-gym.service';
import { ESTADOS_MEMBRESIA_FUERA } from '../ventas/gym-ventas.service';
import { monedaBaseOpcional } from 'src/utils/montos-moneda';

const PERMITIDOS: gym_acceso_resultado[] = [...RESULTADOS_PERMITIDOS];
const PERMITIDOS_TEXTO: string[] = [...RESULTADOS_PERMITIDOS];
/** Días que mira el tablero hacia atrás para vencidos sin renovar y para el gráfico de ingresos. */
const DIAS_VENCIDOS = 30;
const DIAS_GRAFICO = 14;
const LISTA = 8;

/**
 * Tablero de inicio del gimnasio (plan §12, la versión corta para la operación
 * diaria): cuántos tienen la cuota al día, quiénes vencen o vencieron, el
 * movimiento de hoy en recepción, las ventas del mes y las clases de hoy.
 */
@Injectable()
export class TableroGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly reservas: ReservasGymService,
  ) {}

  async tablero(empresa_id: string, f: { sede_id?: string } = {}) {
    const hoy = diaPy();
    const inicioMes = `${hoy.slice(0, 8)}01`;
    const [socios, membresias, accesosHoy, porDia, altasMes, ventasMes, clases] = await Promise.all([
      this.prisma.gym_socios.findMany({
        where: { empresa_id, estado: gym_socio_estado.ACTIVO },
        select: {
          id: true,
          numero_socio: true,
          telefono: true,
          cliente: {
            select: { personas: { select: { razon_social: true, nro_documento: true, ruc: true, dv: true } } },
          },
        },
      }),
      this.prisma.gym_membresias.findMany({
        where: {
          empresa_id,
          estado: { notIn: ESTADOS_MEMBRESIA_FUERA },
          fecha_fin: { gte: aFecha(sumarDias(hoy, -DIAS_VENCIDOS)) },
          plan: { tipo: { not: gym_plan_tipo.CREDITOS } },
          socio: { estado: gym_socio_estado.ACTIVO },
        },
        include: { plan: { select: { nombre: true, tipo: true, producto_id: true } } },
      }),
      this.prisma.gym_accesos.findMany({
        where: { empresa_id, fecha_hora: limitesDelDia(hoy), ...(f.sede_id && { sede_id: f.sede_id }) },
        select: { fecha_hora: true, resultado: true, socio_id: true },
      }),
      this.prisma.$queryRaw<Array<{ dia: string; permitidos: number; rechazados: number }>>`
        SELECT to_char((fecha_hora AT TIME ZONE 'America/Asuncion')::date, 'YYYY-MM-DD') AS dia,
               count(*) FILTER (WHERE resultado::text = ANY(${PERMITIDOS_TEXTO}::text[]))::int AS permitidos,
               count(*) FILTER (WHERE NOT (resultado::text = ANY(${PERMITIDOS_TEXTO}::text[])))::int AS rechazados
        FROM gym_accesos
        WHERE empresa_id = ${empresa_id}::uuid AND fecha_hora >= ${startOfDayAsuncion(sumarDias(hoy, -(DIAS_GRAFICO - 1)))}
          AND (${f.sede_id ?? null}::uuid IS NULL OR sede_id = ${f.sede_id ?? null}::uuid)
        GROUP BY 1 ORDER BY 1`,
      this.prisma.gym_socios.count({ where: { empresa_id, created_at: { gte: startOfDayAsuncion(inicioMes) } } }),
      this.prisma.gym_membresias.findMany({
        where: {
          empresa_id,
          origen: gym_membresia_origen.VENTA,
          estado: { notIn: ESTADOS_MEMBRESIA_FUERA },
          created_at: { gte: startOfDayAsuncion(inicioMes) },
        },
        select: { precio_neto: true, moneda_id: true, membresia_anterior_id: true, plan: { select: { nombre: true } } },
      }),
      this.reservas.agenda(empresa_id, { desde: hoy, hasta: hoy, sede_id: f.sede_id }),
    ]);

    // Situación de la cuota de cada socio activo.
    const porSocio = new Map<string, ReturnType<typeof membresiaPlana<(typeof membresias)[number]>>[]>();
    for (const m of membresias) porSocio.set(m.socio_id, [...(porSocio.get(m.socio_id) ?? []), membresiaPlana(m)]);
    const fila = (
      s: (typeof socios)[number],
      extra: { dias: number | null; plan: string | undefined; producto_id: string | null | undefined },
    ) => ({
      id: s.id,
      numero_socio: s.numero_socio,
      nombre: s.cliente.personas?.razon_social ?? '',
      documento: documentoDe(s.cliente.personas),
      telefono: s.telefono,
      ...extra,
    });
    let alDia = 0;
    const vencen: Array<ReturnType<typeof fila>> = [];
    const vencidos: Array<ReturnType<typeof fila>> = [];
    for (const s of socios) {
      const sit = situacionDeAcceso(porSocio.get(s.id) ?? [], hoy);
      if (sit.situacion === 'VIGENTE' || sit.situacion === 'FUTURA') alDia++;
      // Los pases (1 a 7 días) no cuentan como «por vencer»: nacen así y no son una renovación que perseguir.
      if (sit.situacion === 'VIGENTE' && (sit.dias ?? 99) <= 7 && sit.membresia?.plan.tipo !== gym_plan_tipo.PASE)
        vencen.push(
          fila(s, { dias: sit.dias, plan: sit.membresia?.plan.nombre, producto_id: sit.membresia?.plan.producto_id }),
        );
      if (sit.situacion === 'VENCIDA')
        vencidos.push(
          fila(s, { dias: sit.dias, plan: sit.membresia?.plan.nombre, producto_id: sit.membresia?.plan.producto_id }),
        );
    }
    vencen.sort((a, b) => (a.dias ?? 0) - (b.dias ?? 0));
    vencidos.sort((a, b) => (a.dias ?? 0) - (b.dias ?? 0));

    // Recepción hoy, por hora.
    const porHora = Array.from({ length: 24 }, (_, h) => ({
      hora: String(h).padStart(2, '0'),
      permitidos: 0,
      rechazados: 0,
    }));
    const presentes = new Set<string>();
    for (const a of accesosHoy) {
      const h = Number(horaPy(a.fecha_hora).slice(0, 2));
      if (PERMITIDOS.includes(a.resultado)) {
        porHora[h].permitidos++;
        presentes.add(a.socio_id);
      } else porHora[h].rechazados++;
    }
    const conMovimiento = porHora.filter((x) => x.permitidos || x.rechazados).map((x) => Number(x.hora));
    const horas = conMovimiento.length
      ? porHora.slice(Math.min(...conMovimiento, 6), Math.max(...conMovimiento, 21) + 1)
      : porHora.slice(6, 22);

    const dias = new Map(porDia.map((d) => [d.dia, d]));
    const grafico = Array.from({ length: DIAS_GRAFICO }, (_, i) => {
      const dia = sumarDias(hoy, i - (DIAS_GRAFICO - 1));
      return { dia, permitidos: dias.get(dia)?.permitidos ?? 0, rechazados: dias.get(dia)?.rechazados ?? 0 };
    });

    // Ventas de planes del mes, por moneda.
    const monedas = await this.prisma.moneda.findMany({
      where: { id: { in: [...new Set(ventasMes.map((v) => v.moneda_id).filter((x): x is string => !!x))] } },
      select: { id: true, codigo: true },
    });
    // Una venta sin moneda (legacy) es de la moneda base de la empresa, nunca de un código fijo.
    const base = (await monedaBaseOpcional(this.prisma, empresa_id))?.codigo ?? null;
    const codigo = new Map(monedas.map((m) => [m.id, m.codigo ?? base]));
    const montos = new Map<string, number>();
    for (const v of ventasMes) {
      const c = (v.moneda_id && codigo.get(v.moneda_id)) || base;
      if (!c) continue;
      montos.set(c, (montos.get(c) ?? 0) + Number(v.precio_neto ?? 0));
    }

    return {
      dia: hoy,
      kpis: {
        socios_activos: socios.length,
        al_dia: alDia,
        vencen_7_dias: vencen.length,
        vencidos_sin_renovar: vencidos.length,
        ingresos_hoy: accesosHoy.filter((a) => PERMITIDOS.includes(a.resultado)).length,
        socios_hoy: presentes.size,
        rechazos_hoy: accesosHoy.filter((a) => !PERMITIDOS.includes(a.resultado)).length,
        altas_mes: altasMes,
        ventas_mes: ventasMes.length,
        renovaciones_mes: ventasMes.filter((v) => v.membresia_anterior_id).length,
      },
      ventas_mes: [...montos.entries()].map(([moneda, monto]) => ({ moneda, monto })),
      vencen: vencen.slice(0, LISTA),
      vencidos: vencidos.slice(0, LISTA),
      ingresos_por_hora: horas,
      ingresos_por_dia: grafico,
      clases_hoy: clases.sesiones,
    };
  }
}
