tdeeAlgorithm.ts

/**
 * CODE SAMPLE — the adaptive calorie-target algorithm described in the
 * README's "A technical challenge" section: the regression fit plus the
 * guardrails around it.
 *
 * Smart TDEE, Stoke's core differentiator.
 *
 * Most trackers nudge calories weekly off noisy scale data. Stoke fits a
 * LINEAR REGRESSION trend line through the last 4 weeks of weigh-ins (robust
 * to noise and missing days) and only suggests a small, safe adjustment when
 * the trend has been *consistently* off-target. It never auto-applies, the
 * user approves.
 *
 * Guardrails:
 *  - need ≥ 10 weigh-ins in the 28-day window (enough signal)
 *  - the deviation must hold over BOTH the 4-week and the most-recent-2-week
 *    trend (not one week of noise)
 *  - at most ±100 kcal per adjustment, and at most one adjustment per 2 weeks
 *  - never below the safety floor (1200 kcal female / 1400 kcal otherwise)
 *
 * All reads/writes are scoped with `.eq('user_id', …)` and protected by
 * owner-only RLS (see migration 0004).
 */
import { defaultGoalRate } from '@/constants/profile';
import { supabase } from '@/lib/supabase';
import { Profile, TdeeAdjustment } from '@/types/database';
import { addDays, todayISO } from '@/utils/date';
import { KCAL_PER_KG, macrosForCalories } from '@/utils/nutrition';

const WINDOW_DAYS = 28;
const RECENT_DAYS = 14;
const MIN_ENTRIES = 10;
/** A weekly trend within ±this of the goal counts as on-target (kg/week). */
const SLOPE_TOLERANCE = 0.15;
const MAX_ADJUST_KCAL = 100;
const MIN_DAYS_BETWEEN_ADJUSTMENTS = 14;
const FEMALE_FLOOR = 1200;
const DEFAULT_FLOOR = 1400; // male / other

export interface WeightSample {
  iso: string; // YYYY-MM-DD
  kg: number;
}

export type TdeeStatus = 'insufficient_data' | 'on_track' | 'too_slow' | 'too_fast';

export interface TdeeRecommendation {
  oldTarget: number;
  newTarget: number;
  /** Signed kcal delta (negative = reduce). */
  deltaKcal: number;
  reason: string;
  slopeKgPerWeek: number;
}

export interface TdeeInsight {
  status: TdeeStatus;
  /** Weigh-ins inside the 28-day window. */
  entryCount: number;
  /** Fitted 4-week trend (kg/week), or null when < 2 points. */
  slopeKgPerWeek: number | null;
  /** Target weekly rate from the user's goal (kg/week). */
  expectedSlopeKgPerWeek: number;
  lastAdjustment: TdeeAdjustment | null;
  /** Present only when a safe, consistent, due adjustment is warranted. */
  recommendation: TdeeRecommendation | null;
}

// ── Pure math ────────────────────────────────────────────────────────────────

/** Least-squares slope of y over x. Null if < 2 points or no x-variance. */
export function linearRegressionSlope(points: { x: number; y: number }[]): number | null {
  const n = points.length;
  if (n < 2) return null;
  const meanX = points.reduce((s, p) => s + p.x, 0) / n;
  const meanY = points.reduce((s, p) => s + p.y, 0) / n;
  let num = 0;
  let den = 0;
  for (const p of points) {
    const dx = p.x - meanX;
    num += dx * (p.y - meanY);
    den += dx * dx;
  }
  if (den === 0) return null;
  return num / den;
}

/** Weight-trend slope in kg/WEEK from dated samples (x measured in days). */
export function weeklySlope(samples: WeightSample[]): number | null {
  if (samples.length < 2) return null;
  const t0 = Date.parse(samples[0].iso);
  const points = samples.map((s) => ({ x: (Date.parse(s.iso) - t0) / 86_400_000, y: s.kg }));
  const perDay = linearRegressionSlope(points);
  return perDay == null ? null : perDay * 7;
}

const sign = (x: number): number => (x > 0 ? 1 : x < 0 ? -1 : 0);

function classify(goal: Profile['goal'], deviation: number): Exclude<TdeeStatus, 'insufficient_data'> {
  if (Math.abs(deviation) <= SLOPE_TOLERANCE) return 'on_track';
  // deviation > 0 ⇒ actual slope above expected (gaining more / losing less).
  if (goal === 'lose') return deviation > 0 ? 'too_slow' : 'too_fast';
  return deviation > 0 ? 'too_fast' : 'too_slow'; // gain / maintain
}

