import { Prisma } from '@prisma/client';
import { EstadoSuscripcion, tipoModuloSuscripcion } from './dto/enum-sucripcion';

/**
 * Funciones (submódulos no-addon) que un plan deja afuera de sus módulos.
 *
 * `plan_submodulos` lista las funciones tildadas en el editor del plan. Una función
 * cuenta como incluida si:
 * - está tildada, o
 * - su módulo no tiene ninguna función tildada (planes anteriores a la lista), o
 * - se creó después del último guardado de la lista: el plan no la conocía, así que
 *   no la pudo excluir. Sin esta regla, cada función nueva del catálogo les quedaría
 *   afuera a todos los planes ya guardados.
 *
 * El plan no decide nada en tiempo de ejecución: sus exclusiones se copian a
 * `suscripcion_submodulos` (active=false) al crear la suscripción y al guardar el
 * plan, y de ahí las leen los guards, el menú y los permisos.
 */

type Db = Prisma.TransactionClient;

export type FuncionCatalogo = { id: string; modulo_id: string | null; created_at: Date };

export function calcularSubmodulosPlan(params: {
  moduloIds: string[];
  marcadas: Set<string>;
  /** Último guardado de la lista de funciones del plan; null = nunca se guardó. */
  corte: Date | null;
  catalogo: FuncionCatalogo[];
}) {
  const { moduloIds, marcadas, corte, catalogo } = params;
  const modulos = new Set(moduloIds);
  const modulosConMarcas = new Set(
    catalogo.filter((f) => marcadas.has(f.id)).map((f) => f.modulo_id),
  );
  const incluidos = new Set<string>();
  const excluidos = new Set<string>();
  for (const f of catalogo) {
    if (!f.modulo_id || !modulos.has(f.modulo_id)) continue;
    const incluida =
      marcadas.has(f.id) ||
      !modulosConMarcas.has(f.modulo_id) ||
      !corte ||
      f.created_at > corte;
    (incluida ? incluidos : excluidos).add(f.id);
  }
  return { incluidos, excluidos };
}

export async function submodulosDelPlan(db: Db, planId: string) {
  const [modulos, marcadas, corte] = await Promise.all([
    db.plan_modulos.findMany({ where: { plan_id: planId }, select: { modulo_id: true } }),
    db.plan_submodulos.findMany({
      where: { plan_id: planId, active: true },
      select: { submodulo_id: true },
    }),
    db.plan_submodulos.aggregate({ where: { plan_id: planId }, _max: { updated_at: true } }),
  ]);
  const moduloIds = modulos.map((m) => m.modulo_id);
  const catalogo = moduloIds.length
    ? await db.submodulos.findMany({
        where: { modulo_id: { in: moduloIds }, active: true, es_addon: false },
        select: { id: true, modulo_id: true, created_at: true },
      })
    : [];
  return calcularSubmodulosPlan({
    moduloIds,
    marcadas: new Set(marcadas.map((m) => m.submodulo_id)),
    corte: corte._max.updated_at,
    catalogo,
  });
}

/** Ids de los submódulos de `ids` que cuelgan de los módulos Incluidos (del plan) de la suscripción. */
async function filtrarPorModulosIncluidos(db: Db, suscripcionId: string, ids: string[]) {
  if (!ids.length) return [];
  const incluidos = await db.suscripcion_modulos.findMany({
    where: { suscripcion_id: suscripcionId, activo: true, tipo: tipoModuloSuscripcion.Incluido },
    select: { modulo_id: true },
  });
  const moduloIds = incluidos.map((m) => m.modulo_id).filter((id): id is string => !!id);
  if (!moduloIds.length) return [];
  const subs = await db.submodulos.findMany({
    where: { id: { in: ids }, modulo_id: { in: moduloIds } },
    select: { id: true },
  });
  return subs.map((s) => s.id);
}

/**
 * Copia a una suscripción recién creada las exclusiones de su plan. Solo toca los
 * módulos que vienen del plan (Incluido): un módulo Adicional se vende entero y
 * uno Parcial maneja sus propias filas.
 */
export async function aplicarExclusionesDelPlan(db: Db, suscripcionId: string, planId: string) {
  const { excluidos } = await submodulosDelPlan(db, planId);
  const ids = await filtrarPorModulosIncluidos(db, suscripcionId, [...excluidos]);
  if (!ids.length) return 0;
  const res = await db.suscripcion_submodulos.createMany({
    data: ids.map((submodulo_id) => ({ suscripcion_id: suscripcionId, submodulo_id, active: false, precio: 0 })),
    skipDuplicates: true,
  });
  return res.count;
}

/**
 * Baja a las suscripciones del plan solo lo que cambió en un guardado: lo que se
 * destildó queda excluido y lo que se volvió a tildar se reincluye. Lo que no se
 * tocó no cambia, así una suscripción conserva los ajustes hechos a mano. Si se
 * reincluye en el plan una función que una suscripción tenía excluida a mano,
 * vuelve a estar incluida (manda el último cambio).
 */
export async function propagarCambioDePlan(
  db: Db,
  planId: string,
  excluidosAntes: Set<string>,
  despues: { incluidos: Set<string>; excluidos: Set<string> },
) {
  const nuevas = [...despues.excluidos].filter((id) => !excluidosAntes.has(id));
  // Solo lo que sigue en el plan y ahora está tildado: si se sacó un módulo del
  // plan, sus funciones no se "reincluyen" por desaparecer de la lista.
  const reincluidas = [...excluidosAntes].filter((id) => despues.incluidos.has(id));
  const resultado = { suscripciones: 0, excluidas: 0, reincluidas: 0 };
  if (!nuevas.length && !reincluidas.length) return resultado;

  const suscripciones = await db.suscripciones.findMany({
    where: { plan_id: planId, estado: { not: EstadoSuscripcion.Cancelado } },
    select: { id: true },
  });
  for (const { id } of suscripciones) {
    const aExcluir = await filtrarPorModulosIncluidos(db, id, nuevas);
    const aReincluir = await filtrarPorModulosIncluidos(db, id, reincluidas);
    if (aExcluir.length) {
      const res = await db.suscripcion_submodulos.createMany({
        data: aExcluir.map((submodulo_id) => ({ suscripcion_id: id, submodulo_id, active: false, precio: 0 })),
        skipDuplicates: true,
      });
      resultado.excluidas += res.count;
    }
    if (aReincluir.length) {
      const res = await db.suscripcion_submodulos.deleteMany({
        where: { suscripcion_id: id, submodulo_id: { in: aReincluir }, active: false },
      });
      resultado.reincluidas += res.count;
    }
    if (aExcluir.length || aReincluir.length) resultado.suscripciones += 1;
  }
  return resultado;
}
