import { BadRequestException, Injectable } from '@nestjs/common';
import { gym_acceso_resultado, gym_aviso_estado, gym_duracion_unidad, gym_membresia_origen, gym_plan_tipo } from '@prisma/client';
import { ListaPreciosService } from 'src/lista-precios/lista-precios.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { endOfDayAsuncion, startOfDayAsuncion } from 'src/utils/utilidades';
import { deFecha, diaPy, sumarDias } from '../common/fechas-gym';
import { documentoDe } from '../common/socio-utils';
import { ESTADOS_MEMBRESIA_FUERA } from '../ventas/gym-ventas.service';
import { monedaBaseOpcional } from 'src/utils/montos-moneda';

const DIA_RE = /^\d{4}-\d{2}-\d{2}$/;
const NO_ENTREGADOS = [gym_aviso_estado.SIN_EMAIL, gym_aviso_estado.ERROR, gym_aviso_estado.REBOTADO];

function rango(desde?: string, hasta?: string): { desde: string; hasta: string } {
  const h = hasta && DIA_RE.test(hasta) ? hasta : diaPy();
  const d = desde && DIA_RE.test(desde) ? desde : sumarDias(h, -30);
  if (d > h) throw new BadRequestException('La fecha desde no puede ser posterior a la fecha hasta');
  return { desde: d, hasta: h };
}

/** Días que dura un período del plan (para estimar cuántas cuotas se deben). */
function diasDelPeriodo(valor: number | null, unidad: gym_duracion_unidad | null): number {
  if (!valor) return 30;
  return unidad === gym_duracion_unidad.MES ? valor * 30 : valor;
}

/** Página y tamaño (1–200, por defecto 50) de un listado. */
function paginado(f: { page?: number; limit?: number }) {
  return { page: Math.max(1, Math.floor(f.page ?? 1)), limit: Math.min(200, Math.max(1, Math.floor(f.limit ?? 50))) };
}