function buildReason(goal: Profile['goal'], deviation: number, deltaKcal: number): string {
  const amt = Math.abs(deltaKcal);
  const dir = deltaKcal < 0 ? `reducing by ${amt} kcal` : `adding ${amt} kcal`;
  if (goal === 'lose') {
    return deviation > 0
      ? `Your trend suggests you're losing slower than your goal. Consider ${dir}.`
      : `You're losing faster than your goal, ${dir} keeps it sustainable.`;
  }
  if (goal === 'gain') {
    return deviation > 0
      ? `You're gaining faster than your goal. Consider ${dir}.`
      : `You're gaining slower than your goal. Consider ${dir}.`;
  }
  return deviation > 0
    ? `Your weight is trending up. Consider ${dir} to hold steady.`
    : `Your weight is trending down. Consider ${dir} to hold steady.`;
}

function floorFor(sex: Profile['sex']): number {
  return sex === 'female' ? FEMALE_FLOOR : DEFAULT_FLOOR;
}

function daysSince(iso: string, now: Date): number {
  return (now.getTime() - Date.parse(iso)) / 86_400_000;
}

/**
 * Pure analysis: given the window's weigh-ins, the profile and the last
 * adjustment, decide the trend status and whether to recommend a change.
 */
export function computeInsight(input: {
  weights: WeightSample[];
  profile: Profile;
  lastAdjustment: TdeeAdjustment | null;
  now: Date;
}): TdeeInsight {
  const { profile, lastAdjustment, now } = input;
  const windowStart = addDays(todayISO(), -(WINDOW_DAYS - 1));
  const recentStart = addDays(todayISO(), -(RECENT_DAYS - 1));

  const samples = input.weights
    .filter((s) => s.iso >= windowStart)
    .sort((a, b) => (a.iso < b.iso ? -1 : 1));
  const recent = samples.filter((s) => s.iso >= recentStart);

  const expectedSlopeKgPerWeek = profile.goal_rate_kg_per_week ?? defaultGoalRate(profile.goal ?? 'maintain');
  const slopeKgPerWeek = weeklySlope(samples);

  const base: TdeeInsight = {
    status: 'insufficient_data',
    entryCount: samples.length,
    slopeKgPerWeek,
    expectedSlopeKgPerWeek,
    lastAdjustment,
    recommendation: null,
  };

  // Gate 1: enough data + a fitted slope.
  if (samples.length < MIN_ENTRIES || slopeKgPerWeek == null) return base;

  const deviation = slopeKgPerWeek - expectedSlopeKgPerWeek;
  const status = classify(profile.goal, deviation);
  const insight: TdeeInsight = { ...base, status };
  if (status === 'on_track') return insight;

  // Gate 2: the 2-week trend must agree in direction (not one week of noise).
  const recentSlope = recent.length >= 4 ? weeklySlope(recent) : null;
  if (recentSlope == null) return insight;
  const recentDeviation = recentSlope - expectedSlopeKgPerWeek;
  if (sign(recentDeviation) !== sign(deviation)) return insight;

  // Gate 3: at most one adjustment per 2 weeks.
  if (lastAdjustment && daysSince(lastAdjustment.adjusted_at, now) < MIN_DAYS_BETWEEN_ADJUSTMENTS) {
    return insight;
  }

  // Gate 4: a target to adjust + a safe, non-zero change.
  const oldTarget = profile.calorie_target ?? 0;
  if (oldTarget <= 0) return insight;

  // Daily kcal change needed to move the weekly trend by `deviation`, capped.
  const rawKcal = (deviation * KCAL_PER_KG) / 7;
  let deltaKcal = Math.round(Math.max(-MAX_ADJUST_KCAL, Math.min(MAX_ADJUST_KCAL, -rawKcal)) / 10) * 10;

  const floor = floorFor(profile.sex);
  let newTarget = oldTarget + deltaKcal;
  if (newTarget < floor) {
    newTarget = floor;
    deltaKcal = newTarget - oldTarget; // smaller (or zero) reduction at the floor
  }
  if (deltaKcal === 0) return insight; // already at the safety floor, nothing safe to do

  return {
    ...insight,
    recommendation: {
      oldTarget,
      newTarget,
      deltaKcal,
      slopeKgPerWeek,
      reason: buildReason(profile.goal, deviation, deltaKcal),
    },
  };
}

// ── Adaptive expenditure estimate (Dashboard hero row + Trends card) ─────────

export interface DailyIntake {
  iso: string; // YYYY-MM-DD
  calories: number;
}

/**
 * Estimated daily expenditure (adaptive TDEE) for the 28-day window ending at
 * `endIso`: average logged intake minus the daily energy imbalance implied by
 * the fitted weight trend. Null until there is enough signal on BOTH sides
 * (>= MIN_ENTRIES weigh-ins and >= MIN_ENTRIES logged days in the window).
 */
