Jak liczymy

/**
 * Oblicza średnią ważoną ocen.
 *
 * Wzór: średnia = Σ(ocenaᵢ × wagaᵢ) / Σ(wagaᵢ)
 *
 * @param entries - lista par { ocena, waga }
 * @returns średnia ważona
 * @throws gdy lista jest pusta lub suma wag wynosi 0
 */
export function weightedAverage(entries: GradeWeightEntry[]): number {
  if (entries.length === 0) {
    throw new Error("Nie można obliczyć średniej ważonej z pustej listy.");
  }

  let weightedSum = 0;
  let totalWeight = 0;

  for (const entry of entries) {
    if (entry.weight < 0) {
      throw new Error("Waga nie może być ujemna.");
    }
    weightedSum += entry.grade * entry.weight;
    totalWeight += entry.weight;
  }

  if (totalWeight === 0) {
    throw new Error("Suma wag musi być większa od zera.");
  }

  return weightedSum / totalWeight;
}

/**
 * Oblicza zwykłą średnią arytmetyczną.
 *
 * Wzór: średnia = Σ(ocenaᵢ) / n
 *
 * @param grades - lista ocen
 * @returns średnia arytmetyczna
 * @throws gdy lista jest pusta
 */
export function simpleAverage(grades: number[]): number {
  if (grades.length === 0) {
    throw new Error("Nie można obliczyć średniej z pustej listy ocen.");
  }

  const sum = grades.reduce((acc, grade) => acc + grade, 0);
  return sum / grades.length;
}

/**
 * Wylicza ocenę wymaganą z kolejnego wpisu, aby osiągnąć docelową średnią ważoną.
 *
 * Wzór:
 *   wymagana = (docelowa × (Σw + wₙ) − Σ(oᵢ×wᵢ)) / wₙ
 *
 * Wynik jest przycinany (clamp) do skali 1–6. Flagi:
 * - `achievable: false` gdy wynik matematyczny > 6 (cel niemożliwy)
 * - gdy wynik ≤ 1, cel jest już gwarantowany nawet przy najniższej ocenie
 *
 * @param currentEntries - dotychczasowe oceny z wagami
 * @param targetAverage - docelowa średnia ważona
 * @param nextWeight - waga kolejnej (planowanej) oceny; musi być > 0
 */
export function targetGrade(
  currentEntries: GradeWeightEntry[],
  targetAverage: number,
  nextWeight: number,
): TargetGradeResult {
  if (nextWeight <= 0) {
    throw new Error("Waga kolejnej oceny musi być większa od zera.");
  }

  if (currentEntries.some((e) => e.weight < 0)) {
    throw new Error("Waga nie może być ujemna.");
  }

  const currentWeightSum = currentEntries.reduce((s, e) => s + e.weight, 0);
  const currentWeightedSum = currentEntries.reduce(
    (s, e) => s + e.grade * e.weight,
    0,
  );

  const rawRequired =
    (targetAverage * (currentWeightSum + nextWeight) - currentWeightedSum) /
    nextWeight;

  // Cel już osiągnięty / przekroczony przy istniejących ocenach
  // (nawet ocena 1 nie obniży średniej poniżej celu).
  if (currentWeightSum > 0) {
    const currentAvg = weightedAverage(currentEntries);
    const avgIfMin = weightedAverage([
      ...currentEntries,
      { grade: POLISH_GRADE_MIN, weight: nextWeight },
    ]);
    if (avgIfMin >= targetAverage) {
      return {
        requiredGrade: POLISH_GRADE_MIN,
        achievable: true,
        note: `Cel ${targetAverage} jest już gwarantowany (bieżąca średnia: ${formatNum(currentAvg)}). Wystarczy ocena ${POLISH_GRADE_MIN}.`,
      };
    }
  }

  if (rawRequired > POLISH_GRADE_MAX) {
    return {
      requiredGrade: POLISH_GRADE_MAX,
      achievable: false,
      note: `Cel ${targetAverage} jest matematycznie niemożliwy — wymagana ocena ${formatNum(rawRequired)} przekracza maksimum skali (${POLISH_GRADE_MAX}).`,
    };
  }

  if (rawRequired <= POLISH_GRADE_MIN) {
    return {
      requiredGrade: POLISH_GRADE_MIN,
      achievable: true,
      note: `Cel ${targetAverage} jest już gwarantowany — wystarczy ocena ${POLISH_GRADE_MIN} (wyliczone: ${formatNum(rawRequired)}).`,
    };
  }

  const clamped = Math.min(
    POLISH_GRADE_MAX,
    Math.max(POLISH_GRADE_MIN, rawRequired),
  );

  return {
    requiredGrade: clamped,
    achievable: true,
    note: `Aby osiągnąć średnią ${targetAverage}, potrzebujesz oceny ${formatNum(clamped)}.`,
  };
}

