src/lib/games/score-utils.test.ts

import { describe, it, expect } from "vitest";
import { normalizeScore, denormalizeScore } from "./score-utils";

describe("normalizeScore", () => {
  describe("lower-is-better games", () => {
    it("normalizes memory scores (defaultHighScore 999)", () => {
      // memory: 999 - rawScore
      expect(normalizeScore("memory", 12)).toBe(999 - 12);
      expect(normalizeScore("memory", 0)).toBe(999);
      expect(normalizeScore("memory", 999)).toBe(0);
    });

    it("normalizes reaction scores (defaultHighScore 9999)", () => {
      // reaction: 9999 - rawScore
      expect(normalizeScore("reaction", 200)).toBe(9999 - 200);
      expect(normalizeScore("reaction", 0)).toBe(9999);
      expect(normalizeScore("reaction", 9999)).toBe(0);
    });

    it("normalizes wordle scores (defaultHighScore 7)", () => {
      // wordle: 7 - rawScore
      expect(normalizeScore("wordle", 3)).toBe(7 - 3);
      expect(normalizeScore("wordle", 1)).toBe(6);
      expect(normalizeScore("wordle", 7)).toBe(0);
    });
  });

  describe("higher-is-better games", () => {
    it("passes sequence scores through unchanged", () => {
      expect(normalizeScore("sequence", 15)).toBe(15);
      expect(normalizeScore("sequence", 0)).toBe(0);
    });

    it("passes aim scores through unchanged", () => {
      expect(normalizeScore("aim", 500)).toBe(500);
      expect(normalizeScore("aim", 0)).toBe(0);
    });

    it("passes typing scores through unchanged", () => {
      expect(normalizeScore("typing", 120)).toBe(120);
      expect(normalizeScore("typing", 0)).toBe(0);
    });
  });
});

describe("denormalizeScore", () => {
  describe("lower-is-better games", () => {
    it("reverses memory normalization", () => {
      expect(denormalizeScore("memory", 999 - 12)).toBe(12);
    });

    it("reverses reaction normalization", () => {
      expect(denormalizeScore("reaction", 9999 - 200)).toBe(200);
    });

    it("reverses wordle normalization", () => {
      expect(denormalizeScore("wordle", 7 - 3)).toBe(3);
    });
  });

  describe("higher-is-better games", () => {
    it("passes scores through unchanged", () => {
      expect(denormalizeScore("sequence", 15)).toBe(15);
      expect(denormalizeScore("aim", 500)).toBe(500);
      expect(denormalizeScore("typing", 120)).toBe(120);
    });
  });
});

describe("round-trip normalization", () => {
  it("normalize then denormalize returns the original score for lower-is-better", () => {
    const memoryRaw = 14;
    expect(denormalizeScore("memory", normalizeScore("memory", memoryRaw))).toBe(memoryRaw);

    const reactionRaw = 250;
    expect(denormalizeScore("reaction", normalizeScore("reaction", reactionRaw))).toBe(reactionRaw);

    const wordleRaw = 4;
    expect(denormalizeScore("wordle", normalizeScore("wordle", wordleRaw))).toBe(wordleRaw);
  });

  it("normalize then denormalize returns the original score for higher-is-better", () => {
    const sequenceRaw = 22;
    expect(denormalizeScore("sequence", normalizeScore("sequence", sequenceRaw))).toBe(sequenceRaw);

    const aimRaw = 850;
    expect(denormalizeScore("aim", normalizeScore("aim", aimRaw))).toBe(aimRaw);

    const typingRaw = 95;
    expect(denormalizeScore("typing", normalizeScore("typing", typingRaw))).toBe(typingRaw);
  });
});