@Injectable()
export class ReportesGymService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly precios: ListaPreciosService,
  ) {}

  /**
   * «Ingresos con plan vencido» (§12, clave con modo AVISAR): socios que
   * entraron vencidos, cuántas veces, quién los dejó pasar y lo que se estima
   * no cobrado (cuotas atrasadas × precio de lista), salvo que ya hayan renovado.
   */
  async ingresosConPlanVencido(
    empresa_id: string,
    f: { desde?: string; hasta?: string; sede_id?: string; page?: number; limit?: number },
  ) {
    const { page, limit } = paginado(f);
    const { desde, hasta } = rango(f.desde, f.hasta);
    const accesos = await this.prisma.gym_accesos.findMany({
      where: {
        empresa_id,
        fecha_hora: { gte: startOfDayAsuncion(desde), lte: endOfDayAsuncion(hasta) },
        // Los que entraron debiendo: vencidos (con sus días) y, si el gimnasio lo permite, los que no tienen plan.
        OR: [
          {
            dias_vencida: { not: null },
            resultado: {
              in: [
                gym_acceso_resultado.ALERTA_VENCIDA,
                gym_acceso_resultado.ALERTA_GRACIA,
                gym_acceso_resultado.PERMITIDO_FORZADO,
              ],
            },
          },
          { resultado: gym_acceso_resultado.ALERTA_SIN_PLAN },
        ],
        ...(f.sede_id && { sede_id: f.sede_id }),
      },
      include: {
        socio: {
          select: {
            id: true,
            numero_socio: true,
            cliente_id: true,
            cliente: {
              select: { personas: { select: { razon_social: true, nro_documento: true, ruc: true, dv: true } } },
            },
          },
        },
        membresia: {
          select: {
            id: true,
            fecha_inicio: true,
            fecha_fin: true,
            plan: { select: { nombre: true, producto_id: true, duracion_valor: true, duracion_unidad: true } },
          },
        },
        sede: { select: { nombre: true } },
      },
      orderBy: { fecha_hora: 'asc' },
    });
    if (!accesos.length)
      return {
        desde,
        hasta,
        filas: [],
        total: 0,
        page,
        limit,
        totales: {
          socios: 0,
          ingresos: 0,
          monto_estimado: 0,
          moneda: null,
          monto_estimado_por_moneda: [],
          filas_sin_precio: 0,
        },
      };

    const usuarios = await this.prisma.usuario.findMany({
      where: { id: { in: [...new Set(accesos.map((a) => a.usuario_id).filter((x): x is string => !!x))] } },
      select: { id: true, nombres: true, apellidos: true, username: true },
    });
    const nombreUsuario = new Map(
      usuarios.map((u) => [u.id, [u.nombres, u.apellidos].filter(Boolean).join(' ') || u.username || '']),
    );
    const renovaciones = await this.prisma.gym_membresias.findMany({
      where: {
        empresa_id,
        socio_id: { in: [...new Set(accesos.map((a) => a.socio_id))] },
        estado: { notIn: ESTADOS_MEMBRESIA_FUERA },
        plan: { tipo: { not: gym_plan_tipo.CREDITOS } },
      },
      select: { socio_id: true, fecha_inicio: true },
    });

    const porSocio = new Map<string, (typeof accesos)[number][]>();
    for (const a of accesos) porSocio.set(a.socio_id, [...(porSocio.get(a.socio_id) ?? []), a]);

    // Sin moneda en la entidad, la de la empresa (nunca un código fijo): regla multi-moneda.
    const base = (await monedaBaseOpcional(this.prisma, empresa_id))?.codigo ?? null;
    const precioCache = new Map<string, { monto: number; moneda: string | null; error: string | null }>();
    const filas = [];
    for (const lista of porSocio.values()) {
      const ultimo = lista[lista.length - 1];
      const m = ultimo.membresia;
      const venc = m ? deFecha(m.fecha_fin) : null;
      const renovo = !!m && renovaciones.some((r) => r.socio_id === ultimo.socio_id && r.fecha_inicio > m.fecha_inicio);
      const diasAtraso = Math.max(...lista.map((a) => a.dias_vencida ?? 0));
      let montoEstimado = 0;
      let moneda: string | null = base;
      let precioError: string | null = null;
      if (m && !renovo) {
        const clave = `${ultimo.socio.cliente_id}|${m.plan.producto_id}`;
        if (!precioCache.has(clave)) {
          // Si el precio no se puede leer, la fila lo dice (antes salía un «Gs. 0» estimado sin aviso).
          const p = await this.precios
            .obtenerPrecioProducto({
              productoId: m.plan.producto_id,
              clienteId: ultimo.socio.cliente_id,
              empresaId: empresa_id,
            })
            .then((x) => ({ monto: Number(x?.precioFinal ?? 0), moneda: x?.moneda ?? base, error: null }))
            .catch((err: Error) => ({
              monto: 0,
              moneda: base,
              error: `No se pudo leer el precio del plan: ${err?.message ?? err}`,
            }));
          precioCache.set(clave, p);
        }
        const precio = precioCache.get(clave);
        moneda = precio.moneda;
        precioError = precio.error;
        montoEstimado =
          Math.ceil(diasAtraso / diasDelPeriodo(m.plan.duracion_valor, m.plan.duracion_unidad)) * precio.monto;
      }
      filas.push({
        socio: {
          id: ultimo.socio.id,
          numero_socio: ultimo.socio.numero_socio,
          nombre: ultimo.socio.cliente.personas?.razon_social ?? '',
          documento: documentoDe(ultimo.socio.cliente.personas),
        },
        plan: m?.plan.nombre ?? null,
        vencio_el: venc,
        dias_atraso: diasAtraso,
        ingresos: lista.length,
        forzados: lista.filter((a) => a.resultado === gym_acceso_resultado.PERMITIDO_FORZADO).length,
        primer_ingreso: lista[0].fecha_hora,
        ultimo_ingreso: ultimo.fecha_hora,
        sedes: [...new Set(lista.map((a) => a.sede.nombre))],
        dejaron_pasar: [
          ...new Set(lista.map((a) => (a.usuario_id ? nombreUsuario.get(a.usuario_id) : null)).filter(Boolean)),
        ],
        ya_renovo: renovo,
        monto_estimado: montoEstimado,
        moneda,
        precio_error: precioError,
      });
    }
    filas.sort((a, b) => b.dias_atraso - a.dias_atraso);
    return {
      desde,
      hasta,
      // Los totales son de todo el período; la página, para la tabla (sin cortes en silencio).
      filas: filas.slice((page - 1) * limit, page * limit),
      total: filas.length,
      page,
      limit,
      totales: {
        socios: filas.length,
        ingresos: filas.reduce((s, r) => s + r.ingresos, 0),
        // El total en la moneda base de la empresa (la pantalla vieja lo lee hasta U10) y uno por moneda: nada se suma a
        // otra moneda ni se deja afuera en silencio.
        monto_estimado: filas.filter((r) => r.moneda === base).reduce((s, r) => s + r.monto_estimado, 0),
        moneda: base,
        monto_estimado_por_moneda: [...new Set(filas.map((r) => r.moneda).filter((c): c is string => !!c))]
          .sort()
          .map((codigo) => ({
            codigo,
            monto: filas.filter((r) => r.moneda === codigo).reduce((s, r) => s + r.monto_estimado, 0),
          })),
        filas_sin_precio: filas.filter((r) => r.precio_error).length,
      },
    };
  }

  /** «Avisos no entregados»: sin email, con error de envío o rebotados, para que recepción complete el dato. */
  async avisosNoEntregados(empresa_id: string, f: { desde?: string; hasta?: string; page?: number; limit?: number }) {
    const { desde, hasta } = rango(f.desde, f.hasta);
    const { page, limit } = paginado(f);
    const where = {
      empresa_id,
      estado: { in: NO_ENTREGADOS },
      created_at: { gte: startOfDayAsuncion(desde), lte: endOfDayAsuncion(hasta) },
    };
    const [total, filas] = await Promise.all([
      this.prisma.gym_avisos_log.count({ where: { ...where, empresa_id } }),
      this.prisma.gym_avisos_log.findMany({
        where: { ...where, empresa_id },
        include: {
          socio: {
            select: {
              id: true,
              numero_socio: true,
              email: true,
              telefono: true,
              cliente: {
                select: { personas: { select: { razon_social: true, nro_documento: true, ruc: true, dv: true } } },
              },
            },
          },
          membresia: { select: { fecha_fin: true, plan: { select: { nombre: true } } } },
        },
        orderBy: { created_at: 'desc' },
        skip: (page - 1) * limit,
        take: limit,
      }),
    ]);
    return {
      desde,
      hasta,
      total,
      page,
      limit,
      filas: filas.map((a) => ({
        id: a.id,
        tipo: a.tipo,
        estado: a.estado,
        error: a.error,
        intentos: a.intentos,
        fecha: a.updated_at ?? a.created_at,
        destino: a.destino,
        plan: a.membresia.plan.nombre,
        vence: deFecha(a.membresia.fecha_fin),
        socio: {
          id: a.socio.id,
          numero_socio: a.socio.numero_socio,
          nombre: a.socio.cliente.personas?.razon_social ?? '',
          documento: documentoDe(a.socio.cliente.personas),
          email_actual: a.socio.email,
          telefono: a.socio.telefono,
        },
      })),
    };
  }

  /**
   * «Membresías sin factura» (§15.12): planes cargados como ya pagados, a mano desde la ficha o en la importación, con
   * quién los cargó y por qué. Es el control de la excepción a «no hay membresía sin factura». Incluye las anuladas.
   */
  async membresiasSinFactura(empresa_id: string, f: { desde?: string; hasta?: string; page?: number; limit?: number }) {
    const { desde, hasta } = rango(f.desde, f.hasta);
    const { page, limit } = paginado(f);
    const where = {
      empresa_id,
      factura_id: null,
      origen: { in: [gym_membresia_origen.MANUAL, gym_membresia_origen.MIGRACION] },
      created_at: { gte: startOfDayAsuncion(desde), lte: endOfDayAsuncion(hasta) },
    };
    const [total, filas, porOrigen] = await Promise.all([
      this.prisma.gym_membresias.count({ where: { ...where, empresa_id } }),
      this.prisma.gym_membresias.findMany({
        where: { ...where, empresa_id },
        include: {
          plan: { select: { nombre: true } },
          socio: {
            select: {
              id: true,
              numero_socio: true,
              cliente: { select: { personas: { select: { razon_social: true, nro_documento: true, ruc: true, dv: true } } } },
            },
          },
        },
        orderBy: { created_at: 'desc' },
        skip: (page - 1) * limit,
        take: limit,
      }),
      this.prisma.gym_membresias.groupBy({ by: ['origen'], where: { ...where, empresa_id }, _count: { _all: true } }),
    ]);
    const usuarios = await this.prisma.usuario.findMany({
      where: { id: { in: [...new Set(filas.map((m) => m.created_by).filter((x): x is string => !!x))] } },
      select: { id: true, nombres: true, apellidos: true, username: true },
    });
    const nombreUsuario = new Map(usuarios.map((u) => [u.id, [u.nombres, u.apellidos].filter(Boolean).join(' ') || u.username || '']));
    const contar = (o: gym_membresia_origen) => porOrigen.find((g) => g.origen === o)?._count._all ?? 0;
    return {
      desde,
      hasta,
      total,
      page,
      limit,
      totales: { manuales: contar(gym_membresia_origen.MANUAL), importadas: contar(gym_membresia_origen.MIGRACION) },
      filas: filas.map((m) => ({
        id: m.id,
        origen: m.origen,
        estado: m.estado,
        plan: m.plan.nombre,
        fecha_inicio: deFecha(m.fecha_inicio),
        fecha_fin: deFecha(m.fecha_fin),
        motivo: m.motivo_sin_factura,
        motivo_anulacion: m.motivo_anulacion,
        cargada_at: m.created_at,
        cargada_por: m.created_by ? (nombreUsuario.get(m.created_by) ?? null) : null,
        socio: {
          id: m.socio.id,
          numero_socio: m.socio.numero_socio,
          nombre: m.socio.cliente.personas?.razon_social ?? '',
          documento: documentoDe(m.socio.cliente.personas),
        },
      })),
    };
  }
}
