Liczby, zaokrąglanie i pieniądze

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;
import java.util.List;
import java.util.Locale;

/**
 * Liczby, zaokrąglanie i pieniądze — skryptyJAVA.pl
 * Zapisz jako: LiczbyIPieniadze.java
 */
public final class LiczbyIPieniadze {

    private static final Locale POLSKI = Locale.forLanguageTag("pl-PL");
    private static final BigDecimal STAWKA_VAT = new BigDecimal("0.23");
    private static final BigDecimal RABAT = new BigDecimal("15");

    /** Pozycja koszyka: cena jednostkowa netto i liczba sztuk. */
    public record Pozycja(String nazwa, BigDecimal cenaNetto, int ilosc) {}

    /** Zaokrągla do pełnych groszy „w górę od połowy” — tak liczy większość faktur. */
    public static BigDecimal doGroszy(BigDecimal kwota) {
        return kwota.setScale(2, RoundingMode.HALF_UP);
    }

    /** Wartość pozycji po rabacie, jeszcze bez zaokrąglania — pełna dokładność mnożenia. */
    public static BigDecimal wartoscDokladna(Pozycja pozycja, BigDecimal rabatProcent) {
        BigDecimal mnoznik = BigDecimal.ONE.subtract(rabatProcent.movePointLeft(2));
        return pozycja.cenaNetto().multiply(BigDecimal.valueOf(pozycja.ilosc())).multiply(mnoznik);
    }

    /** Suma zaokrąglonych pozycji — zgadza się z kwotami wydrukowanymi w wierszach. */
    public static BigDecimal sumaPozycjiZaokraglonych(List<Pozycja> koszyk, BigDecimal rabat) {
        BigDecimal suma = BigDecimal.ZERO;
        for (Pozycja pozycja : koszyk) {
            suma = suma.add(doGroszy(wartoscDokladna(pozycja, rabat)));
        }
        return suma;
    }

    /** Suma wartości dokładnych, zaokrąglona dopiero na końcu — bywa o grosz inna. */
    public static BigDecimal sumaZaokraglonaNaKoncu(List<Pozycja> koszyk, BigDecimal rabat) {
        BigDecimal suma = BigDecimal.ZERO;
        for (Pozycja pozycja : koszyk) {
            suma = suma.add(wartoscDokladna(pozycja, rabat));
        }
        return doGroszy(suma);
    }

    /** Ta sama arytmetyka na double — celowo błędna, żeby było co porównać. */
    public static double sumaNaDouble(List<Pozycja> koszyk, double rabatProcent) {
        double suma = 0.0;
        for (Pozycja pozycja : koszyk) {
            double wartosc = pozycja.cenaNetto().doubleValue() * pozycja.ilosc()
                    * (1.0 - rabatProcent / 100.0);
            suma += Math.round(wartosc * 100) / 100.0;
        }
        return suma;
    }

    /** Rabat 0–100% na groszach, z symetrycznym HALF_UP i kontrolą przepełnienia. */
    public static long rabatWGroszach(long groszy, int rabatProcent) {
        if (rabatProcent < 0 || rabatProcent > 100) {
            throw new IllegalArgumentException("Rabat musi mieścić się w zakresie 0–100%.");
        }
        long mnoznik = 100L - rabatProcent;
        long cale = Math.multiplyExact(groszy / 100, mnoznik);
        long reszta = Math.multiplyExact(groszy % 100, mnoznik);
        return Math.addExact(cale, (reszta + Long.signum(reszta) * 50) / 100);
    }

    /** Kwota w polskim formacie, np. 12,34 zł. */
    public static String pln(BigDecimal kwota) {
        return NumberFormat.getCurrencyInstance(POLSKI).format(kwota);
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) {
        System.out.println("— czego double nie potrafi —");
        System.out.println("0.1 + 0.2  = " + (0.1 + 0.2));
        System.out.println("4.35 * 100 = " + (4.35 * 100));

        System.out.println("\n— BigDecimal buduj z tekstu, nigdy z double —");
        System.out.println("new BigDecimal(0.1)   = " + new BigDecimal(0.1));
        System.out.println("new BigDecimal(\"0.1\") = " + new BigDecimal("0.1"));

        BigDecimal dwa = new BigDecimal("2.0");
        BigDecimal dwaZero = new BigDecimal("2.00");
        System.out.println("2.0.equals(2.00)    = " + dwa.equals(dwaZero) + "  (skala się liczy)");
        System.out.println("2.0.compareTo(2.00) = " + dwa.compareTo(dwaZero) + "  (0 znaczy równe)");

        System.out.println("\n— dzielenie —");
        BigDecimal trzy = new BigDecimal("3");
        try {
            System.out.println(BigDecimal.ONE.divide(trzy));
        } catch (ArithmeticException blad) {
            System.out.println("1/3 bez skali rzuca wyjątek: " + blad.getMessage());
        }
        System.out.println("1/3 ze skalą 4: " + BigDecimal.ONE.divide(trzy, 4, RoundingMode.HALF_UP));

        System.out.println("\n— HALF_UP, HALF_EVEN i to, co po cichu wybiera pln() —");
        for (String tekst : List.of("2.345", "2.355", "-2.345")) {
            BigDecimal kwota = new BigDecimal(tekst);
            System.out.printf("%-7s HALF_UP=%-6s HALF_EVEN=%-6s pln=%s%n", tekst,
                    kwota.setScale(2, RoundingMode.HALF_UP),
                    kwota.setScale(2, RoundingMode.HALF_EVEN), pln(kwota));
        }

        System.out.println("\n— koszyk: rabat 15%, VAT 23% —");
        List<Pozycja> koszyk = List.of(
                new Pozycja("Kubek termiczny", new BigDecimal("2.10"), 3),
                new Pozycja("Zeszyt A5", new BigDecimal("4.30"), 1),
                new Pozycja("Długopis", new BigDecimal("1.50"), 7));

        for (Pozycja pozycja : koszyk) {
            BigDecimal dokladna = wartoscDokladna(pozycja, RABAT);
            System.out.printf("%-16s %8s -> %s%n", pozycja.nazwa(), dokladna, pln(doGroszy(dokladna)));
        }

        BigDecimal netto = sumaPozycjiZaokraglonych(koszyk, RABAT);
        System.out.println("Suma zaokrąglonych pozycji: " + pln(netto));
        System.out.println("Zaokrąglona suma dokładna:  " + pln(sumaZaokraglonaNaKoncu(koszyk, RABAT)));
        System.out.println("To samo policzone na double: " + sumaNaDouble(koszyk, 15.0));

        // VAT naliczamy od podstawy, czyli od sumy już zaokrąglonych pozycji.
        BigDecimal podatek = doGroszy(netto.multiply(STAWKA_VAT));
        System.out.println("VAT 23%: " + pln(podatek) + ",  brutto: " + pln(netto.add(podatek)));

        System.out.println("\n— alternatywa: kwoty w groszach jako long —");
        long groszy = rabatWGroszach(1050L, 15);
        System.out.println("1050 gr - 15% = " + groszy + " gr = " + pln(BigDecimal.valueOf(groszy, 2)));
        System.out.println("-1050 gr - 15% = " + rabatWGroszach(-1050L, 15)
                + " gr (symetryczne HALF_UP)");
    }
}