/**
 * Przelicza ocenę tekstową (np. „5+”, „4−”) na wartość liczbową.
 *
 * @param grade - ocena jako string (dopuszczalne: „5+”, „5-”, „5−”, „4,5”, „4.5”)
 * @param ruleset - zestaw reguł przeliczenia
 * @param customMap - wymagane przy ruleset „custom”; klucze znormalizowane (bez spacji, − → -)
 * @returns wartość liczbowa oceny
 */
export function plusMinusToNumeric(
  grade: string,
  ruleset: PlusMinusRuleset,
  customMap?: Record<string, number>,
): number {
  const key = normalizeGradeKey(grade);

  // Jawna liczba dziesiętna (np. "4.5") — bez mapy +/-
  if (/^\d+\.\d+$/.test(key)) {
    return Number(key);
  }

  const map = resolveMap(ruleset, customMap);
  const value = map[key];
  if (value === undefined) {
    throw new Error(
      `Nieznana ocena "${grade}" (znormalizowana: "${key}") w ruleset "${ruleset}".`,
    );
  }
  return value;
}

/**
 * Oblicza średnią ważoną punktami ECTS.
 *
 * Wzór (po agregacji podejść): średnia = Σ(ocena × ECTS) / Σ(ECTS)
 *
 * Obsługa poprawek (`resitHandling`) — wpisy z tym samym `subjectId`:
 * - `"average"` (styl UJ): uśrednij oceny z podejść, potem zastosuj ECTS raz
 * - `"latest"`: weź ocenę z ostatniego wpisu dla danego przedmiotu
 *
 * @param entries - oceny z ECTS i identyfikatorem przedmiotu
 * @param resitHandling - sposób łączenia poprawek
 */
export function ectsWeightedAverage(
  entries: EctsGradeEntry[],
  resitHandling: "average" | "latest",
): number {
  if (entries.length === 0) {
    throw new Error("Nie można obliczyć średniej ECTS z pustej listy.");
  }

  const bySubject = new Map<
    string,
    { grades: number[]; ects: number }
  >();

  for (const entry of entries) {
    if (entry.ects < 0) {
      throw new Error("Liczba punktów ECTS nie może być ujemna.");
    }
    if (!entry.subjectId) {
      throw new Error("Każdy wpis ECTS wymaga subjectId.");
    }

    const existing = bySubject.get(entry.subjectId);
    if (!existing) {
      bySubject.set(entry.subjectId, {
        grades: [entry.grade],
        ects: entry.ects,
      });
    } else {
      existing.grades.push(entry.grade);
      // ECTS przedmiotu — ostatnia podana wartość (zwykle stała)
      existing.ects = entry.ects;
    }
  }

  let weightedSum = 0;
  let totalEcts = 0;

  for (const { grades, ects } of bySubject.values()) {
    if (ects === 0) {
      continue;
    }

    let grade: number;
    if (grades.length === 1) {
      grade = grades[0]!;
    } else if (resitHandling === "average") {
      grade = grades.reduce((a, b) => a + b, 0) / grades.length;
    } else {
      grade = grades[grades.length - 1]!;
    }

    weightedSum += grade * ects;
    totalEcts += ects;
  }

  if (totalEcts === 0) {
    throw new Error("Suma punktów ECTS musi być większa od zera.");
  }

  return weightedSum / totalEcts;
}

/**
 * Oblicza medianę zbioru liczb.
 *
 * Wzór:
 * - przy nieparzystej liczbie elementów: wartość środkowa
 * - przy parzystej: średnia dwóch środkowych
 *
 * @param values - lista wartości
 * @returns mediana
 * @throws gdy lista jest pusta
 */
export function median(values: number[]): number {
  if (values.length === 0) {
    throw new Error("Nie można obliczyć mediany z pustej listy.");
  }

  const sorted = [...values].sort((a, b) => a - b);
  const mid = Math.floor(sorted.length / 2);

  if (sorted.length % 2 === 1) {
    return sorted[mid]!;
  }

  return (sorted[mid - 1]! + sorted[mid]!) / 2;
}

