import { prisma } from "@app/lib/prisma";

import { InsightType, InsightPeriod } from "@prisma/client";

import { InsightPeriodPayload } from "@app/lib/queue/types";

// Pearson correlation coefficient for two paired samples, in [-1, 1]. Returns

// 0 when there are fewer than two samples or either axis has no variance, so

// an absent signal reads as no correlation rather than a divide by zero.

export function pearson(xs: number[], ys: number[]): number {

  const n = xs.length;

  if (n < 2) return 0;

  const meanX = xs.reduce((a, b) => a + b, 0) / n;

  const meanY = ys.reduce((a, b) => a + b, 0) / n;

  const num = xs.reduce((sum, x, i) => sum + (x - meanX) * (ys[i] - meanY), 0);

  const denX = Math.sqrt(xs.reduce((sum, x) => sum + (x - meanX) ** 2, 0));

  const denY = Math.sqrt(ys.reduce((sum, y) => sum + (y - meanY) ** 2, 0));

  if (denX === 0 || denY === 0) return 0;

  return num / (denX * denY);

}

export function energySleepBody(score: number, sampleSize: number): string {

  const base = sampleSize < 5 ? " (dados limitados, continue registrando)" : "";

  if (score > 0.6)

    return `Seu sono tem forte impacto positivo na sua energia no dia seguinte.${base}`;

  if (score > 0.3)

    return `Seu sono tem impacto moderado na sua energia no dia seguinte.${base}`;

  if (score < -0.3)

    return `Curiosamente, mais sono está associado a menos energia — vale investigar.${base}`;

  return `Não encontramos uma relação clara entre seu sono e energia ainda.${base}`;

}

export async function processEnergySleep({

  userId,

  periodStart,

  periodEnd,

}: InsightPeriodPayload): Promise<void> {

  const start = new Date(periodStart);

  const end = new Date(periodEnd);

  const sleepRecords = await prisma.sleepRecord.findMany({

    where: { userId, date: { gte: start, lte: end } },

    orderBy: { date: "asc" },

  });

  if (sleepRecords.length < 3) return;

  // For each sleep record, find the closest mood entry on the following day

  // XXX: What if the user logs two sleep entries on the same day?

  const pairs: Array<{ sleep: number; energy: number }> = [];

  for (const record of sleepRecords) {

    const nextDayStart = new Date(record.date);

    nextDayStart.setDate(nextDayStart.getDate() + 1);

    const nextDayEnd = new Date(nextDayStart);

    nextDayEnd.setDate(nextDayEnd.getDate() + 1);

    const mood = await prisma.mood.findFirst({

      where: { userId, moment: { gte: nextDayStart, lt: nextDayEnd } },

      orderBy: { moment: "asc" },

      select: { energyLevel: true },

    });

    if (mood) {

      pairs.push({ sleep: record.average, energy: mood.energyLevel });

    }

  }

  if (pairs.length < 3) return;

  const sleepValues = pairs.map((p) => p.sleep);

  const energyValues = pairs.map((p) => p.energy);

  const score = parseFloat(pearson(sleepValues, energyValues).toFixed(3));

  await prisma.insight.upsert({

    where: {

      userId_type_periodStart: {

        userId,

        type: InsightType.ENERGY_SLEEP_CORRELATION,

        periodStart: start,

      },

    },

    update: {

      body: energySleepBody(score, pairs.length),

      metadata: { correlationScore: score, sampleSize: pairs.length },

      generatedAt: new Date(),

    },

    create: {

      userId,

      type: InsightType.ENERGY_SLEEP_CORRELATION,

      period: InsightPeriod.WEEKLY,

      title: "Sono e Energia",

      body: energySleepBody(score, pairs.length),

      metadata: { correlationScore: score, sampleSize: pairs.length },

      periodStart: start,

      periodEnd: end,

    },

  });

}