Fuck yeah, Coffee!

/**
 * Calculate the remaining caffeine in the system based on consumption times and amounts.
 * 
 * @param firstCupTime - Time of first cup (HH:mm format)
 * @param lastCupTime - Time of last cup (HH:mm format)
 * @param numberOfCups - Number of cups consumed
 * @param strength - Caffeine per cup in mg
 * @param currentTime - Current time (HH:mm format)
 * @param halfLife - Half-life of caffeine in hours (default: 5)
 * @returns Object with caffeineRemaining and canHaveAnotherCup
 */
export function calculateCaffeine(
    firstCupTime: string,
    lastCupTime: string,
    numberOfCups: number,
    strength: number,
    currentTime: string,
    halfLife: number = 5
): { caffeineRemaining: number; canHaveAnotherCup: boolean } {
    const parseTime = (time: string): Date => {
        const [hours, minutes] = time.split(":").map(Number);
        const now = new Date();
        return new Date(now.getFullYear(), now.getMonth(), now.getDate(), hours, minutes);
    };

    const firstCup = parseTime(firstCupTime);
    const lastCup = parseTime(lastCupTime);
    const current = parseTime(currentTime);

    // Let's not defy physics.
    if (firstCup.getTime() > lastCup.getTime()) {
        throw new Error("First cup must be before your last cup.");
    }

    // Maybe we return a success response instead of an error?
    if (numberOfCups <= 0) {
        throw new Error("You haven't had any coffee yet.");
    }

    // If you _just had_ your cup we can return without calculating.
    if (firstCup.getTime() == current.getTime()) {
      return {
        caffeineRemaining: strength,
        canHaveAnotherCup: strength <= 100
      };
    }

    const caffeinePerCup = strength;
    const cups: Date[] = [];

    let interval = 0;
    if (numberOfCups == 1) {
      interval = 1;
    }

    if (numberOfCups > 2) {
      interval = (lastCup.getTime() - firstCup.getTime()) / numberOfCups;
    }

    for (let i = 0; i < numberOfCups; i++) {
        cups.push(new Date(firstCup.getTime() + i * interval));
    }

    let totalCaffeineRemaining = 0;

    cups.forEach((cupTime) => {
        const hoursSinceCup = (current.getTime() - cupTime.getTime()) / (1000 * 60 * 60);
        if (hoursSinceCup > 0) {
            const caffeineRemaining = caffeinePerCup * Math.pow(0.5, hoursSinceCup / halfLife);
            totalCaffeineRemaining += caffeineRemaining;
        }
    });

    return {
        caffeineRemaining: Math.ceil(totalCaffeineRemaining),
        canHaveAnotherCup: totalCaffeineRemaining <= 100,
    };
}

import { describe, it, expect } from "vitest";
import { calculateCaffeine } from "./caffeine_calculator";

describe("Caffeine Calculator", () => {
    it("calculates caffeine correctly for a single cup", () => {
      const tests:array = [
        {test: {firstcup: "08:00", lastcup: "08:00", numcups: 1, strength: 96, curtime: "13:00"}, expected: [48, true]},
        {test: {firstcup: "08:00", lastcup: "08:00", numcups: 1, strength: 96, curtime: "8:00"}, expected: [96, true]},
        {test: {firstcup: "08:00", lastcup: "08:00", numcups: 1, strength: 96, curtime: "8:01"}, expected: [96, true]},
        {test: {firstcup: "08:00", lastcup: "09:00", numcups: 1, strength: 96, curtime: "9:00"}, expected: [84, true]}
      ];
      
      tests.forEach((t) => {
        const result = calculateCaffeine(t.test.firstcup, t.test.lastcup, t.test.numcups, t.test.strength, t.test.curtime);
        expect(result.caffeineRemaining).toBeCloseTo(t.expected[0]); // Half-life decay
        expect(result.canHaveAnotherCup).toBe(t.expected[1]);
      });
    });

    it("handles multiple cups spread out during the day", () => {
        const tests:array = [
          {test: {firstcup: "08:00", lastcup: "12:00", numcups: 3, strength: 96, curtime: "23:00"}, expected: [44, true]},
          {test: {firstcup: "08:00", lastcup: "10:00", numcups: 2, strength: 96, curtime: "17:00"}, expected: [56, true]},
          {test: {firstcup: "08:00", lastcup: "11:00", numcups: 4, strength: 96, curtime: "17:00"}, expected: [130, false]},
          {test: {firstcup: "08:00", lastcup: "14:00", numcups: 5, strength: 96, curtime: "17:00"}, expected: [198, false]}
        ];
        
        tests.forEach((t) => {
          const result = calculateCaffeine(t.test.firstcup, t.test.lastcup, t.test.numcups, t.test.strength, t.test.curtime);
          expect(result.caffeineRemaining).toBeCloseTo(t.expected[0]); // Half-life decay
          expect(result.canHaveAnotherCup).toBe(t.expected[1]);
        });
    });

    it("throws an error if first cup is after last cup", () => {
        expect(() => {
            calculateCaffeine("14:00", "08:00", 1, 96, "10:00");
        }).toThrow("First cup must be before your last cup.");
    });

    it("throws an error if no coffee was consumed", () => {
        expect(() => {
            calculateCaffeine("08:00", "08:00", 0, 96, "10:00");
        }).toThrow("You haven't had any coffee yet.");
    });
});