/*
 * SPDX-FileCopyrightText: none
 * SPDX-License-Identifier: CC0-1.0
 */

package dev.metaschema.cli.processor;

import static org.jline.jansi.Ansi.ansi;

import org.apache.commons.cli.Option;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.eclipse.jdt.annotation.NotOwning;
import org.jline.jansi.Ansi;

import java.io.PrintStream;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import dev.metaschema.cli.processor.command.CommandService;
import dev.metaschema.cli.processor.command.ICommand;
import dev.metaschema.core.util.CollectionUtil;
import dev.metaschema.core.util.IVersionInfo;
import dev.metaschema.core.util.ObjectUtils;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

/**
 * Processes command line arguments and dispatches called commands.
 * <p>
 * This implementation make significant use of the command pattern to support a
 * delegation chain of commands based on implementations of {@link ICommand}.
 */
public class CLIProcessor {
  private static final Logger LOGGER = LogManager.getLogger(CLIProcessor.class);

  /**
   * This option indicates if the help should be shown.
   */
  @NonNull
  public static final Option HELP_OPTION = ObjectUtils.notNull(Option.builder("h")
      .longOpt("help")
      .desc("display this help message")
      .get());
  /**
   * This option indicates if colorized output should be disabled.
   */
  @NonNull
  public static final Option NO_COLOR_OPTION = ObjectUtils.notNull(Option.builder()
      .longOpt("no-color")
      .desc("do not colorize output")
      .get());
  /**
   * This option indicates if non-errors should be suppressed.
   */
  @NonNull
  public static final Option QUIET_OPTION = ObjectUtils.notNull(Option.builder("q")
      .longOpt("quiet")
      .desc("minimize output to include only errors")
      .get());
  /**
   * This option indicates if a strack trace should be shown for an error
   * {@link ExitStatus}.
   */
  @NonNull
  public static final Option SHOW_STACK_TRACE_OPTION = ObjectUtils.notNull(Option.builder()
      .longOpt("show-stack-trace")
      .desc("display the stack trace associated with an error")
      .get());
  /**
   * This option indicates if the version information should be shown.
   */
  @NonNull
  public static final Option VERSION_OPTION = ObjectUtils.notNull(Option.builder()
      .longOpt("version")
      .desc("display the application version")
      .get());

  @NonNull
  static final List<Option> OPTIONS = ObjectUtils.notNull(List.of(
      HELP_OPTION,
      NO_COLOR_OPTION,
      QUIET_OPTION,
      SHOW_STACK_TRACE_OPTION,
      VERSION_OPTION));

  /**
   * Used to identify the version info for the command.
   */
  public static final String COMMAND_VERSION = "http://csrc.nist.gov/ns/metaschema-java/cli/command-version";

  @NonNull
  private final List<ICommand> commands = new LinkedList<>();
  @NonNull
  private final String exec;
  @NonNull
  private final Map<String, IVersionInfo> versionInfos;
  @NonNull
  @NotOwning
  private final PrintStream outputStream;

  /**
   * The main entry point for command execution.
   *
   * @param args
   *          the command line arguments to process
   */
  public static void main(String... args) {
    System.setProperty("java.util.logging.manager", "org.apache.logging.log4j.jul.LogManager");
    CLIProcessor processor = new CLIProcessor("metaschema-cli");

    CommandService.getInstance().getCommands().stream().forEach(command -> {
      assert command != null;
      processor.addCommandHandler(command);
    });
    System.exit(processor.process(args).getExitCode().getStatusCode());
  }

  /**
   * The main entry point for CLI processing.
   * <p>
   * This uses the build-in version information.
   *
   * @param args
   *          the command line arguments
   */
  public CLIProcessor(@NonNull String args) {
    this(args, CollectionUtil.singletonMap(COMMAND_VERSION, new ProcessorVersion()));
  }

  /**
   * The main entry point for CLI processing.
   * <p>
   * This uses the provided version information.
   *
   * @param exec
   *          the command name
   * @param versionInfos
   *          the version info to display when the version option is provided
   */
  public CLIProcessor(@NonNull String exec, @NonNull Map<String, IVersionInfo> versionInfos) {
    this(exec, versionInfos, null);
  }