/**
 * Oblicza odchylenie standardowe.
 *
 * Wzory:
 * - populacja (`population = true`):  σ = √(Σ(xᵢ − μ)² / N)
 * - próba (`population = false`, domyślnie):  s = √(Σ(xᵢ − x̄)² / (n − 1))
 *
 * @param values - lista wartości
 * @param population - true = odchylenie populacyjne; false = próbkowe (domyślnie)
 * @throws gdy lista jest pusta; przy próbie gdy mniej niż 2 elementy
 */
export function standardDeviation(
  values: number[],
  population = false,
): number {
  if (values.length === 0) {
    throw new Error(
      "Nie można obliczyć odchylenia standardowego z pustej listy.",
    );
  }

  if (!population && values.length < 2) {
    throw new Error(
      "Odchylenie standardowe z próby wymaga co najmniej 2 wartości.",
    );
  }

  const mean = simpleAverage(values);
  const squaredDiffs = values.reduce(
    (sum, x) => sum + (x - mean) ** 2,
    0,
  );
  const divisor = population ? values.length : values.length - 1;
  return Math.sqrt(squaredDiffs / divisor);
}

/**
 * Oblicza dominantę (modę) — wartość(i) występujące najczęściej.
 *
 * Gdy kilka wartości ma tę samą maksymalną częstość, zwraca wszystkie (multimodalność),
 * posortowane rosnąco. Gdy wszystkie wartości występują raz, zwraca wszystkie
 * (każda jest „równie modalna”).
 *
 * @param values - lista wartości
 * @returns tablica dominant (może być pusta tylko dla pustego wejścia — wtedy rzuca)
 */
export function mode(values: number[]): number[] {
  if (values.length === 0) {
    throw new Error("Nie można obliczyć dominanty z pustej listy.");
  }

  const counts = new Map<number, number>();
  for (const v of values) {
    counts.set(v, (counts.get(v) ?? 0) + 1);
  }

  let maxCount = 0;
  for (const c of counts.values()) {
    if (c > maxCount) maxCount = c;
  }

  return [...counts.entries()]
    .filter(([, c]) => c === maxCount)
    .map(([v]) => v)
    .sort((a, b) => a - b);
}

/**
 * Sprawdza uprawnienie do świadectwa z wyróżnieniem („czerwony pasek”).
 *
 * Warunki (uproszczone, zgodne z powszechną praktyką szkolną):
 * - średnia ocen ≥ 4,75
 * - ocena z zachowania: „wzorowe” lub „bardzo dobre”
 *
 * Uwaga: szczegółowe zasady mogą wynikać ze statutu szkoły / WSO —
 * ta funkcja implementuje kanoniczny próg produktowy.
 *
 * @param average - średnia ocen (arytmetyczna lub ważona — wg szkoły)
 * @param behaviorGrade - ocena z zachowania (tekst)
 */
export function redStripeEligibility(
  average: number,
  behaviorGrade: string,
): RedStripeResult {
  const normalizedBehavior = behaviorGrade.trim().toLowerCase();
  const behaviorOk = (RED_STRIPE_BEHAVIOR_GRADES as readonly string[]).includes(
    normalizedBehavior,
  );
  const averageOk = average >= RED_STRIPE_AVERAGE_THRESHOLD;

  if (averageOk && behaviorOk) {
    return {
      eligible: true,
      reason: `Uprawnienie spełnione: średnia ${average} ≥ ${RED_STRIPE_AVERAGE_THRESHOLD} oraz zachowanie „${normalizedBehavior}”.`,
    };
  }

  const parts: string[] = [];
  if (!averageOk) {
    parts.push(
      `średnia ${average} jest poniżej progu ${RED_STRIPE_AVERAGE_THRESHOLD}`,
    );
  }
  if (!behaviorOk) {
    parts.push(
      `zachowanie „${behaviorGrade.trim()}” nie należy do: ${RED_STRIPE_BEHAVIOR_GRADES.join(", ")}`,
    );
  }

  return {
    eligible: false,
    reason: `Brak uprawnienia: ${parts.join("; ")}.`,
  };
}

/**
 * Konwertuje ocenę polską ↔ GPA według udokumentowanej tabeli przybliżeń.
 *
 * @param plGrade - wartość wejściowa (PL przy plToGpa, GPA przy gpaToPl)
 * @param direction - kierunek konwersji
 */
export function gpaConvert(plGrade: number, direction: GpaDirection): number {
  if (direction === "plToGpa") {
    return interpolate(plGrade, PL_TO_GPA_ANCHORS);
  }

  // gpaToPl — odwrócone kotwice [gpa, pl]
  const reversed = PL_TO_GPA_ANCHORS.map(
    ([pl, gpa]) => [gpa, pl] as [number, number],
  );
  return interpolate(plGrade, reversed);
}