correctly declare thrown exceptions

(public interfaces need their own file, apparently)

Darlehenberechner.java

@@ -1,5 +1,9 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
 import java.math.BigDecimal;
 import java.math.MathContext;
+import java.nio.charset.StandardCharsets;
 import java.text.DecimalFormat;
 import java.text.DecimalFormatSymbols;
 import java.text.ParseException;
@@ -14,8 +18,9 @@ class Darlehenberechner {
       private BigDecimal darlehenswert;
       private BigDecimal zinssatzReal;
       private BigDecimal monatlicheRate;
-      private Integer laufzeitJahre;
-      private Integer aktTilgungsfreieZeit;
+      private Integer laufzeitMonate;
+      private BigDecimal restschuld;
+      private Integer tilgungsfreieZeit;
       private YearMonth anfangsmonat;
       private BigDecimal sondertilgungReal;
 
@@ -53,24 +58,47 @@ class Darlehenberechner {
       }
 
 
-      public Integer getLaufzeitJahre() {
-         return laufzeitJahre;
+      public Integer getLaufzeitMonate() {
+         return laufzeitMonate;
       }
 
 
-      public Konfiguration setLaufzeitJahre(Integer laufzeitJahre) {
-         this.laufzeitJahre = laufzeitJahre;
+      public Konfiguration setLaufzeitMonate(Integer laufzeitMonate) {
+         this.laufzeitMonate = laufzeitMonate;
          return this;
       }
 
 
-      public Integer getaktTilgungsfreieZeit() {
-         return aktTilgungsfreieZeit;
+      public Konfiguration setLaufzeitJahre(Integer jahre) {
+         this.laufzeitMonate = (jahre * 12);
+         return this;
       }
 
 
-      public Konfiguration setaktTilgungsfreieZeit(Integer aktTilgungsfreieZeit) {
-         this.aktTilgungsfreieZeit = aktTilgungsfreieZeit;
+      public Konfiguration setLaufzeit(Integer jahre, Integer monate) {
+         this.laufzeitMonate = (jahre * 12) + monate;
+         return this;
+      }
+
+
+      public BigDecimal getRestschuld() {
+         return restschuld;
+      }
+
+
+      public Konfiguration setRestschuld(BigDecimal restschuld) {
+         this.restschuld = restschuld;
+         return this;
+      }
+
+
+      public Integer getTilgungsfreieZeit() {
+         return tilgungsfreieZeit;
+      }
+
+
+      public Konfiguration setTilgungsfreieZeit(Integer tilgungsfreieZeit) {
+         this.tilgungsfreieZeit = tilgungsfreieZeit;
          return this;
       }
 
@@ -101,7 +129,8 @@ class Darlehenberechner {
    private static final BigDecimal ZWOELF = BigDecimal.valueOf(12);
    private static final BigDecimal EINHUNDERT = BigDecimal.valueOf(100);
 
-   private final Integer laufzeitJahre;
+   private final Integer laufzeitMonate;
+   private final BigDecimal restschuld;
    private final BigDecimal zinssatz;
    private BigDecimal sondertilgung;
    private int summeMonate = 0;
@@ -122,28 +151,74 @@ class Darlehenberechner {
    private BigDecimal summeRaten = BigDecimal.ZERO;
 
 
-   public static void main(String[] args) throws ParseException {
-      new Darlehenberechner(new Konfiguration()
+   public static void main(String[] args) throws ParseException, IOException {
+      /*new Darlehenberechner(new Konfiguration()
          .setDarlehenswert(BigDecimal.valueOf(168_000))
          .setZinssatzProzent(BigDecimal.valueOf(3.73))
          .setMonatlicheRate(BigDecimal.valueOf(1_500))
-         .setaktTilgungsfreieZeit(0)
+         .setTilgungsfreieZeit(0)
          .setAnfangsmonat(YearMonth.of(2024, Month.SEPTEMBER))
          .setSondertilgungProzent(BigDecimal.valueOf(2.5))
-      ).berechneWerte();
-      return;
+      ).berechneWerte();*/
 
       /*new Darlehenberechner(new Konfiguration()
          .setDarlehenswert(BigDecimal.valueOf(168_000))
          .setZinssatzProzent(BigDecimal.valueOf(3.73))
          .setMonatlicheRate(BigDecimal.valueOf(1_500))
-         .setaktTilgungsfreieZeit(0)
+         .setTilgungsfreieZeit(0)
          .setLaufzeitJahre(11)
          .setAnfangsmonat(YearMonth.of(2024, Month.SEPTEMBER))
-      ).berechneWerte();
-      return;*/
+      ).berechneWerte();*/
 
-      /*var konfig = new Konfiguration();
+      if (args.length == 0) {
+         askParametersAndRun();
+      } else {
+         parseParametersAndRun(args);
+      }
+   }
+
+
+   private static void askParametersAndRun() throws ParseException, IOException {
+      DECIMAL_FORMAT.setParseBigDecimal(true);
+
+      var konfig = new Konfiguration();
+      var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
+      System.out.print("Darlehenswert: ");
+      konfig.setDarlehenswert((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
+      System.out.print("Zinssatz: ");
+      konfig.setZinssatzProzent((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
+      System.out.print("Monatliche Rate: ");
+      konfig.setMonatlicheRate((BigDecimal) DECIMAL_FORMAT.parse(br.readLine()));
+      System.out.print("Monat erste Rate(z.B. 2007-12): ");
+      konfig.setAnfangsmonat(YearMonth.parse(br.readLine()));
+      System.out.print("Laufzeit in Jahren(optional Jahre:Monate): ");
+      String in = br.readLine();
+      if (in != null && !in.isBlank()) {
+         String[] split = in.split(":");
+         konfig.setLaufzeit(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
+      } else {
+         System.out.print("Restschuld(optional): ");
+         in = br.readLine();
+         if (in != null && !in.isBlank()) {
+            konfig.setRestschuld((BigDecimal) DECIMAL_FORMAT.parse(in));
+         }
+      }
+      System.out.print("Anzahl tilgungsfreier Monate(optional): ");
+      in = br.readLine();
+      if (in != null && !in.isBlank()) {
+         konfig.setTilgungsfreieZeit(Integer.parseInt(in));
+      }
+      System.out.print("Sondertilgungssatz(optional): ");
+      in = br.readLine();
+      if (in != null && !in.isBlank()) {
+         konfig.setSondertilgungProzent((BigDecimal) DECIMAL_FORMAT.parse(in));
+      }
+      new Darlehenberechner(konfig).berechneWerte();
+   }
+
+
+   private static void parseParametersAndRun(String[] args) throws ParseException {
+      var konfig = new Konfiguration();
       int count = 0;
       DECIMAL_FORMAT.setParseBigDecimal(true);
       while (count < args.length) {
@@ -170,7 +245,7 @@ class Darlehenberechner {
          }
          if (arg.equals("-aktTilgungsfreieZeit")) {
             count++;
-            konfig.setaktTilgungsfreieZeit(Integer.parseInt(args[count]));
+            konfig.setTilgungsfreieZeit(Integer.parseInt(args[count]));
          }
          if (arg.equals("-laufzeitJahre")) {
             count++;
@@ -182,17 +257,21 @@ class Darlehenberechner {
          }
          count++;
       }
-      new Darlehenberechner(konfig).berechneWerte();*/
+      new Darlehenberechner(konfig).berechneWerte();
    }
 
 
    private Darlehenberechner(Konfiguration konfig) {
-      laufzeitJahre = konfig.getLaufzeitJahre();
+      laufzeitMonate = konfig.getLaufzeitMonate();
+      restschuld = konfig.getRestschuld();
       zinssatz = konfig.getZinssatz();
       sondertilgung = konfig.getSondertilgung() != null ? konfig.getSondertilgung().multiply(konfig.getDarlehenswert()) : BigDecimal.ZERO;
       aktRestschuld = konfig.getDarlehenswert();
+      if (restschuld != null) {
+         aktRestschuld = aktRestschuld.subtract(restschuld);
+      }
       aktMonatlicheRate = konfig.getMonatlicheRate();
-      aktTilgungsfreieZeit = konfig.getaktTilgungsfreieZeit();
+      aktTilgungsfreieZeit = konfig.getTilgungsfreieZeit();
       aktMonat = konfig.getAnfangsmonat();
    }
 
@@ -220,7 +299,7 @@ class Darlehenberechner {
 
 
    private boolean laufzeitNichtVorbei() {
-      return (laufzeitJahre == null || summeMonate < (laufzeitJahre * 12)) && aktRestschuld.signum() > 0;
+      return laufzeitMonate != null ? summeMonate < laufzeitMonate : aktRestschuld.signum() > 0;
    }
 
 
@@ -235,19 +314,24 @@ class Darlehenberechner {
 
 
    private void zahleSondertilgung() {
-      if (sondertilgung.signum() == 0) {
+      if (sondertilgung == null || sondertilgung.signum() == 0) {
          return;
       }
       boolean sondertilgungFaellingErstesJahr = summeMonate < 12 && aktMonat.getMonth() == Month.DECEMBER;
       if (sondertilgungFaellingErstesJahr || summeMonate > 1 && aktMonat.getMonth() == Month.JANUARY) {
-         aktRestschuld = aktRestschuld.subtract(sondertilgung);
-         System.out.println(aktMonat + ": " + DECIMAL_FORMAT.format(sondertilgung) + " = 0,00 + " + DECIMAL_FORMAT.format(sondertilgung) + " | " + DECIMAL_FORMAT.format(aktRestschuld));
+         aktRestschuld = aktRestschuld.compareTo(sondertilgung) > 0 ? aktRestschuld.subtract(sondertilgung) : aktRestschuld;
+         System.out.println(aktMonat + ": " + DECIMAL_FORMAT.format(sondertilgung) + " = 0,00 + " + DECIMAL_FORMAT.format(sondertilgung) + " | " + DECIMAL_FORMAT.format(getRealeRestschuld()));
       }
    }
 
 
+   private BigDecimal getRealeRestschuld() {
+      return restschuld != null ? aktRestschuld.add(restschuld) : aktRestschuld;
+   }
+
+
    private void berechneBeitragAufteilung() {
-      aktZinsbetrag = aktRestschuld.multiply(zinssatz)
+      aktZinsbetrag = getRealeRestschuld().multiply(zinssatz)
          .divide(ZWOELF, MathContext.DECIMAL128);
       if (aktMonatlicheRate.compareTo(aktRestschuld) > 0) {
          aktMonatlicheRate = aktRestschuld.add(aktZinsbetrag); // die letzte Rate ist gleich der Restschuld + Zinsen
@@ -263,7 +347,7 @@ class Darlehenberechner {
 
    private void druckeAktuelleMonatswerte() {
       System.out.println(aktMonat + ": " + DECIMAL_FORMAT.format(aktMonatlicheRate) + " = " + DECIMAL_FORMAT.format(aktZinsbetrag)
-            + " + " + DECIMAL_FORMAT.format(aktTilgungsbetrag) + " | " + DECIMAL_FORMAT.format(aktRestschuld));
+            + " + " + DECIMAL_FORMAT.format(aktTilgungsbetrag) + " | " + DECIMAL_FORMAT.format(getRealeRestschuld()));
    }
 
 
@@ -282,34 +366,32 @@ class Darlehenberechner {
 
    private void druckeJahressumeBedingt() {
       boolean kreditjahrVergangen = summeMonate > 1 && summeMonate % 12 == 0 || laufzeitVorbei();
-      if (kreditjahrVergangen || aktMonat.getMonth() == Month.DECEMBER) {
-         BigDecimal jahressummeZinsen;
-         BigDecimal jahressummeTilgung;
-         BigDecimal jahressummeRaten;
-         String desc;
+      boolean kalenderjahrVergangen = aktMonat.getMonth() == Month.DECEMBER;
+      if (kreditjahrVergangen || kalenderjahrVergangen) {
          if (kreditjahrVergangen) {
-            jahressummeZinsen = jahressummeZinsenKreditjahr;
-            jahressummeTilgung = jahressummeTilgungKreditjahr;
-            jahressummeRaten = jahressummeRatenKreditjahr;
+            String desc = "Kreditjahr " + (summeMonate + 11) / 12; // + 11 weil integerdivision und X Jahre plus 1 Monat soll X + 1 tes Kreditjahr ergeben
+            druckeJahressumme(desc, jahressummeRatenKreditjahr, jahressummeZinsenKreditjahr, jahressummeTilgungKreditjahr);
+            jahressummeRatenKreditjahr = BigDecimal.ZERO;
             jahressummeZinsenKreditjahr = BigDecimal.ZERO;
             jahressummeTilgungKreditjahr = BigDecimal.ZERO;
-            jahressummeRatenKreditjahr = BigDecimal.ZERO;
-            desc = "Kreditjahr " + summeMonate / 12;
-         } else {
-            jahressummeZinsen = jahressummeZinsenKalenderjahr;
-            jahressummeTilgung = jahressummeTilgungKalenderjahr;
-            jahressummeRaten = jahressummeRatenKalenderjahr;
+         }
+         if (kalenderjahrVergangen) {
+            String desc = "Kalenderjahr " + aktMonat.getYear();
+            druckeJahressumme(desc, jahressummeRatenKalenderjahr, jahressummeZinsenKalenderjahr, jahressummeTilgungKalenderjahr);
             jahressummeZinsenKalenderjahr = BigDecimal.ZERO;
             jahressummeTilgungKalenderjahr = BigDecimal.ZERO;
             jahressummeRatenKalenderjahr = BigDecimal.ZERO;
-            desc = "Kalenderjahr " + aktMonat.getYear();
          }
-         System.out.println("Summe " + desc + ":\n" + DECIMAL_FORMAT.format(jahressummeRaten) + " = " + DECIMAL_FORMAT.format(jahressummeZinsen)
-            + " + " + DECIMAL_FORMAT.format(jahressummeTilgung));
       }
    }
 
 
+   private void druckeJahressumme(String desc, BigDecimal jahressummeRaten, BigDecimal jahressummeZinsen, BigDecimal jahressummeTilgung) {
+      System.out.println("Summe " + desc + ":\n" + DECIMAL_FORMAT.format(jahressummeRaten) + " = " + DECIMAL_FORMAT.format(jahressummeZinsen)
+            + " + " + DECIMAL_FORMAT.format(jahressummeTilgung));
+   }
+
+
    private void aktualisiereZeitwerte() {
       aktMonat = aktMonat.plusMonths(1);
       if (aktTilgungsfreieZeit != null) {
@@ -325,9 +407,9 @@ class Darlehenberechner {
 
 
    private void druckeLaufzeitUndRestschuld() {
-      int laufzeitJahreFinal = laufzeitJahre == null ? summeMonate / 12 : laufzeitJahre;
-      int teillaufzeitMonateFinal = summeMonate - (laufzeitJahreFinal * 12);
+      int laufzeitJahreFinal = summeMonate / 12;
+      int teillaufzeitMonateFinal = summeMonate % 12;
       System.out.println("Laufzeit: " + laufzeitJahreFinal + " Jahre " + teillaufzeitMonateFinal + " Monate");
-      System.out.println("Restschuld: " + DECIMAL_FORMAT.format(aktRestschuld));
+      System.out.println("Restschuld: " + DECIMAL_FORMAT.format(getRealeRestschuld()));
    }
 }

DrinkingBar.java

@@ -0,0 +1,132 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.math.RoundingMode;
+import java.nio.charset.StandardCharsets;
+import java.text.DecimalFormat;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.util.concurrent.TimeUnit;
+
+public class DrinkingBar {
+
+   private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm");
+   private static final int MINS_PER_HOUR = 60;
+   private static final int MINS_PER_HALF_HOUR = MINS_PER_HOUR / 2;
+   private static final int MINUTES_BEFORE_PAUSE = 4 * MINS_PER_HOUR + MINS_PER_HALF_HOUR;
+   private static final int MINUTES_WITH_PAUSE = 6 * MINS_PER_HOUR;
+   private static final int DEFAULT_TOTAL_TIME = 8 * MINS_PER_HOUR + MINS_PER_HALF_HOUR;
+   private static final DecimalFormat LITER_FORMAT = new DecimalFormat("0.00");
+   private static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
+   private static final BigDecimal MINS_PER_HOUR_BD = BigDecimal.valueOf(MINS_PER_HOUR);
+   private static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
+
+   private final LocalTime startTime;
+   private LocalTime endTime;
+   private long totalMinutes;
+   private BigDecimal totalMinutesBD;
+
+
+   private DrinkingBar(LocalTime startTime) {
+      this.startTime = startTime;
+      this.totalMinutes = DEFAULT_TOTAL_TIME;
+      this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
+      this.endTime = startTime.plusMinutes(totalMinutes);
+   }
+
+
+   public static void main(String[] args) throws IOException {
+      var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
+      print("Ankunftszeit: ");
+      var startTime = LocalTime.parse(br.readLine(), TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      var db = new DrinkingBar(startTime);
+      db.showLoadingBar();
+   }
+
+
+   private static void println(Object o) {
+      System.out.println(o);
+   }
+
+
+   private static void print(Object o) {
+      System.out.print(o);
+   }
+
+
+   private void setEndTime(LocalTime endTime) {
+      this.endTime = endTime;
+      this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
+      this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
+   }
+
+
+   private void showLoadingBar() {
+      long passedMinutes = startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
+      // long passedMinutes = 0; // DEBUG
+      if (passedMinutes > totalMinutes) {
+         passedMinutes = totalMinutes;
+      } else if (passedMinutes < 0) {
+         var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
+         println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
+      }
+      println(minutesToTimeString(totalMinutesBD) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime));
+      while (passedMinutes < totalMinutes) {
+         print(fillLoadingBar(passedMinutes, true));
+         waitUntilNextMinute();
+         passedMinutes++;
+      }
+      println(fillLoadingBar(passedMinutes, false));
+   }
+
+
+   private String fillLoadingBar(long passedMinutes, boolean progressive) {
+      long effectivePassedMinutes = passedMinutes;
+      if (passedMinutes > MINUTES_BEFORE_PAUSE && passedMinutes <= MINUTES_WITH_PAUSE) {
+         effectivePassedMinutes = MINUTES_BEFORE_PAUSE;
+      }
+      double currentLitres = 2.0 / totalMinutes * effectivePassedMinutes + 0.25;
+      double printedLitres = currentLitres - (currentLitres % 0.25);
+      // double currentProgressToNextStep = 100 / 0.25 * (currentLitres - printedLitres);
+      BigDecimal minutesToNextStep = getMinutesToNextStep(currentLitres);
+      String progressivePart = progressive ? "\r" : "";
+      return progressivePart + "Aktuelles Volumen: " + LITER_FORMAT.format(printedLitres) + "L - "
+         // + PERCENTAGE_FORMAT.format(currentProgressToNextStep) + "% - "
+         + minutesToTimeString(minutesToNextStep);
+   }
+
+
+   private BigDecimal getMinutesToNextStep(double currentLitres) {
+      // berechne Liter benötigt bis zum nächsten 0.25er Schritt
+      double litresToNextStep = 0.25 - (currentLitres % 0.25);
+      // berechne Minuten benötigt für 1 Liter
+      double minutesPerLitre = totalMinutes / 2.0;
+      // berechne Minuten benötigt bis zum nächsten 0.25er Schritt
+      return BigDecimal.valueOf((minutesPerLitre * litresToNextStep) + 1);
+   }
+
+
+   private String minutesToTimeString(BigDecimal minutes) {
+      BigDecimal[] hoursAndMinutes = minutes.divideAndRemainder(MINS_PER_HOUR_BD, MC_INTEGER);
+      return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
+   }
+
+
+   private void waitUntilNextMinute() {
+      try {
+         var now = LocalTime.now();
+         var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
+         /* We wait whole seconds to not make it overly complicated.
+            That results in cut milliseconds: if we would have to wait 1 second and 526 milliseconds, we wait only 1 second.
+            So, adjust for ignored milliseconds, add +1 second as it is better to switch between 00 and 01 as between 59 and 00 */
+         TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
+         // TimeUnit.MILLISECONDS.sleep(100L); // DEBUG
+      } catch (InterruptedException ie) {
+         Thread.currentThread().interrupt();
+         throw new RuntimeException(ie);
+      }
+   }
+}

Java11.java

@@ -12,6 +12,8 @@ import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 class Java11 {
+
+
    public static void main(String[] args) {
       ////////
       // 1. //
@@ -159,4 +161,4 @@ interface InterfaceWithPrivateMethods {
 @Documented
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.PARAMETER)
-public @interface Nonnull {}
+@interface Nonnull {}

LoadingBar.java

@@ -1,14 +1,18 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
 import java.math.BigDecimal;
 import java.math.MathContext;
 import java.math.RoundingMode;
+import java.nio.charset.StandardCharsets;
 import java.text.DecimalFormat;
-import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
+import java.time.LocalTime;
 import java.time.temporal.ChronoUnit;
 import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
 import java.util.List;
 import java.util.Objects;
-import java.util.concurrent.TimeUnit;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -23,11 +27,13 @@ public class LoadingBar {
    private static final int MIN_LUNCH_DURATION = 30;
    private static final LocalTime LATEST_LUNCH_TIME = LocalTime.of(13, 30);
    private static final int MINS_PER_HOUR = 60;
+   private static final BigDecimal MINS_PER_HOUR_BD = BigDecimal.valueOf(MINS_PER_HOUR);
    private static final long DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH = 5L * MINS_PER_HOUR;
    private static final int MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH = 6 * MINS_PER_HOUR;
    private static final long MAX_NUMBER_WORK_MINS = 8L * MINS_PER_HOUR;
    private static final int LINE_LENGTH = 100;
    private static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
+   private static final BigDecimal ONE_HUNDRED_PERCENT = BigDecimal.valueOf(100);
 
 
    private enum DaySection {
@@ -60,83 +66,189 @@ public class LoadingBar {
    }
 
 
-   public static void main(String[] args) {
-      if (args.length > 0 && Objects.equals(args[0], "--help")) {
-         printHelp();
+   private final LocalTime startTime;
+   private LocalTime endTime;
+   private long totalMinutes;
+   private BigDecimal totalMinutesBD;
+
+
+   private LoadingBar(LocalTime startTime) {
+      this.startTime = startTime;
+   }
+
+
+   private void setEndTime(LocalTime endTime) {
+      this.endTime = endTime;
+      this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
+      this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
+   }
+
+
+   public static void main(String[] args) throws IOException {
+      if (args.length == 0) {
+         askParametersAndRun();
+      } else {
+         parseParametersAndRun(args);
+      }
+   }
+
+
+   private static void askParametersAndRun() throws IOException {
+      var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
+      print("Ankunftszeit: ");
+      var startTime = LocalTime.parse(br.readLine(), TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      var lb = new LoadingBar(startTime);
+      if (lb.hasMittagspauseArrived()) {
+         handleMittagspause(br, lb);
+         lb.showLoadingBar();
+      }
+      handleZapfenstreich(br, lb);
+      lb.showLoadingBar();
+   }
+
+
+   private static void println(Object o) {
+      System.out.println(o);
+   }
+
+
+   private static void print(Object o) {
+      System.out.print(o);
+   }
+
+
+   private static void handleMittagspause(BufferedReader br, LoadingBar lb) throws IOException {
+      print("Mittagspause verschieben um (optional): ");
+      String mittagspauseOffsetRaw = br.readLine();
+      if (mittagspauseOffsetRaw != null && !mittagspauseOffsetRaw.isBlank()) {
+         var mittagspauseOffset = Integer.parseInt(mittagspauseOffsetRaw);
+         lb.initMittagspause(mittagspauseOffset);
          return;
       }
-      verifyMinimumNumberOfArgs(args);
+      print("Mittagspause um (optional): ");
+      String manualMittagspauseRaw = br.readLine();
+      if (manualMittagspauseRaw != null && !manualMittagspauseRaw.isBlank()) {
+         var manualMittagspause = LocalTime.parse(manualMittagspauseRaw, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+         lb.initMittagspause(manualMittagspause);
+      } else {
+         lb.initMittagspause();
+      }
+   }
+
+
+   private static void handleZapfenstreich(BufferedReader br, LoadingBar lb) throws IOException {
+      print("Mittagspause hat gedauert (optional): ");
+      String mittagspauseDurationRaw = br.readLine();
+      Integer mittagspauseDuration = null;
+      if (mittagspauseDurationRaw != null && !mittagspauseDurationRaw.isBlank()) {
+         mittagspauseDuration = Integer.valueOf(mittagspauseDurationRaw);
+      }
+      LocalTime vorlaeufigeEndzeit = lb.startTime.plusMinutes(MAX_NUMBER_WORK_MINS)
+         .plusMinutes(mittagspauseDuration != null ? mittagspauseDuration : MIN_LUNCH_DURATION);
+      println("Endzeit: " + TIME_FORMATTER.format(vorlaeufigeEndzeit));
+      print("Feierabend verschieben um (optional): ");
+      String zapfenstreichOffsetRaw = br.readLine();
+      Integer zapfenstreichOffset = null;
+      if (zapfenstreichOffsetRaw != null && !zapfenstreichOffsetRaw.isBlank()) {
+         zapfenstreichOffset = Integer.valueOf(zapfenstreichOffsetRaw);
+         lb.initZapfenstreich(mittagspauseDuration, zapfenstreichOffset);
+         return;
+      }
+      print("Manuelle Uhrzeit Feierabend (optional): ");
+      String manualZapfenstreichRaw = br.readLine();
+      LocalTime manualZapfenstreich = null;
+      if (manualZapfenstreichRaw != null && !manualZapfenstreichRaw.isBlank()) {
+         manualZapfenstreich = LocalTime.parse(manualZapfenstreichRaw, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+         lb.initZapfenstreich(mittagspauseDuration, manualZapfenstreich);
+      } else {
+         lb.initZapfenstreich(mittagspauseDuration);
+      }
+   }
+
+
+   private static void parseParametersAndRun(String[] args) {
+      LoadingBar lb = getLoadingBarFromCLI(args);
+      lb.showLoadingBar();
+   }
+
+
+   private static LoadingBar getLoadingBarFromCLI(String[] args) {
       String nextArg = args[0];
+      if ("--help".equals(nextArg)) {
+         printHelp();
+         System.exit(1);
+      }
+      verifyMinimumNumberOfArgs(args);
       verifyTimeFormat(nextArg, "Erstes Argument");
-      var startTime = LocalTime.parse(nextArg, TIME_FORMATTER);
+      var startTime = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
       nextArg = args[1];
       var section = DaySection.byParam(nextArg);
       verifyDaySection(section, nextArg);
-      if (section == DaySection.MITTAG) {
-         handleMittagspause(args, startTime);
-      } else {
-         handleZapfenstreich(args, startTime);
-      }
+      return section == DaySection.MITTAG ? getLoadingBarMittagspause(args, startTime) : getLoadingBarZapfenstreich(args, startTime);
    }
 
 
-   private static void handleMittagspause(String[] args, LocalTime startTime) {
+   private static LoadingBar getLoadingBarMittagspause(String[] args, LocalTime startTime) {
+      var lb = new LoadingBar(startTime);
       if (args.length == 2) {
-         showLoadingBarMittagspause(startTime);
-         return;
+         lb.initMittagspause();
+         return lb;
       }
       String nextArg = args[2];
       if (OFFSET_PATTERN.matcher(nextArg).matches()) {
-         showLoadingBarMittagspause(startTime, Integer.parseInt(nextArg));
-         return;
+         lb.initMittagspause(Integer.parseInt(nextArg));
+         return lb;
       }
       verifyTimeFormat(nextArg, "Argument nach " + DaySection.MITTAG.getParam());
-      var maxMittagspause = LocalTime.parse(nextArg, TIME_FORMATTER);
-      showLoadingBarMittagspause(startTime, maxMittagspause);
+      var manualMittagspause = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      lb.initMittagspause(manualMittagspause);
+      return lb;
    }
 
 
-   private static void handleZapfenstreich(String[] args, LocalTime startTime) {
-      Integer lunchDuration = null;
+   private static LoadingBar getLoadingBarZapfenstreich(String[] args, LocalTime startTime) {
+      var lb = new LoadingBar(startTime);
       if (args.length == 2) {
-         showLoadingBarZapfenstreich(startTime);
-         return;
+         lb.initZapfenstreich();
+         return lb;
       }
       String nextArg = args[2];
       LocalTime maxZapfenstreich = null;
       int endTimeOffset = 0;
+      Integer lunchDuration = null;
       if (TIME_PATTERN.matcher(nextArg).matches()) {
-         maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER);
+         maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
       } else if (OFFSET_PATTERN.matcher(nextArg).matches()) {
          endTimeOffset = Integer.parseInt(nextArg);
       } else {
-         verifyDurationFormat(nextArg, "Argument nach " + DaySection.ZAPFENSTREICH.getParam(), true); // FSFIXME erweitere Fehlermeldung
+         verifyDurationFormat(nextArg, "Argument nach " + DaySection.ZAPFENSTREICH.getParam());
          lunchDuration = Integer.parseInt(nextArg);
       }
       if (args.length == 3) {
          if (maxZapfenstreich == null && endTimeOffset == 0) {
-            showLoadingBarZapfenstreich(startTime, lunchDuration);
+            lb.initZapfenstreich(lunchDuration);
          } else if (maxZapfenstreich == null) {
-            showLoadingBarZapfenstreich(startTime, lunchDuration, endTimeOffset);
+            lb.initZapfenstreich(lunchDuration, endTimeOffset);
          } else {
-            showLoadingBarZapfenstreich(startTime, lunchDuration, maxZapfenstreich);
+            lb.initZapfenstreich(lunchDuration, maxZapfenstreich);
          }
-         return;
+         return lb;
       }
       nextArg = args[3];
       if (lunchDuration == null) {
-         System.out.println("Letztes Argument darf nur auf Mittagspausendauer folgen.");
+         println("Letztes Argument darf nur auf Mittagspausendauer folgen.");
          System.exit(1);
       }
       if (maxZapfenstreich == null && !OFFSET_PATTERN.matcher(nextArg).matches()) {
          verifyTimeFormat(nextArg, "Letztes Argument nach " + DaySection.ZAPFENSTREICH.getParam() + " und Mittagspausendauer");
-         maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER);
-         showLoadingBarZapfenstreich(startTime, lunchDuration, maxZapfenstreich);
-         return;
+         maxZapfenstreich = LocalTime.parse(nextArg, TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+         lb.initZapfenstreich(lunchDuration, maxZapfenstreich);
+         return lb;
       }
       verifyOffsetFormat(nextArg, "Letztes Argument nach " + DaySection.ZAPFENSTREICH.getParam() + " und Enduhrzeit");
       endTimeOffset = Integer.parseInt(nextArg);
-      showLoadingBarZapfenstreich(startTime, lunchDuration, endTimeOffset);
+      lb.initZapfenstreich(lunchDuration, endTimeOffset);
+      return lb;
    }
 
 
@@ -144,34 +256,33 @@ public class LoadingBar {
       if (args.length >= 2) {
          return;
       }
-      System.out.println("Mindestens 2 Argumente müssen gegeben sein.");
+      println("Mindestens 2 Argumente müssen gegeben sein.");
       printHelp();
       System.exit(1);
    }
 
 
    private static void verifyTimeFormat(String param, String errMsgPrefix) {
-      verifyInputFormat(TIME_PATTERN, param, errMsgPrefix, true, false);
+      verifyInputFormat(TIME_PATTERN, param, errMsgPrefix, "Uhrzeitformat (" + TIME_FORMAT + ")", false);
    }
 
 
-   private static void verifyDurationFormat(String param, String errMsgPrefix, boolean timeInputPossible) {
-      verifyInputFormat(LUNCH_DURATION_PATTERN, param, errMsgPrefix, false, timeInputPossible);
+   private static void verifyDurationFormat(String param, String errMsgPrefix) {
+      verifyInputFormat(LUNCH_DURATION_PATTERN, param, errMsgPrefix, "Minutenanzahl (ganze Zahl)", true);
    }
 
 
    private static void verifyOffsetFormat(String param, String errMsgPrefix) {
-      verifyInputFormat(OFFSET_PATTERN, param, errMsgPrefix, false, false);
+      verifyInputFormat(OFFSET_PATTERN, param, errMsgPrefix, "Minutendifferenz (ganze Zahl mit Vorzeichen)", false);
    }
 
 
-   private static void verifyInputFormat(Pattern pattern, String param, String errMsgPrefix, boolean timeInput, boolean timeInputPossible) {
+   private static void verifyInputFormat(Pattern pattern, String param, String errMsgPrefix, String firstInputPart, boolean timeInputPossible) {
       if (pattern.matcher(param).matches()) {
          return;
-      } // FSFIXME fine tune message -> HH:mm, mm, -+mm
-      var firstInputPart = timeInput ? "Uhrzeitformat (" + TIME_FORMAT + ")" : "Minutenanzahl (" + LUNCH_DURATION_PATTERN + ")";
-      var possibleTimeInputPart = !timeInput && timeInputPossible ? " oder Uhrzeitformat (" + TIME_FORMAT + ")" : "";
-      System.out.println(errMsgPrefix + " \"" + param + "\" muss " + firstInputPart + possibleTimeInputPart + " entsprechen.");
+      }
+      var possibleTimeInputPart = timeInputPossible ? " oder Uhrzeitformat (" + TIME_FORMAT + ")" : "";
+      println(errMsgPrefix + " \"" + param + "\" muss " + firstInputPart + possibleTimeInputPart + " entsprechen.");
       System.exit(1);
    }
 
@@ -183,13 +294,13 @@ public class LoadingBar {
       List<String> sectionDescs = Arrays.stream(DaySection.values()).map((DaySection ds) -> ds.getDescription() + " (" + ds.getParam() + ")")
           .collect(Collectors.toList());
       String sectionDescsJoined = String.join(" oder ", sectionDescs);
-      System.out.println("Argument nach Startzeit \"" + param + "\" muss Angabe für " + sectionDescsJoined + " sein.");
+      println("Argument nach Startzeit \"" + param + "\" muss Angabe für " + sectionDescsJoined + " sein.");
       System.exit(1);
    }
 
 
    private static void printHelp() {
-      System.out.println("Mögliche Argumente für LoadingBar:\n"
+      println("Mögliche Argumente für LoadingBar:\n"
           + "Normalfall Vormittag (Mittagspause <= " + LATEST_LUNCH_TIME + ")\n"
           + TIME_FORMAT + " " + DaySection.MITTAG.getParam() + "\n"
           + "Vormittag mit expliziter Mittagspause (<= " + LATEST_LUNCH_TIME + ")\n"
@@ -219,55 +330,65 @@ public class LoadingBar {
    }
 
 
-   private static void showLoadingBarMittagspause(LocalTime startTime) {
-      showLoadingBarMittagspause(startTime, null);
+   private boolean hasMittagspauseArrived() {
+      return startTime.until(LocalTime.now(), ChronoUnit.MINUTES) < DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH;
    }
 
 
-   private static void showLoadingBarMittagspause(LocalTime startTime, int endTimeOffset) {
-      LocalTime endTime = startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH + endTimeOffset);
-      LocalTime trueEndTime = endTime.isAfter(LATEST_LUNCH_TIME) ? LATEST_LUNCH_TIME : endTime;
-      showLoadingBar(startTime, trueEndTime);
+   private void initMittagspause() {
+      LocalTime defaultEndTime = startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
+      realInitMittagspause(defaultEndTime);
    }
 
 
-   private static void showLoadingBarMittagspause(LocalTime startTime, LocalTime manualEndTime) {
-      LocalTime endTime = manualEndTime != null ? manualEndTime : startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
-      LocalTime trueEndTime = endTime.isAfter(LATEST_LUNCH_TIME) ? LATEST_LUNCH_TIME : endTime;
-      showLoadingBar(startTime, trueEndTime);
+   private void initMittagspause(int endTimeOffset) {
+      LocalTime offsetEndTime = startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH + endTimeOffset);
+      realInitMittagspause(offsetEndTime);
    }
 
 
-   private static void showLoadingBarZapfenstreich(LocalTime startTime) {
-      showLoadingBarZapfenstreich(startTime, -1, 0);
+   private void initMittagspause(LocalTime manualEndTime) {
+      LocalTime effectiveEndTime = manualEndTime != null ? manualEndTime : startTime.plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
+      realInitMittagspause(effectiveEndTime);
    }
 
 
-   private static void showLoadingBarZapfenstreich(LocalTime startTime, Integer manualLunchDuration) {
-      showLoadingBarZapfenstreich(startTime, manualLunchDuration, 0);
+   private void realInitMittagspause(LocalTime theoreticalEndTime) {
+      setEndTime(theoreticalEndTime.isAfter(LATEST_LUNCH_TIME) ? LATEST_LUNCH_TIME : theoreticalEndTime);
    }
 
 
-   private static void showLoadingBarZapfenstreich(LocalTime startTime, Integer manualLunchDuration, int endTimeOffset) {
+   private void initZapfenstreich() {
+      LocalTime trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + MIN_LUNCH_DURATION);
+      realInitZapfenstreich(MIN_LUNCH_DURATION, trueEndTime);
+   }
+
+
+   private void initZapfenstreich(Integer manualLunchDuration) {
+      initZapfenstreich(manualLunchDuration, 0);
+   }
+
+
+   private void initZapfenstreich(Integer manualLunchDuration, int endTimeOffset) {
       long minLunchDuration = getMinLunchDuration(endTimeOffset);
       long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
       LocalTime trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration + endTimeOffset);
-      realShowLoadingBarZapfenstreich(startTime, realLunchDuration, trueEndTime);
+      realInitZapfenstreich(realLunchDuration, trueEndTime);
    }
 
 
-   private static void showLoadingBarZapfenstreich(LocalTime startTime, Integer manualLunchDuration, LocalTime manualEndTime) {
+   private void initZapfenstreich(Integer manualLunchDuration, LocalTime manualEndTime) {
       LocalTime trueEndTime = manualEndTime;
-      long minLunchDuration = getMinLunchDuration(startTime, trueEndTime);
+      long minLunchDuration = getMinLunchDuration(trueEndTime);
       long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
       if (trueEndTime == null) {
          trueEndTime = startTime.plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration);
       }
-      realShowLoadingBarZapfenstreich(startTime, realLunchDuration, trueEndTime);
+      realInitZapfenstreich(realLunchDuration, trueEndTime);
    }
 
 
-   private static long getMinLunchDuration(int endTimeOffset) {
+   private long getMinLunchDuration(int endTimeOffset) {
       if (endTimeOffset == 0) {
          return MIN_LUNCH_DURATION;
       }
@@ -277,17 +398,17 @@ public class LoadingBar {
    }
 
 
-   private static long getMinLunchDuration(LocalTime startTime, LocalTime endTime) {
-      if (endTime == null) {
+   private long getMinLunchDuration(LocalTime manualEndTime) {
+      if (manualEndTime == null) {
          return MIN_LUNCH_DURATION;
       }
-      long totalDuration = startTime.until(endTime, ChronoUnit.MINUTES);
-      int effectiveLunchDuration = ((int) totalDuration) - MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH;
+      long totalDuration = startTime.until(manualEndTime, ChronoUnit.MINUTES);
+      long effectiveLunchDuration = totalDuration - MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH;
       return getMinLunchDuration(effectiveLunchDuration);
    }
 
 
-   private static long getMinLunchDuration(long effectiveLunchDuration) {
+   private long getMinLunchDuration(long effectiveLunchDuration) {
       if (effectiveLunchDuration < 0) {
          effectiveLunchDuration = 0;
       }
@@ -295,52 +416,61 @@ public class LoadingBar {
    }
 
 
-   private static long getRealLunchDuration(Integer manualLunchDuration, long minLunchDuration) {
+   private long getRealLunchDuration(Integer manualLunchDuration, long minLunchDuration) {
       return manualLunchDuration != null && manualLunchDuration >= minLunchDuration ? manualLunchDuration : minLunchDuration;
    }
 
 
-   private static void realShowLoadingBarZapfenstreich(LocalTime startTime, long manualLunchDuration, LocalTime endTime) {
-      if (manualLunchDuration > 0) {
-         var totalWorkTime = LocalTime.MIDNIGHT.plusMinutes(startTime.until(endTime, ChronoUnit.MINUTES) - manualLunchDuration);
-         System.out.print("Arbeitszeit: " + TIME_FORMATTER.format(totalWorkTime) + "; ");
+   private void realInitZapfenstreich(long effectiveLunchDuration, LocalTime effectiveEndTime) {
+      if (effectiveLunchDuration > 0) {
+         var totalWorkTime = LocalTime.MIDNIGHT.plusMinutes(startTime.until(effectiveEndTime, ChronoUnit.MINUTES) - effectiveLunchDuration);
+         print("Arbeitszeit: " + TIME_FORMATTER.format(totalWorkTime) + "; ");
       }
-      showLoadingBar(startTime, endTime);
+      setEndTime(effectiveEndTime);
    }
 
 
-   private static void showLoadingBar(LocalTime startTime, LocalTime endTime) {
-      long initialMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
-      System.out.print(minutesToTimeString(initialMinutes) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime) + "\n");
-      long passedMinutes = startTime.until(LocalTime.now(), ChronoUnit.MINUTES);
-      if (passedMinutes > initialMinutes) {
-         passedMinutes = initialMinutes;
+   private void showLoadingBar() {
+      long passedMinutes = startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
+      // long passedMinutes = 0; // DEBUG
+      if (passedMinutes > totalMinutes) {
+         passedMinutes = totalMinutes;
       } else if (passedMinutes < 0) {
-         System.out.println(fillLoadingBar(initialMinutes, 0, false));
-         return;
+         var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
+         println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
       }
-      while (passedMinutes < initialMinutes) {
-         System.out.print(fillLoadingBar(initialMinutes, passedMinutes, true));
-         try {
-            var now = LocalTime.now();
-            var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
-            // +1 second to adjust for ignored milliseconds as it is better to switch between 00 and 01 as between 59 and 00
-            TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
-            // TimeUnit.SECONDS.sleep(1L); // DEBUG
-         } catch (InterruptedException ie) {
-            throw new RuntimeException(ie);
-         }
+      println(minutesToTimeString(totalMinutesBD) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime));
+      while (passedMinutes < totalMinutes) {
+         print(fillLoadingBar(passedMinutes, true));
+         waitUntilNextMinute();
          passedMinutes++;
       }
-      System.out.println(fillLoadingBar(initialMinutes, passedMinutes, false));
+      println(fillLoadingBar(passedMinutes, false));
    }
 
 
-   private static String fillLoadingBar(long initialMinutes, long passedMinutes, boolean progressive) {
-      BigDecimal wholePercentage = BigDecimal.valueOf(100)
-         .multiply(BigDecimal.valueOf(passedMinutes) // kind of reverse dreisatz to avoid to have e.g. 99.9999 instead of 100 %
-         .divide(BigDecimal.valueOf(initialMinutes), MathContext.DECIMAL64));
-      long remainingMinutes = initialMinutes - passedMinutes;
+   private void waitUntilNextMinute() {
+      try {
+         var now = LocalTime.now();
+         var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
+         /* We wait whole seconds to not make it overly complicated.
+            That results in cut milliseconds: if we would have to wait 1 second and 526 milliseconds, we wait only 1 second.
+            So, adjust for ignored milliseconds, add +1 second as it is better to switch between 00 and 01 as between 59 and 00 */
+         TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
+         // TimeUnit.MILLISECONDS.sleep(100L); // DEBUG
+      } catch (InterruptedException ie) {
+         Thread.currentThread().interrupt();
+         throw new RuntimeException(ie);
+      }
+   }
+
+
+   private String fillLoadingBar(long passedMinutes, boolean progressive) {
+      var nonNegativePassedMinutes = BigDecimal.valueOf(passedMinutes < 0 ? 0 : passedMinutes);
+      BigDecimal wholePercentage = ONE_HUNDRED_PERCENT
+         // kind of reverse dreisatz to avoid having e.g. 99.9999 instead of 100 %
+         .multiply(nonNegativePassedMinutes)
+         .divide(totalMinutesBD, MathContext.DECIMAL64);
       int numberOfEquals = wholePercentage.intValue();
       var sb = new StringBuilder("[");
       for (int i = 0; i < LINE_LENGTH; i++) {
@@ -350,8 +480,9 @@ public class LoadingBar {
             sb.append("-");
          }
       }
+      BigDecimal remainingMinutes = totalMinutesBD.subtract(nonNegativePassedMinutes);
       sb.append("] ").append(PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
-          .append(minutesToTimeString(passedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
+          .append(minutesToTimeString(nonNegativePassedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
       if (progressive) {
          sb.append("\r");
       }
@@ -359,9 +490,8 @@ public class LoadingBar {
    }
 
 
-   private static String minutesToTimeString(long minutes) {
-      var minutesBD = BigDecimal.valueOf(minutes);
-      BigDecimal[] hoursAndMinutes = minutesBD.divideAndRemainder(BigDecimal.valueOf(MINS_PER_HOUR), MC_INTEGER);
+   private String minutesToTimeString(BigDecimal minutes) {
+      BigDecimal[] hoursAndMinutes = minutes.divideAndRemainder(MINS_PER_HOUR_BD, MC_INTEGER);
       return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
    }
 }

SimpleLoadingBar.java

@@ -16,8 +16,23 @@ public class SimpleLoadingBar {
    private static final Pattern TIME_PATTERN = Pattern.compile("(?>[01]\\d|2[0-4]):[0-5]\\d");
    private static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
    private static final int MINS_PER_HOUR = 60;
+   private static final BigDecimal MINS_PER_HOUR_BD = BigDecimal.valueOf(MINS_PER_HOUR);
    private static final int LINE_LENGTH = 100;
    private static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
+   private static final BigDecimal ONE_HUNDRED_PERCENT = BigDecimal.valueOf(100);
+
+   private final String title;
+   private final LocalTime startTime;
+   private LocalTime endTime;
+   private long totalMinutes;
+   private BigDecimal totalMinutesBD;
+
+
+   private SimpleLoadingBar(LocalTime startTime, LocalTime endTime, String title) {
+      this.startTime = startTime;
+      setEndTime(endTime);
+      this.title = initTitle(title);
+   }
 
 
    public static void main(String[] args) {
@@ -27,13 +42,12 @@ public class SimpleLoadingBar {
       }
       verifyMinimumNumberOfArgs(args);
       String nextArg = args[0];
-      verifyTimeFormat(nextArg, "Erstes Argument"); // FSFIXME package
-      var firstTime = LocalTime.parse(nextArg, TIME_FORMATTER); // FSFIXME package
+      verifyTimeFormat(nextArg, "Erstes Argument");
+      var firstTime = LocalTime.parse(nextArg, TIME_FORMATTER);
       LocalTime startTime = null;
       String title = "";
       LocalTime endTime = null;
       if (args.length > 1) {
-         startTime = firstTime;
          nextArg = args[1];
          if ("-msg".equals(nextArg)) {
             title = args.length > 2 ? args[2] : title;
@@ -45,23 +59,32 @@ public class SimpleLoadingBar {
       if (endTime == null) {
          startTime = LocalTime.now();
          endTime = firstTime;
+      } else {
+         startTime = firstTime;
       }
-      String fallbackTitle = "Ende! Endzeit " + TIME_FORMATTER.format(endTime) + " erreicht.";
       if (args.length == 2 || !title.isBlank()) {
-         title = title.isBlank() ? fallbackTitle : title;
-         showLoadingBar(startTime, endTime, title);
+         new SimpleLoadingBar(startTime, endTime, title).showLoadingBar();
          return;
       }
       // if there are 3 arguments, the third will be discarded.
       boolean hasTitleArg = args.length > 3 && "-msg".equals(args[2]);
       title = hasTitleArg ? args[3] : title;
-      title = title.isBlank() ? fallbackTitle : title;
-      showLoadingBar(startTime, endTime, title);
+      new SimpleLoadingBar(startTime, endTime, title).showLoadingBar();
+   }
+
+
+   private static void println(Object o) {
+      System.out.println(o);
+   }
+
+
+   private static void print(Object o) {
+      System.out.print(o);
    }
 
 
    private static void printHelp() {
-      System.out.println("Mögliche Argumente für LoadingBar:\n"
+      println("Mögliche Argumente für LoadingBar:\n"
           + "Startzeit, Endzeit, Endnachricht (Optional)\n"
           + TIME_FORMAT + " " + TIME_FORMAT + " -msg <Nachricht>\n"
           + "Endzeit (Startzeit = jetzt), Endnachricht (Optional)\n"
@@ -74,7 +97,7 @@ public class SimpleLoadingBar {
       if (args.length >= 1) {
          return;
       }
-      System.out.println("Mindestens 1 Argument muss gegeben sein.");
+      println("Mindestens 1 Argument muss gegeben sein.");
       printHelp();
       System.exit(1);
    }
@@ -84,44 +107,52 @@ public class SimpleLoadingBar {
       if (TIME_PATTERN.matcher(param).matches()) {
          return;
       }
-      System.out.println(errMsgPrefix + " \"" + param + "\" muss Uhrzeitformat (" + TIME_FORMAT + ") entsprechen.");
+      println(errMsgPrefix + " \"" + param + "\" muss Uhrzeitformat (" + TIME_FORMAT + ") entsprechen.");
       System.exit(1);
    }
 
 
-   public static void showLoadingBar(LocalTime startTime, LocalTime endTime, String title) {
-      long initialMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
-      System.out.print(minutesToTimeString(initialMinutes) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime) + "\n");
-      long passedMinutes = startTime.until(LocalTime.now(), ChronoUnit.MINUTES);
-      if (passedMinutes > initialMinutes) {
-         passedMinutes = initialMinutes;
-      } else if (passedMinutes < 0) {
-         System.out.println(fillLoadingBar(initialMinutes, 0, false));
-         return;
-      }
-      while (passedMinutes < initialMinutes) {
-         System.out.print(fillLoadingBar(initialMinutes, passedMinutes, true));
-         try {
-            var now = LocalTime.now();
-            var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
-            // +1 second to adjust for ignored milliseconds as it is better to switch between 00 and 01 as between 59 and 00
-            TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
-            // TimeUnit.SECONDS.sleep(1L); // DEBUG
-         } catch (InterruptedException ie) {
-            throw new RuntimeException(ie);
-         }
-         passedMinutes++;
-      }
-      System.out.println(fillLoadingBar(initialMinutes, passedMinutes, false));
-      System.out.println(formatTitle(title));
+   private void setEndTime(LocalTime endTime) {
+      this.endTime = endTime;
+      this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
+      this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
    }
 
 
-   private static String fillLoadingBar(long initialMinutes, long passedMinutes, boolean progressive) {
-      BigDecimal wholePercentage = BigDecimal.valueOf(100)
-         .multiply(BigDecimal.valueOf(passedMinutes) // kind of reverse dreisatz to avoid to have e.g. 99.9999 instead of 100 %
-         .divide(BigDecimal.valueOf(initialMinutes), MathContext.DECIMAL64));
-      long remainingMinutes = initialMinutes - passedMinutes;
+   private String initTitle(String inputTitle) {
+      String fallbackTitle = "Ende! Endzeit " + TIME_FORMATTER.format(endTime) + " erreicht.";
+      String effectiveTitle = inputTitle == null || inputTitle.isBlank() ? fallbackTitle : inputTitle;
+      String separator = "*".repeat(effectiveTitle.length());
+      return separator + "\n" + effectiveTitle + "\n" + separator;
+   }
+
+
+   private void showLoadingBar() {
+      long passedMinutes = startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
+      // long passedMinutes = 0; // DEBUG
+      if (passedMinutes > totalMinutes) {
+         passedMinutes = totalMinutes;
+      } else if (passedMinutes < 0) {
+         var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
+         println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
+      }
+      println(minutesToTimeString(totalMinutesBD) + " gesamt; Endzeit: " + TIME_FORMATTER.format(endTime));
+      while (passedMinutes < totalMinutes) {
+         print(fillLoadingBar(passedMinutes, true));
+         waitUntilNextMinute();
+         passedMinutes++;
+      }
+      println(fillLoadingBar(passedMinutes, false));
+      println(title);
+   }
+
+
+   private String fillLoadingBar(long passedMinutes, boolean progressive) {
+      var nonNegativePassedMinutes = BigDecimal.valueOf(passedMinutes < 0 ? 0 : passedMinutes);
+      BigDecimal wholePercentage = ONE_HUNDRED_PERCENT
+         // kind of reverse dreisatz to avoid having e.g. 99.9999 instead of 100 %
+         .multiply(nonNegativePassedMinutes)
+         .divide(totalMinutesBD, MathContext.DECIMAL64);
       int numberOfEquals = wholePercentage.intValue();
       var sb = new StringBuilder("[");
       for (int i = 0; i < LINE_LENGTH; i++) {
@@ -131,8 +162,9 @@ public class SimpleLoadingBar {
             sb.append("-");
          }
       }
+      BigDecimal remainingMinutes = totalMinutesBD.subtract(nonNegativePassedMinutes);
       sb.append("] ").append(PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
-          .append(minutesToTimeString(passedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
+          .append(minutesToTimeString(nonNegativePassedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
       if (progressive) {
          sb.append("\r");
       }
@@ -140,15 +172,24 @@ public class SimpleLoadingBar {
    }
 
 
-   private static String minutesToTimeString(long minutes) {
-      var minutesBD = BigDecimal.valueOf(minutes);
-      BigDecimal[] hoursAndMinutes = minutesBD.divideAndRemainder(BigDecimal.valueOf(MINS_PER_HOUR), MC_INTEGER);
+   private String minutesToTimeString(BigDecimal minutes) {
+      BigDecimal[] hoursAndMinutes = minutes.divideAndRemainder(MINS_PER_HOUR_BD, MC_INTEGER);
       return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
    }
 
 
-   private static String formatTitle(String title) {
-      String separator = "*".repeat(title.length());
-      return separator + "\n" + title + "\n" + separator;
+   private void waitUntilNextMinute() {
+      try {
+         var now = LocalTime.now();
+         var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
+         /* We wait whole seconds to not make it overly complicated.
+            That results in cut milliseconds: if we would have to wait 1 second and 526 milliseconds, we wait only 1 second.
+            So, adjust for ignored milliseconds, add +1 second as it is better to switch between 00 and 01 as between 59 and 00 */
+         TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
+         // TimeUnit.MILLISECONDS.sleep(100L); // DEBUG
+      } catch (InterruptedException ie) {
+         Thread.currentThread().interrupt();
+         throw new RuntimeException(ie);
+      }
    }
 }

zeitlaeufer/compileProject.sh

@@ -0,0 +1,3 @@
+#/usr/bin/env bash
+
+javac -p target/ src/**/*.java

zeitlaeufer/src/main/java/de/szimnau/AbstractLoadingBar.java

@@ -0,0 +1,148 @@
+package de.szimnau;
+
+import de.szimnau.tools.FormatTools;
+import java.math.BigDecimal;
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+import java.util.concurrent.TimeUnit;
+
+import static de.szimnau.tools.CommonTools.print;
+import static de.szimnau.tools.CommonTools.println;
+
+
+public abstract class AbstractLoadingBar {
+
+   private final LocalTime startTime;
+   private LocalTime endTime;
+   private long totalMinutes;
+   private BigDecimal totalMinutesBD;
+
+
+   protected AbstractLoadingBar(LocalTime startTime) {
+      this.startTime = startTime;
+   }
+
+
+   protected AbstractLoadingBar(LocalTime startTime, LocalTime endTime) {
+      this.startTime = startTime;
+      setEndTime(endTime);
+   }
+
+
+   protected AbstractLoadingBar(LocalTime startTime, long totalMinutes) {
+      this.startTime = startTime;
+      this.endTime = startTime.plusMinutes(totalMinutes);
+      this.totalMinutes = totalMinutes;
+      this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
+   }
+
+
+   protected LocalTime getStartTime() {
+      return startTime;
+   }
+
+
+   protected LocalTime getEndTime() {
+      return endTime;
+   }
+
+
+   protected void setEndTime(LocalTime endTime) {
+      this.endTime = endTime;
+      this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
+      this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
+   }
+
+
+   protected long getTotalMinutes() {
+      return totalMinutes;
+   }
+
+
+   protected BigDecimal getTotalMinutesBD() {
+      return totalMinutesBD;
+   }
+
+
+   protected void showLoadingBar() {
+      showLoadingBar(false, false, 0);
+   }
+
+
+   protected void showLoadingBarDebug() {
+      showLoadingBar(true, true, 100L);
+   }
+
+
+   protected void showLoadingBarDebug(long millisWaiting) {
+      showLoadingBar(true, true, millisWaiting);
+   }
+
+
+   protected void showLoadingBarDebug(boolean passedMinutesZero) {
+      showLoadingBar(true, passedMinutesZero, 100L);
+   }
+
+
+   protected void showLoadingBarDebug(boolean passedMinutesZero, long millisWaiting) {
+      showLoadingBar(true, passedMinutesZero, millisWaiting);
+   }
+
+
+   private void showLoadingBar(boolean debug, boolean passedMinutesZero, long millisWaiting) {
+      long passedMinutes = startTime.until(LocalTime.now().truncatedTo(ChronoUnit.MINUTES), ChronoUnit.MINUTES);
+      if (debug && passedMinutesZero) {
+         passedMinutes = 0;
+      }
+      if (passedMinutes > totalMinutes) {
+         passedMinutes = totalMinutes;
+      } else if (passedMinutes < 0) {
+         var now = LocalTime.now().truncatedTo(ChronoUnit.SECONDS);
+         println("!ACHTUNG! Startzeit \"" + startTime + ":00\" liegt in der Zukunft von jetzt an (" + now + ") gesehen.");
+      }
+      println(FormatTools.minutesToTimeString(totalMinutes) + " gesamt; Endzeit: " + FormatTools.TIME_FORMATTER.format(endTime));
+      while (passedMinutes < totalMinutes) {
+         print(fillLoadingBar(passedMinutes, true));
+         waitUntilNextMinute(debug, millisWaiting);
+         passedMinutes++;
+      }
+      println(fillLoadingBar(passedMinutes, false));
+   }
+
+
+   protected abstract String fillLoadingBar(long passedMinutes, boolean progressive);
+
+
+   protected void waitUntilNextMinute() {
+      waitUntilNextMinute(false, 0L);
+   }
+
+
+   protected void waitUntilNextMinuteDebug() {
+      waitUntilNextMinute(true, 100L);
+   }
+
+
+   protected void waitUntilNextMinuteDebug(long millisWaiting) {
+      waitUntilNextMinute(true, millisWaiting);
+   }
+
+
+   private void waitUntilNextMinute(boolean debug, long millisWaiting) {
+      try {
+         if (debug) {
+            TimeUnit.MILLISECONDS.sleep(millisWaiting);
+            return;
+         }
+         var now = LocalTime.now();
+         var oneMinuteLater = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);
+         /* We wait whole seconds to not make it overly complicated.
+            That results in cut milliseconds: if we would have to wait 1 second and 526 milliseconds, we wait only 1 second.
+            So, adjust for ignored milliseconds, add +1 second as it is better to switch between 00 and 01 as between 59 and 00 */
+         TimeUnit.SECONDS.sleep(now.until(oneMinuteLater, ChronoUnit.SECONDS) + 1);
+      } catch (InterruptedException ie) {
+         Thread.currentThread().interrupt();
+         throw new RuntimeException(ie);
+      }
+   }
+}

zeitlaeufer/src/main/java/de/szimnau/AbstractProgressBar.java

@@ -0,0 +1,50 @@
+package de.szimnau;
+
+import de.szimnau.tools.FormatTools;
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.time.LocalTime;
+
+
+public abstract class AbstractProgressBar extends AbstractLoadingBar {
+
+   protected static final int LINE_LENGTH = 100;
+   protected static final BigDecimal ONE_HUNDRED_PERCENT = BigDecimal.valueOf(100);
+
+
+   protected AbstractProgressBar(LocalTime startTime) {
+      super(startTime);
+   }
+
+
+   protected AbstractProgressBar(LocalTime startTime, LocalTime endTime) {
+      super(startTime, endTime);
+   }
+
+
+   @Override
+   protected String fillLoadingBar(long passedMinutes, boolean progressive) {
+      var nonNegativePassedMinutes = BigDecimal.valueOf(passedMinutes < 0 ? 0 : passedMinutes);
+      BigDecimal wholePercentage = ONE_HUNDRED_PERCENT
+         // kind of reverse dreisatz to avoid having e.g. 99.9999 instead of 100 %
+         .multiply(nonNegativePassedMinutes)
+         .divide(getTotalMinutesBD(), MathContext.DECIMAL64);
+      int numberOfEquals = wholePercentage.intValue();
+      var sb = new StringBuilder("[");
+      for (int i = 0; i < LINE_LENGTH; i++) {
+         if (i < numberOfEquals) {
+            sb.append("=");
+         } else {
+            sb.append("-");
+         }
+      }
+      BigDecimal remainingMinutes = getTotalMinutesBD().subtract(nonNegativePassedMinutes);
+      sb.append("] ").append(FormatTools.PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
+          .append(FormatTools.minutesToTimeString(nonNegativePassedMinutes)).append(" - ")
+          .append(FormatTools.minutesToTimeString(remainingMinutes));
+      if (progressive) {
+         sb.append("\r");
+      }
+      return sb.toString();
+   }
+}

zeitlaeufer/src/main/java/de/szimnau/DrinkingBar.java

@@ -0,0 +1,65 @@
+package de.szimnau;
+
+import de.szimnau.tools.CommonTools;
+import de.szimnau.tools.FormatTools;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.nio.charset.StandardCharsets;
+import java.text.DecimalFormat;
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+
+import static de.szimnau.tools.CommonTools.print;
+
+
+public class DrinkingBar extends AbstractLoadingBar {
+
+   private static final int MINS_PER_HALF_HOUR = CommonTools.MINS_PER_HOUR / 2;
+   private static final int MINUTES_BEFORE_PAUSE = 4 * CommonTools.MINS_PER_HOUR + MINS_PER_HALF_HOUR;
+   private static final int MINUTES_WITH_PAUSE = 6 * CommonTools.MINS_PER_HOUR;
+   private static final int DEFAULT_TOTAL_TIME = 8 * CommonTools.MINS_PER_HOUR + MINS_PER_HALF_HOUR;
+   private static final DecimalFormat LITER_FORMAT = new DecimalFormat("0.00");
+
+
+   protected DrinkingBar(LocalTime startTime) {
+      super(startTime, DEFAULT_TOTAL_TIME);
+   }
+
+
+   public static void main(String[] args) throws IOException {
+      var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
+      print("Ankunftszeit: ");
+      var startTime = LocalTime.parse(br.readLine(), FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      var db = new DrinkingBar(startTime);
+      db.showLoadingBar();
+   }
+
+
+   @Override
+   protected String fillLoadingBar(long passedMinutes, boolean progressive) {
+      long effectivePassedMinutes = passedMinutes;
+      if (passedMinutes > MINUTES_BEFORE_PAUSE && passedMinutes <= MINUTES_WITH_PAUSE) {
+         effectivePassedMinutes = MINUTES_BEFORE_PAUSE;
+      }
+      double currentLitres = 2.0 / getTotalMinutes() * effectivePassedMinutes + 0.25;
+      double printedLitres = currentLitres - (currentLitres % 0.25);
+      // double currentProgressToNextStep = 100 / 0.25 * (currentLitres - printedLitres);
+      BigDecimal minutesToNextStep = getMinutesToNextStep(currentLitres);
+      String progressivePart = progressive ? "\r" : "";
+      return progressivePart + "Aktuelles Volumen: " + LITER_FORMAT.format(printedLitres) + "L - "
+         // + FormatTools.PERCENTAGE_FORMAT.format(currentProgressToNextStep) + "% - "
+         + FormatTools.minutesToTimeString(minutesToNextStep);
+   }
+
+
+   private BigDecimal getMinutesToNextStep(double currentLitres) {
+      // berechne Liter benötigt bis zum nächsten 0.25er Schritt
+      double litresToNextStep = 0.25 - (currentLitres % 0.25);
+      // berechne Minuten benötigt für 1 Liter
+      double minutesPerLitre = getTotalMinutes() / 2.0;
+      // berechne Minuten benötigt bis zum nächsten 0.25er Schritt
+      return BigDecimal.valueOf((minutesPerLitre * litresToNextStep) + 1);
+   }
+}

zeitlaeufer/src/main/java/de/szimnau/LoadingBar.java

@@ -0,0 +1,402 @@
+package de.szimnau;
+
+import de.szimnau.tools.CommonTools;
+import de.szimnau.tools.FormatTools;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static de.szimnau.tools.CommonTools.print;
+import static de.szimnau.tools.CommonTools.println;
+
+
+public class LoadingBar extends AbstractProgressBar {
+
+   private static final Pattern LUNCH_DURATION_PATTERN = Pattern.compile("\\d+");
+   private static final Pattern OFFSET_PATTERN = Pattern.compile("[+-]\\d+");
+   private static final int MIN_LUNCH_DURATION = 30;
+   private static final LocalTime LATEST_LUNCH_TIME = LocalTime.of(13, 30);
+   private static final long DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH = 5L * CommonTools.MINS_PER_HOUR;
+   private static final int MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH = 6 * CommonTools.MINS_PER_HOUR;
+   private static final long MAX_NUMBER_WORK_MINS = 8L * CommonTools.MINS_PER_HOUR;
+
+
+   private enum DaySection {
+      MITTAG("-m", "Mittag"),
+      ZAPFENSTREICH("-z", "Zapfenstreich");
+
+      private final String param;
+      private final String description;
+
+
+      DaySection(String param, String description) {
+         this.param = param;
+         this.description = description;
+      }
+
+
+      public static DaySection byParam(String param) {
+         return Arrays.stream(DaySection.values()).filter((DaySection section) -> section.getParam().equals(param)).findFirst().orElse(null);
+      }
+
+
+      public String getParam() {
+         return param;
+      }
+
+
+      public String getDescription() {
+         return description;
+      }
+   }
+
+
+   protected LoadingBar(LocalTime startTime) {
+      super(startTime);
+   }
+
+
+   public static void main(String[] args) throws IOException {
+      if (args.length == 0) {
+         askParametersAndRun();
+      } else {
+         parseParametersAndRun(args);
+      }
+   }
+
+
+   private static void askParametersAndRun() throws IOException {
+      var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
+      print("Ankunftszeit: ");
+      var startTime = LocalTime.parse(br.readLine(), FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      var lb = new LoadingBar(startTime);
+      if (lb.hasMittagspauseArrived()) {
+         handleMittagspause(br, lb);
+         lb.showLoadingBar();
+         // lb.showLoadingBarDebug(); // DEBUG
+      }
+      handleZapfenstreich(br, lb);
+      lb.showLoadingBar();
+      // lb.showLoadingBarDebug(); // DEBUG
+   }
+
+
+   protected static void handleMittagspause(BufferedReader br, LoadingBar lb) throws IOException {
+      print("Mittagspause verschieben um (optional): ");
+      String mittagspauseOffsetRaw = br.readLine();
+      if (mittagspauseOffsetRaw != null && !mittagspauseOffsetRaw.isBlank()) {
+         var mittagspauseOffset = Integer.parseInt(mittagspauseOffsetRaw);
+         lb.initMittagspause(mittagspauseOffset);
+         return;
+      }
+      print("Mittagspause um (optional): ");
+      String manualMittagspauseRaw = br.readLine();
+      if (manualMittagspauseRaw != null && !manualMittagspauseRaw.isBlank()) {
+         var manualMittagspause = LocalTime.parse(manualMittagspauseRaw, FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+         lb.initMittagspause(manualMittagspause);
+      } else {
+         lb.initMittagspause();
+      }
+   }
+
+
+   protected static void handleZapfenstreich(BufferedReader br, LoadingBar lb) throws IOException {
+      print("Mittagspause hat gedauert (optional): ");
+      String mittagspauseDurationRaw = br.readLine();
+      Integer mittagspauseDuration = null;
+      if (mittagspauseDurationRaw != null && !mittagspauseDurationRaw.isBlank()) {
+         mittagspauseDuration = Integer.valueOf(mittagspauseDurationRaw);
+      }
+      LocalTime vorlaeufigeEndzeit = lb.getStartTime().plusMinutes(MAX_NUMBER_WORK_MINS)
+         .plusMinutes(mittagspauseDuration != null ? mittagspauseDuration : MIN_LUNCH_DURATION);
+      println("Endzeit: " + FormatTools.TIME_FORMATTER.format(vorlaeufigeEndzeit));
+      print("Feierabend verschieben um (optional): ");
+      String zapfenstreichOffsetRaw = br.readLine();
+      Integer zapfenstreichOffset = null;
+      if (zapfenstreichOffsetRaw != null && !zapfenstreichOffsetRaw.isBlank()) {
+         zapfenstreichOffset = Integer.valueOf(zapfenstreichOffsetRaw);
+         lb.initZapfenstreich(mittagspauseDuration, zapfenstreichOffset);
+         return;
+      }
+      print("Manuelle Uhrzeit Feierabend (optional): ");
+      String manualZapfenstreichRaw = br.readLine();
+      LocalTime manualZapfenstreich = null;
+      if (manualZapfenstreichRaw != null && !manualZapfenstreichRaw.isBlank()) {
+         manualZapfenstreich = LocalTime.parse(manualZapfenstreichRaw, FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+         lb.initZapfenstreich(mittagspauseDuration, manualZapfenstreich);
+      } else {
+         lb.initZapfenstreich(mittagspauseDuration);
+      }
+   }
+
+
+   private static void parseParametersAndRun(String[] args) {
+      LoadingBar lb = getLoadingBarFromCLI(args);
+      lb.showLoadingBar();
+      // lb.showLoadingBarDebug(); // DEBUG
+   }
+
+
+   protected static LoadingBar getLoadingBarFromCLI(String[] args) {
+      String nextArg = args[0];
+      if ("--help".equals(nextArg)) {
+         printHelp();
+         System.exit(1);
+      }
+      verifyMinimumNumberOfArgs(args);
+      verifyTimeFormat(nextArg, "Erstes Argument");
+      var startTime = LocalTime.parse(nextArg, FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      nextArg = args[1];
+      var section = DaySection.byParam(nextArg);
+      verifyDaySection(section, nextArg);
+      return section == DaySection.MITTAG ? getLoadingBarMittagspause(args, startTime) : getLoadingBarZapfenstreich(args, startTime);
+   }
+
+
+   private static LoadingBar getLoadingBarMittagspause(String[] args, LocalTime startTime) {
+      var lb = new LoadingBar(startTime);
+      if (args.length == 2) {
+         lb.initMittagspause();
+         return lb;
+      }
+      String nextArg = args[2];
+      if (OFFSET_PATTERN.matcher(nextArg).matches()) {
+         lb.initMittagspause(Integer.parseInt(nextArg));
+         return lb;
+      }
+      verifyTimeFormat(nextArg, "Argument nach " + DaySection.MITTAG.getParam());
+      var manualMittagspause = LocalTime.parse(nextArg, FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      lb.initMittagspause(manualMittagspause);
+      return lb;
+   }
+
+
+   private static LoadingBar getLoadingBarZapfenstreich(String[] args, LocalTime startTime) {
+      var lb = new LoadingBar(startTime);
+      if (args.length == 2) {
+         lb.initZapfenstreich();
+         return lb;
+      }
+      String nextArg = args[2];
+      LocalTime maxZapfenstreich = null;
+      int endTimeOffset = 0;
+      Integer lunchDuration = null;
+      if (FormatTools.TIME_PATTERN.matcher(nextArg).matches()) {
+         maxZapfenstreich = LocalTime.parse(nextArg, FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      } else if (OFFSET_PATTERN.matcher(nextArg).matches()) {
+         endTimeOffset = Integer.parseInt(nextArg);
+      } else {
+         verifyDurationFormat(nextArg, "Argument nach " + DaySection.ZAPFENSTREICH.getParam());
+         lunchDuration = Integer.parseInt(nextArg);
+      }
+      if (args.length == 3) {
+         if (maxZapfenstreich == null && endTimeOffset == 0) {
+            lb.initZapfenstreich(lunchDuration);
+         } else if (maxZapfenstreich == null) {
+            lb.initZapfenstreich(lunchDuration, endTimeOffset);
+         } else {
+            lb.initZapfenstreich(lunchDuration, maxZapfenstreich);
+         }
+         return lb;
+      }
+      nextArg = args[3];
+      if (lunchDuration == null) {
+         println("Letztes Argument darf nur auf Mittagspausendauer folgen.");
+         System.exit(1);
+      }
+      if (maxZapfenstreich == null && !OFFSET_PATTERN.matcher(nextArg).matches()) {
+         verifyTimeFormat(nextArg, "Letztes Argument nach " + DaySection.ZAPFENSTREICH.getParam() + " und Mittagspausendauer");
+         maxZapfenstreich = LocalTime.parse(nextArg, FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+         lb.initZapfenstreich(lunchDuration, maxZapfenstreich);
+         return lb;
+      }
+      verifyOffsetFormat(nextArg, "Letztes Argument nach " + DaySection.ZAPFENSTREICH.getParam() + " und Enduhrzeit");
+      endTimeOffset = Integer.parseInt(nextArg);
+      lb.initZapfenstreich(lunchDuration, endTimeOffset);
+      return lb;
+   }
+
+
+   private static void verifyMinimumNumberOfArgs(String[] args) {
+      if (args.length >= 2) {
+         return;
+      }
+      println("Mindestens 2 Argumente müssen gegeben sein.");
+      printHelp();
+      System.exit(1);
+   }
+
+
+   private static void verifyTimeFormat(String param, String errMsgPrefix) {
+      verifyInputFormat(FormatTools.TIME_PATTERN, param, errMsgPrefix, "Uhrzeitformat (" + FormatTools.TIME_FORMAT + ")", false);
+   }
+
+
+   private static void verifyDurationFormat(String param, String errMsgPrefix) {
+      verifyInputFormat(LUNCH_DURATION_PATTERN, param, errMsgPrefix, "Minutenanzahl (ganze Zahl)", true);
+   }
+
+
+   private static void verifyOffsetFormat(String param, String errMsgPrefix) {
+      verifyInputFormat(OFFSET_PATTERN, param, errMsgPrefix, "Minutendifferenz (ganze Zahl mit Vorzeichen)", false);
+   }
+
+
+   private static void verifyInputFormat(Pattern pattern, String param, String errMsgPrefix, String firstInputPart, boolean timeInputPossible) {
+      if (pattern.matcher(param).matches()) {
+         return;
+      }
+      var possibleTimeInputPart = timeInputPossible ? " oder Uhrzeitformat (" + FormatTools.TIME_FORMAT + ")" : "";
+      println(errMsgPrefix + " \"" + param + "\" muss " + firstInputPart + possibleTimeInputPart + " entsprechen.");
+      System.exit(1);
+   }
+
+
+   private static void verifyDaySection(DaySection section, String param) {
+      if (section != null) {
+         return;
+      }
+      List<String> sectionDescs = Arrays.stream(DaySection.values()).map((DaySection ds) -> ds.getDescription() + " (" + ds.getParam() + ")")
+          .collect(Collectors.toList());
+      String sectionDescsJoined = String.join(" oder ", sectionDescs);
+      println("Argument nach Startzeit \"" + param + "\" muss Angabe für " + sectionDescsJoined + " sein.");
+      System.exit(1);
+   }
+
+
+   private static void printHelp() {
+      println("Mögliche Argumente für LoadingBar:\n"
+          + "Normalfall Vormittag (Mittagspause <= " + LATEST_LUNCH_TIME + ")\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.MITTAG.getParam() + "\n"
+          + "Vormittag mit expliziter Mittagspause (<= " + LATEST_LUNCH_TIME + ")\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.MITTAG.getParam() + " " + FormatTools.TIME_FORMAT + "\n"
+          + "Vormittag mit abweichender Minutenanzahl Arbeitszeit\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.MITTAG.getParam() + " -+mm\n"
+          + "Normalfall Nachmittag (Mittagspause " + MIN_LUNCH_DURATION + " min)\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + "\n"
+          + "Nachmittag mit expliziter Länge Mittagspause (Mittagspause unter " + MIN_LUNCH_DURATION + " min wird auf " + MIN_LUNCH_DURATION + " min korrigiert)\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " mm\n"
+          + "Nachmittag mit explizitem Feierabend (Mittagspause je nach Minimum (s.u.))\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " " + FormatTools.TIME_FORMAT + "\n"
+          + "Nachmittag mit abweichender Minutenanzahl Arbeitszeit\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " -+mm\n"
+          + "Nachmittag mit explizitem Feierabend u. expliziter Länge Mittagspause (Mittagspause unter Minimum (s.u.) wird auf Minimum korrigiert)\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " mm " + FormatTools.TIME_FORMAT + "\n"
+          + "Nachmittag mit explizitem Feierabend u. abweichender Minutenanzahl Arbeitszeit\n"
+          + FormatTools.TIME_FORMAT + " " + DaySection.ZAPFENSTREICH.getParam() + " " + FormatTools.TIME_FORMAT + " -+mm\n\n"
+          + "Mittagspause minimum in Minuten:\n"
+          + " - bis " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min ("
+          + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH / CommonTools.MINS_PER_HOUR + " std):  0\n"
+          + " - bis " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min + "
+          + MIN_LUNCH_DURATION + " min: Arbeitszeit - " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min\n"
+          + " - ab  " + MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH + " min + " + MIN_LUNCH_DURATION + " min: "
+          + MIN_LUNCH_DURATION + " min\n"
+      );
+   }
+
+
+   protected boolean hasMittagspauseArrived() {
+      return getStartTime().until(LocalTime.now(), ChronoUnit.MINUTES) < DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH;
+   }
+
+
+   private void initMittagspause() {
+      LocalTime defaultEndTime = getStartTime().plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
+      realInitMittagspause(defaultEndTime);
+   }
+
+
+   private void initMittagspause(int endTimeOffset) {
+      LocalTime offsetEndTime = getStartTime().plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH + endTimeOffset);
+      realInitMittagspause(offsetEndTime);
+   }
+
+
+   private void initMittagspause(LocalTime manualEndTime) {
+      LocalTime effectiveEndTime = manualEndTime != null ? manualEndTime : getStartTime().plusMinutes(DEFAULT_NUMBER_WORK_MINS_BEFORE_LUNCH);
+      realInitMittagspause(effectiveEndTime);
+   }
+
+
+   private void realInitMittagspause(LocalTime theoreticalEndTime) {
+      setEndTime(theoreticalEndTime.isAfter(LATEST_LUNCH_TIME) ? LATEST_LUNCH_TIME : theoreticalEndTime);
+   }
+
+
+   private void initZapfenstreich() {
+      LocalTime trueEndTime = getStartTime().plusMinutes(MAX_NUMBER_WORK_MINS + MIN_LUNCH_DURATION);
+      realInitZapfenstreich(MIN_LUNCH_DURATION, trueEndTime);
+   }
+
+
+   private void initZapfenstreich(Integer manualLunchDuration) {
+      initZapfenstreich(manualLunchDuration, 0);
+   }
+
+
+   private void initZapfenstreich(Integer manualLunchDuration, int endTimeOffset) {
+      long minLunchDuration = getMinLunchDuration(endTimeOffset);
+      long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
+      LocalTime trueEndTime = getStartTime().plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration + endTimeOffset);
+      realInitZapfenstreich(realLunchDuration, trueEndTime);
+   }
+
+
+   private void initZapfenstreich(Integer manualLunchDuration, LocalTime manualEndTime) {
+      LocalTime trueEndTime = manualEndTime;
+      long minLunchDuration = getMinLunchDuration(trueEndTime);
+      long realLunchDuration = getRealLunchDuration(manualLunchDuration, minLunchDuration);
+      if (trueEndTime == null) {
+         trueEndTime = getStartTime().plusMinutes(MAX_NUMBER_WORK_MINS + realLunchDuration);
+      }
+      realInitZapfenstreich(realLunchDuration, trueEndTime);
+   }
+
+
+   private long getMinLunchDuration(int endTimeOffset) {
+      if (endTimeOffset == 0) {
+         return MIN_LUNCH_DURATION;
+      }
+      long totalDuration = MAX_NUMBER_WORK_MINS + endTimeOffset;
+      long effectiveLunchDuration = totalDuration - MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH;
+      return getMinLunchDuration(effectiveLunchDuration);
+   }
+
+
+   private long getMinLunchDuration(LocalTime manualEndTime) {
+      if (manualEndTime == null) {
+         return MIN_LUNCH_DURATION;
+      }
+      long totalDuration = getStartTime().until(manualEndTime, ChronoUnit.MINUTES);
+      long effectiveLunchDuration = totalDuration - MAX_NUMBER_WORK_MINS_WITHOUT_LUNCH;
+      return getMinLunchDuration(effectiveLunchDuration);
+   }
+
+
+   private long getMinLunchDuration(long effectiveLunchDuration) {
+      if (effectiveLunchDuration < 0) {
+         effectiveLunchDuration = 0;
+      }
+      return Math.min(effectiveLunchDuration, MIN_LUNCH_DURATION);
+   }
+
+
+   private long getRealLunchDuration(Integer manualLunchDuration, long minLunchDuration) {
+      return manualLunchDuration != null && manualLunchDuration >= minLunchDuration ? manualLunchDuration : minLunchDuration;
+   }
+
+
+   private void realInitZapfenstreich(long effectiveLunchDuration, LocalTime effectiveEndTime) {
+      if (effectiveLunchDuration > 0) {
+         var totalWorkTime = LocalTime.MIDNIGHT.plusMinutes(getStartTime().until(effectiveEndTime, ChronoUnit.MINUTES) - effectiveLunchDuration);
+         print("Arbeitszeit: " + FormatTools.TIME_FORMATTER.format(totalWorkTime) + "; ");
+      }
+      setEndTime(effectiveEndTime);
+   }
+}

zeitlaeufer/src/main/java/de/szimnau/SimpleLoadingBar.java

@@ -0,0 +1,102 @@
+package de.szimnau;
+
+import de.szimnau.tools.FormatTools;
+import java.time.LocalTime;
+import java.util.*;
+
+import static de.szimnau.tools.CommonTools.println;
+
+
+public class SimpleLoadingBar extends AbstractProgressBar {
+
+   private final String title;
+
+
+   private SimpleLoadingBar(LocalTime startTime, LocalTime endTime, String title) {
+      super(startTime, endTime);
+      this.title = initTitle(title);
+   }
+
+
+   public static void main(String[] args) {
+      if (args.length > 0 && Objects.equals(args[0], "--help")) {
+         printHelp();
+         return;
+      }
+      verifyMinimumNumberOfArgs(args);
+      String nextArg = args[0];
+      verifyTimeFormat(nextArg, "Erstes Argument");
+      var firstTime = LocalTime.parse(nextArg, FormatTools.TIME_FORMATTER);
+      LocalTime startTime = null;
+      String title = "";
+      LocalTime endTime = null;
+      if (args.length > 1) {
+         nextArg = args[1];
+         if ("-msg".equals(nextArg)) {
+            title = args.length > 2 ? args[2] : title;
+         } else {
+            verifyTimeFormat(nextArg, "Zweites Argument");
+            endTime = LocalTime.parse(nextArg, FormatTools.TIME_FORMATTER);
+         }
+      }
+      if (endTime == null) {
+         startTime = LocalTime.now();
+         endTime = firstTime;
+      } else {
+         startTime = firstTime;
+      }
+      if (args.length == 2 || !title.isBlank()) {
+         new SimpleLoadingBar(startTime, endTime, title).showLoadingBar();
+         return;
+      }
+      // if there are 3 arguments, the third will be discarded.
+      boolean hasTitleArg = args.length > 3 && "-msg".equals(args[2]);
+      title = hasTitleArg ? args[3] : title;
+      new SimpleLoadingBar(startTime, endTime, title).showLoadingBar();
+   }
+
+
+   private static void printHelp() {
+      println("Mögliche Argumente für LoadingBar:\n"
+          + "Startzeit, Endzeit, Endnachricht (Optional)\n"
+          + FormatTools.TIME_FORMAT + " " + FormatTools.TIME_FORMAT + " -msg <Nachricht>\n"
+          + "Endzeit (Startzeit = jetzt), Endnachricht (Optional)\n"
+          + FormatTools.TIME_FORMAT + " -msg <Nachricht>\n"
+      );
+   }
+
+
+   private static void verifyMinimumNumberOfArgs(String[] args) {
+      if (args.length >= 1) {
+         return;
+      }
+      println("Mindestens 1 Argument muss gegeben sein.");
+      printHelp();
+      System.exit(1);
+   }
+
+
+   private static void verifyTimeFormat(String param, String errMsgPrefix) {
+      if (FormatTools.TIME_PATTERN.matcher(param).matches()) {
+         return;
+      }
+      println(errMsgPrefix + " \"" + param + "\" muss Uhrzeitformat (" + FormatTools.TIME_FORMAT + ") entsprechen.");
+      System.exit(1);
+   }
+
+
+   private String initTitle(String inputTitle) {
+      String fallbackTitle = "Ende! Endzeit " + FormatTools.TIME_FORMATTER.format(getEndTime()) + " erreicht.";
+      String effectiveTitle = inputTitle == null || inputTitle.isBlank() ? fallbackTitle : inputTitle;
+      String separator = "*".repeat(effectiveTitle.length());
+      return separator + "\n" + effectiveTitle + "\n" + separator;
+   }
+
+
+   @Override
+   protected void showLoadingBar() {
+      showLoadingBar();
+      // showLoadingBarDebug(); // DEBUG
+      println(title);
+   }
+}

zeitlaeufer/src/main/java/de/szimnau/WorkLoadingBar.java

@@ -0,0 +1,91 @@
+package de.szimnau;
+
+import de.szimnau.tools.CommonTools;
+import de.szimnau.tools.FormatTools;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+
+import static de.szimnau.tools.CommonTools.print;
+
+
+public class WorkLoadingBar extends AbstractProgressBar {
+
+   private final LoadingBar loadingBar;
+   private final DrinkingBar drinkingBar;
+
+
+   private WorkLoadingBar(LoadingBar loadingBar, DrinkingBar drinkingBar) {
+      super(loadingBar.getStartTime());
+      this.loadingBar = loadingBar;
+      this.drinkingBar = drinkingBar;
+   }
+
+
+   public static void main(String[] args) throws IOException {
+      if (args.length == 0) {
+         askParametersAndRun();
+      } else {
+         parseParametersAndRun(args);
+      }
+   }
+
+
+   private static void askParametersAndRun() throws IOException {
+      var br = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
+      print("Ankunftszeit: ");
+      var startTime = LocalTime.parse(br.readLine(), FormatTools.TIME_FORMATTER).truncatedTo(ChronoUnit.MINUTES);
+      var lb = new LoadingBar(startTime);
+      var db = new DrinkingBar(startTime);
+      var wlb = new WorkLoadingBar(lb, db);
+      if (lb.hasMittagspauseArrived()) {
+         handleMittagspause(br, wlb);
+         wlb.showLoadingBar();
+         // wlb.showLoadingBarDebug(); // DEBUG
+      }
+      handleZapfenstreich(br, wlb);
+      wlb.showLoadingBar();
+      // wlb.showLoadingBarDebug(); // DEBUG
+   }
+
+
+   private static void handleMittagspause(BufferedReader br, WorkLoadingBar wlb) throws IOException {
+      LoadingBar.handleMittagspause(br, wlb.loadingBar);
+      wlb.setEndTime(wlb.loadingBar.getEndTime(), false);
+   }
+
+
+   private static void handleZapfenstreich(BufferedReader br, WorkLoadingBar wlb) throws IOException {
+      LoadingBar.handleZapfenstreich(br, wlb.loadingBar);
+      wlb.setEndTime(wlb.loadingBar.getEndTime(), true);
+   }
+
+
+   private static void parseParametersAndRun(String[] args) {
+      LoadingBar lb = LoadingBar.getLoadingBarFromCLI(args);
+      var db = new DrinkingBar(lb.getStartTime());
+      var wlb = new WorkLoadingBar(lb, db);
+      wlb.setEndTime(wlb.loadingBar.getEndTime(), true);
+      wlb.showLoadingBar();
+      // wlb.showLoadingBarDebug(); // DEBUG
+   }
+
+
+   protected void setEndTime(LocalTime endTime, boolean finalEndTime) {
+      setEndTime(endTime);
+      if (finalEndTime) {
+         drinkingBar.setEndTime(endTime);
+      }
+   }
+
+
+   @Override
+   protected String fillLoadingBar(long passedMinutes, boolean progressive) {
+      String filledLoadingBar = loadingBar.fillLoadingBar(passedMinutes, false);
+      filledLoadingBar += " | " + drinkingBar.fillLoadingBar(passedMinutes, false);
+      return filledLoadingBar + (progressive ? "\r" : "");
+   }
+}

zeitlaeufer/src/main/java/de/szimnau/tools/CommonTools.java

@@ -0,0 +1,28 @@
+package de.szimnau.tools;
+
+import java.lang.*;
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.math.RoundingMode;
+import java.util.*;
+
+
+public class CommonTools {
+
+   public static final int MINS_PER_HOUR = 60;
+   public static final BigDecimal MINS_PER_HOUR_BD = BigDecimal.valueOf(MINS_PER_HOUR);
+   public static final MathContext MC_INTEGER = new MathContext(1, RoundingMode.HALF_EVEN);
+
+
+   private CommonTools() {}
+
+
+   public static void print(Object o) {
+      System.out.print(o);
+   }
+
+
+   public static void println(Object o) {
+      System.out.println(o);
+   }
+}

zeitlaeufer/src/main/java/de/szimnau/tools/FormatTools.java

@@ -0,0 +1,32 @@
+package de.szimnau.tools;
+
+import java.lang.*;
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.time.format.DateTimeFormatter;
+import java.time.LocalTime;
+import java.util.*;
+import java.util.regex.Pattern;
+
+
+public class FormatTools {
+
+   public static final String TIME_FORMAT = "HH:mm";
+   public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(TIME_FORMAT);
+   public static final Pattern TIME_PATTERN = Pattern.compile("(?>[01]\\d|2[0-4]):[0-5]\\d");
+   public static final DecimalFormat PERCENTAGE_FORMAT = new DecimalFormat("00.00");
+
+
+   private FormatTools() {}
+
+
+   public static String minutesToTimeString(long minutes) {
+      return minutesToTimeString(BigDecimal.valueOf(minutes));
+   }
+
+
+   public static String minutesToTimeString(BigDecimal minutes) {
+      BigDecimal[] hoursAndMinutes = minutes.divideAndRemainder(CommonTools.MINS_PER_HOUR_BD, CommonTools.MC_INTEGER);
+      return LocalTime.of(hoursAndMinutes[0].intValue(), hoursAndMinutes[1].intValue()).format(TIME_FORMATTER);
+   }
+}