  /**
   * The main entry point for CLI processing.
   * <p>
   * This constructor allows specifying a custom output stream for testing
   * purposes.
   *
   * @param exec
   *          the command name
   * @param versionInfos
   *          the version info to display when the version option is provided
   * @param outputStream
   *          the output stream to write to, or {@code null} to use the default
   *          console. The caller retains ownership of this stream and is
   *          responsible for closing it.
   */
  @SuppressWarnings("resource")
  public CLIProcessor(@NonNull String exec, @NonNull Map<String, IVersionInfo> versionInfos,
      @Nullable @NotOwning PrintStream outputStream) {
    this.exec = exec;
    this.versionInfos = versionInfos;
    // Use System.out directly - modern terminals (Windows 10+, Linux, macOS)
    // support ANSI natively without requiring native terminal detection
    this.outputStream = outputStream != null ? outputStream : ObjectUtils.notNull(System.out);
  }

  /**
   * Gets the command used to execute for use in help text.
   *
   * @return the command name
   */
  @NonNull
  public String getExec() {
    return exec;
  }

  /**
   * Retrieve the version information for this application.
   *
   * @return the versionInfo
   */
  @NonNull
  public Map<String, IVersionInfo> getVersionInfos() {
    return versionInfos;
  }

  /**
   * Register a new command handler.
   *
   * @param handler
   *          the command handler to register
   */
  public void addCommandHandler(@NonNull ICommand handler) {
    commands.add(handler);
  }

  /**
   * Process a set of CLIProcessor arguments.
   * <p>
   * process().getExitCode().getStatusCode()
   *
   * @param args
   *          the arguments to process
   * @return the exit status
   */
  @NonNull
  public ExitStatus process(String... args) {
    return parseCommand(args);
  }

  @NonNull
  private ExitStatus parseCommand(String... args) {
    List<String> commandArgs = Arrays.asList(args);
    assert commandArgs != null;
    CallingContext callingContext = new CallingContext(this, commandArgs);

    if (LOGGER.isDebugEnabled()) {
      String commandChain = callingContext.getCalledCommands().stream()
          .map(ICommand::getName)
          .collect(Collectors.joining(" -> "));
      LOGGER.debug("Processing command chain: {}", commandChain);
    }

    ExitStatus status;
    // the first two arguments should be the <command> and <operation>, where <type>
    // is the object type
    // the <operation> is performed against.
    if (commandArgs.isEmpty()) {
      status = ExitCode.INVALID_COMMAND.exit();
      callingContext.showHelp();
    } else {
      status = callingContext.processCommand();
    }
    return status;
  }

  /**
   * Get the root-level commands.
   *
   * @return the list of commands
   */
  @NonNull
  public final List<ICommand> getTopLevelCommands() {
    return CollectionUtil.unmodifiableList(commands);
  }

  /**
   * Get the root-level commands, mapped from name to command.
   *
   * @return the map of command names to command
   */
  @NonNull
  protected final Map<String, ICommand> getTopLevelCommandsByName() {
    return ObjectUtils.notNull(getTopLevelCommands()
        .stream()
        .collect(Collectors.toUnmodifiableMap(ICommand::getName, Function.identity())));
  }

  /**
   * Disable ANSI escape sequences in output.
   * <p>
   * When called, this method disables ANSI color codes, causing output to use
   * plain text without formatting. This is useful for legacy consoles that do not
   * support ANSI escape codes, CI/CD environments, or when redirecting output to
   * a file.
   */
  static void handleNoColor() {
    Ansi.setEnabled(false);
  }

  /**
   * Get the output stream used for writing CLI output.
   * <p>
   * The caller does not own this stream and must not close it.
   *
   * @return the output stream
   */
  @NonNull
  @NotOwning
  PrintStream getOutputStream() {
    return outputStream;
  }

  /**
   * Configure the logger to only report errors.
   */
  static void handleQuiet() {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false); // NOPMD not closable here
    Configuration config = ctx.getConfiguration();
    LoggerConfig loggerConfig = config.getLoggerConfig(LogManager.ROOT_LOGGER_NAME);
    Level oldLevel = loggerConfig.getLevel();
    if (oldLevel.isLessSpecificThan(Level.ERROR)) {
      loggerConfig.setLevel(Level.ERROR);
      ctx.updateLoggers();
    }
  }

  /**
   * Output version information.
   */
  protected void showVersion() {
    getVersionInfos().values().stream().forEach(info -> {
      outputStream.println(ansi()
          .bold().a(info.getName()).boldOff()
          .a(" ")
          .bold().a(info.getVersion()).boldOff()
          .a(" built at ")
          .bold().a(info.getBuildTimestamp()).boldOff()
          .a(" from branch ")
          .bold().a(info.getGitBranch()).boldOff()
          .a(" (")
          .bold().a(info.getGitCommit()).boldOff()
          .a(") at ")
          .bold().a(info.getGitOriginUrl()).boldOff()
          .reset());
    });
    outputStream.flush();
  }
}