export function estimateExpenditure(
  weights: WeightSample[],
  intake: DailyIntake[],
  endIso: string,
): number | null {
  const startIso = addDays(endIso, -(WINDOW_DAYS - 1));
  const w = weights.filter((s) => s.iso >= startIso && s.iso <= endIso).sort((a, b) => (a.iso < b.iso ? -1 : 1));
  const days = intake.filter((d) => d.iso >= startIso && d.iso <= endIso && d.calories > 0);
  if (w.length < MIN_ENTRIES || days.length < MIN_ENTRIES) return null;
  const slope = weeklySlope(w);
  if (slope == null) return null;
  const avgIntake = days.reduce((s, d) => s + d.calories, 0) / days.length;
  return Math.round(avgIntake - (slope * KCAL_PER_KG) / 7);
}

export interface ExpenditureEstimate {
  kcalPerDay: number;
  /** Change vs the estimate one week earlier; null when last week lacks data. */
  deltaVsLastWeek: number | null;
  /** Weekly estimates, oldest to newest (current included), for sparklines. */
  series: number[];
}

const EXPENDITURE_POINTS = 6;

/** Fetch weights + daily intake once and derive the rolling weekly estimates. */
export async function getExpenditureEstimate(userId: string): Promise<ExpenditureEstimate | null> {
  const spanDays = WINDOW_DAYS + (EXPENDITURE_POINTS - 1) * 7;
  const sinceIso = addDays(todayISO(), -(spanDays - 1));
  const [weights, intake] = await Promise.all([
    getWeightSamplesSince(userId, sinceIso),
    getDailyIntakeSince(userId, sinceIso),
  ]);
  const current = estimateExpenditure(weights, intake, todayISO());
  if (current == null) return null;
  const prev = estimateExpenditure(weights, intake, addDays(todayISO(), -7));
  const series: number[] = [];
  for (let k = EXPENDITURE_POINTS - 1; k >= 0; k--) {
    const est = estimateExpenditure(weights, intake, addDays(todayISO(), -7 * k));
    if (est != null) series.push(est);
  }
  return { kcalPerDay: current, deltaVsLastWeek: prev == null ? null : current - prev, series };
}

// ── Data access ──────────────────────────────────────────────────────────────

async function getDailyIntakeSince(userId: string, sinceIso: string): Promise<DailyIntake[]> {
  const { data } = await supabase
    .from('food_logs')
    .select('date, calories')
    .eq('user_id', userId)
    .gte('date', sinceIso);
  const byDay = new Map<string, number>();
  for (const r of data ?? []) byDay.set(r.date, (byDay.get(r.date) ?? 0) + Number(r.calories));
  return [...byDay.entries()].map(([iso, calories]) => ({ iso, calories }));
}

async function getWeightSamplesSince(userId: string, sinceIso: string): Promise<WeightSample[]> {
  const { data } = await supabase
    .from('weight_logs')
    .select('date, weight_kg')
    .eq('user_id', userId)
    .gte('date', sinceIso)
    .order('date', { ascending: true });
  return (data ?? []).map((r) => ({ iso: r.date, kg: Number(r.weight_kg) }));
}

/** The user's most recent approved adjustment (for the cooldown + UI). */
export async function getLastAdjustment(userId: string): Promise<TdeeAdjustment | null> {
  const { data } = await supabase
    .from('tdee_adjustments')
    .select('*')
    .eq('user_id', userId)
    .order('adjusted_at', { ascending: false })
    .limit(1)
    .maybeSingle();
  return data ?? null;
}

/** Fetch the window + last adjustment and run the analysis. */
export async function getTdeeInsight(userId: string, profile: Profile): Promise<TdeeInsight> {
  const sinceIso = addDays(todayISO(), -(WINDOW_DAYS - 1));
  const [weights, lastAdjustment] = await Promise.all([
    getWeightSamplesSince(userId, sinceIso),
    getLastAdjustment(userId),
  ]);
  return computeInsight({ weights, profile, lastAdjustment, now: new Date() });
}

/**
 * Apply an approved recommendation: append the audit row, then update the
 * profile's calorie target + macro split (kept consistent via macrosForCalories).
 */
export async function applyTdeeAdjustment(
  userId: string,
  profile: Profile,
  rec: TdeeRecommendation,
): Promise<void> {
  const { error: insErr } = await supabase.from('tdee_adjustments').insert({
    user_id: userId,
    old_target: rec.oldTarget,
    new_target: rec.newTarget,
    trend_slope: Math.round(rec.slopeKgPerWeek * 1000) / 1000,
    reason: rec.reason,
  });
  if (insErr) throw insErr;

  const macros = macrosForCalories(rec.newTarget, profile.weight_kg ?? 0);
  const { error: upErr } = await supabase
    .from('profiles')
    .update({
      calorie_target: rec.newTarget,
      protein_target_g: macros.proteinTargetG,
      carb_target_g: macros.carbTargetG,
      fat_target_g: macros.fatTargetG,
    })
    .eq('id', userId);
  if (upErr) throw upErr;
}