/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package dev.metaschema.cli.processor.ansi;
   
   import java.util.concurrent.atomic.AtomicBoolean;
   
  import edu.umd.cs.findbugs.annotations.NonNull;
  
  /**
   * A minimal ANSI escape-code builder used by the CLI to emit colored and
   * formatted terminal output.
   * <p>
   * Emits a subset of
   * <a href= "https://en.wikipedia.org/wiki/ANSI_escape_code#Colors">Select
   * Graphic Rendition</a> codes for foreground colors, bold, and reset. When
   * globally disabled via {@link #setEnabled(boolean)}, escape sequences are
   * suppressed while appended literal text is preserved so output remains
   * readable on terminals that do not interpret ANSI codes.
   */
  public final class Ansi {
    private static final String ESC = "\u001B[";
    private static final String RESET_SEQ = ESC + "0m";
    private static final String BOLD_SEQ = ESC + "1m";
    private static final String BOLD_OFF_SEQ = ESC + "22m";
  
    private static final AtomicBoolean ENABLED = new AtomicBoolean(true);
  
    @NonNull
    private final StringBuilder buffer = new StringBuilder();
  
    private Ansi() {
      // use ansi() factory
    }
  
    /**
     * Create a new builder.
     *
     * @return a fresh builder with empty contents
     */
    @NonNull
    public static Ansi ansi() {
      return new Ansi();
    }
  
    /**
     * Globally enable or disable emission of ANSI escape codes.
     * <p>
     * When disabled, all color and style methods are no-ops; literal appended text
     * is still emitted.
     *
     * @param enable
     *          {@code true} to emit escape sequences, {@code false} to suppress
     *          them
     */
    public static void setEnabled(boolean enable) {
      ENABLED.set(enable);
    }
  
    /**
     * Indicates whether ANSI escape code emission is currently enabled.
     *
     * @return {@code true} if enabled
     */
    public static boolean isEnabled() {
      return ENABLED.get();
    }
  
    @NonNull
    private Ansi emit(@NonNull String sequence) {
      if (ENABLED.get()) {
        buffer.append(sequence);
      }
      return this;
    }
  
    /**
     * Append a single literal character.
     *
     * @param ch
     *          the character to append
     * @return {@code this} for chaining
     */
    @NonNull
    public Ansi a(char ch) {
      buffer.append(ch);
      return this;
    }
  
    /**
     * Append a literal string.
     *
     * @param text
     *          the text to append
     * @return {@code this} for chaining
     */
    @NonNull
   public Ansi a(@NonNull CharSequence text) {
     buffer.append(text);
     return this;
   }
 
   /**
    * Append formatted text using {@link String#format(String, Object...)}
    * semantics.
    *
    * @param format
    *          the format string
    * @param args
    *          the format arguments
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi format(@NonNull String format, Object... args) {
     buffer.append(String.format(format, args));
     return this;
   }
 
   /**
    * Emit the ANSI reset sequence, clearing any active color or style.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi reset() {
     return emit(RESET_SEQ);
   }
 
   /**
    * Enable bold rendering for subsequent appended text.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi bold() {
     return emit(BOLD_SEQ);
   }
 
   /**
    * Disable bold rendering for subsequent appended text.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi boldOff() {
     return emit(BOLD_OFF_SEQ);
   }
 
   /**
    * Set the foreground color to red.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi fgRed() {
     return emit(ESC + "31m");
   }
 
   /**
    * Set the foreground color to bright red.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi fgBrightRed() {
     return emit(ESC + "91m");
   }
 
   /**
    * Set the foreground color to bright yellow.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi fgBrightYellow() {
     return emit(ESC + "93m");
   }
 
   /**
    * Set the foreground color to bright blue.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi fgBrightBlue() {
     return emit(ESC + "94m");
   }
 
   /**
    * Set the foreground color to bright cyan.
    *
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi fgBrightCyan() {
     return emit(ESC + "96m");
   }
 
   /**
    * Set the foreground color to the bright variant of the supplied color.
    *
    * @param color
    *          the base color
    * @return {@code this} for chaining
    */
   @NonNull
   public Ansi fgBright(@NonNull Color color) {
     return emit(ESC + (90 + color.ordinal()) + "m");
   }
 
   @Override
   public String toString() {
     return buffer.toString();
   }
 
   /**
    * Standard 8 ANSI foreground colors. Ordinals align with the standard color
    * codes (0-7) so bright variants are derived by adding 90.
    */
   public enum Color {
     /** Black (code 30, bright 90). */
     BLACK,
     /** Red (code 31, bright 91). */
     RED,
     /** Green (code 32, bright 92). */
     GREEN,
     /** Yellow (code 33, bright 93). */
     YELLOW,
     /** Blue (code 34, bright 94). */
     BLUE,
     /** Magenta (code 35, bright 95). */
     MAGENTA,
     /** Cyan (code 36, bright 96). */
     CYAN,
     /** White (code 37, bright 97). */
     WHITE;
   }
 }