import { prisma } from "@app/lib/prisma";
import { InsightType, InsightPeriod } from "@prisma/client";
import { InsightPeriodPayload } from "@app/lib/queue/types";
import { avg } from "@app/utils/calc";
import {
  appDayWindow,
  previousAppDay,
  DAY_WINDOW_LABEL,
} from "@app/lib/queue/processors/insights/utils";

type EnergyEntry = {
  energyLevel: number;
  stressLevel: number;
  anxietyLevel: number;
};

export type DailyEnergyMetadata = {
  avgEnergy: number;
  avgStress: number;
  avgAnxiety: number;
  peak: number;
  trough: number;
  dayTrend: number | null;
  entryCount: number;
  yesterdayAvg: number | null;
  diffEnergy: number | null;
  windowLabel: string;
};

export function computeDailyEnergy(
  moods: EnergyEntry[],
  yesterdayMoods: { energyLevel: number }[],
): { metadata: DailyEnergyMetadata; dayTrend: number | null } {
  const avgEnergy = parseFloat(avg(moods.map((m) => m.energyLevel)).toFixed(2));
  const avgStress = parseFloat(avg(moods.map((m) => m.stressLevel)).toFixed(2));
  const avgAnxiety = parseFloat(
    avg(moods.map((m) => m.anxietyLevel)).toFixed(2),
  );
  const peak = Math.max(...moods.map((m) => m.energyLevel));
  const trough = Math.min(...moods.map((m) => m.energyLevel));

  // Trend across the day: compare first half vs second half entries
  // Not that great, but it works
  const mid = Math.floor(moods.length / 2);
  const morningAvg =
    moods.length > 1
      ? avg(moods.slice(0, mid).map((m) => m.energyLevel))
      : null;

  const eveningAvg =
    moods.length > 1 ? avg(moods.slice(mid).map((m) => m.energyLevel)) : null;

  const dayTrend =
    morningAvg && eveningAvg
      ? parseFloat((((eveningAvg - morningAvg) / morningAvg) * 100).toFixed(1))
      : null;

  const yesterdayAvg =
    yesterdayMoods.length > 0
      ? parseFloat(avg(yesterdayMoods.map((m) => m.energyLevel)).toFixed(2))
      : null;

  // Positive means more energy than yesterday; null when there is nothing to
  // compare against
  const diffEnergy =
    yesterdayAvg !== null
      ? parseFloat((avgEnergy - yesterdayAvg).toFixed(2))
      : null;

  const metadata: DailyEnergyMetadata = {
    avgEnergy,
    avgStress,
    avgAnxiety,
    peak,
    trough,
    dayTrend,
    entryCount: moods.length,
    yesterdayAvg,
    diffEnergy,
    windowLabel: DAY_WINDOW_LABEL,
  };

  return { metadata, dayTrend };
}

export function dailyEnergyBody(
  avgEnergy: number,
  dayTrend: number | null,
): string {
  const level = avgEnergy >= 7 ? "alta" : avgEnergy >= 4 ? "moderada" : "baixa";
  if (dayTrend === null) return `Energia ${level} hoje.`;
  if (dayTrend > 10)
    return `Energia ${level} hoje, com melhora ao longo do dia.`;
  if (dayTrend < -10)
    return `Energia ${level} hoje, com queda ao longo do dia.`;
  return `Energia ${level} e estável ao longo do dia.`;
}

export async function processDailyEnergy({
  userId,
  periodStart,
}: InsightPeriodPayload): Promise<void> {
  const { start, end } = appDayWindow(new Date(periodStart));
  const yesterdayStart = previousAppDay(start);

  const [moods, yesterdayMoods] = await Promise.all([
    prisma.mood.findMany({
      where: { userId, moment: { gte: start, lt: end } },
      orderBy: { moment: "asc" },
      select: {
        energyLevel: true,
        stressLevel: true,
        anxietyLevel: true,
        selectedMood: true,
        moment: true,
      },
    }),
    prisma.mood.findMany({
      where: { userId, moment: { gte: yesterdayStart, lt: start } },
      select: { energyLevel: true },
    }),
  ]);

  if (moods.length === 0) return;

  const { metadata, dayTrend } = computeDailyEnergy(moods, yesterdayMoods);

  await prisma.insight.upsert({
    where: {
      userId_type_periodStart: {
        userId,
        type: InsightType.DAILY_ENERGY,
        periodStart: start,
      },
    },
    update: {
      body: dailyEnergyBody(metadata.avgEnergy, dayTrend),
      metadata,
      generatedAt: new Date(),
    },
    create: {
      userId,
      type: InsightType.DAILY_ENERGY,
      period: InsightPeriod.DAILY,
      title: "Energia do Dia",
      body: dailyEnergyBody(metadata.avgEnergy, dayTrend),
      metadata,
      periodStart: start,
      periodEnd: end,
    },
  });
}