JavaUtils/SimpleLoadingBar.java

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;

public class SimpleLoadingBar {

   private static final String TIME_FORMAT = "HH:mm";
   private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(TIME_FORMAT);
   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) {
      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, 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, 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 println(Object o) {
      System.out.println(o);
   }


   private static void print(Object o) {
      System.out.print(o);
   }


   private static void printHelp() {
      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"
          + 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 (TIME_PATTERN.matcher(param).matches()) {
         return;
      }
      println(errMsgPrefix + " \"" + param + "\" muss Uhrzeitformat (" + TIME_FORMAT + ") entsprechen.");
      System.exit(1);
   }


   private void setEndTime(LocalTime endTime) {
      this.endTime = endTime;
      this.totalMinutes = startTime.until(endTime, ChronoUnit.MINUTES);
      this.totalMinutesBD = BigDecimal.valueOf(totalMinutes);
   }


   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++) {
         if (i < numberOfEquals) {
            sb.append("=");
         } else {
            sb.append("-");
         }
      }
      BigDecimal remainingMinutes = totalMinutesBD.subtract(nonNegativePassedMinutes);
      sb.append("] ").append(PERCENTAGE_FORMAT.format(wholePercentage)).append("% ")
          .append(minutesToTimeString(nonNegativePassedMinutes)).append(" - ").append(minutesToTimeString(remainingMinutes));
      if (progressive) {
         sb.append("\r");
      }
      return sb.toString();
   }


   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);
      }
   }
}