/*
    * 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.CommandLine;
  import org.apache.commons.cli.DefaultParser;
  import org.apache.commons.cli.Option;
  import org.apache.commons.cli.Options;
  import org.apache.commons.cli.ParseException;
  import org.apache.commons.cli.help.HelpFormatter;
  import org.apache.commons.cli.help.OptionFormatter;
  import org.apache.commons.cli.help.TextHelpAppendable;
  
  import java.io.IOException;
  import java.io.PrintStream;
  import java.io.PrintWriter;
  import java.io.UncheckedIOException;
  import java.nio.charset.StandardCharsets;
  import java.util.Collection;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Optional;
  import java.util.concurrent.atomic.AtomicBoolean;
  import java.util.stream.Collectors;
  
  import dev.metaschema.cli.processor.command.CommandExecutionException;
  import dev.metaschema.cli.processor.command.ExtraArgument;
  import dev.metaschema.cli.processor.command.ICommand;
  import dev.metaschema.cli.processor.command.ICommandExecutor;
  import dev.metaschema.core.util.AutoCloser;
  import dev.metaschema.core.util.CollectionUtil;
  import dev.metaschema.core.util.ObjectUtils;
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.Nullable;
  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  
  /**
   * Records information about the command line options and called command
   * hierarchy.
   */
  public class CallingContext {
    @NonNull
    private final CLIProcessor cliProcessor;
    @NonNull
    private final List<Option> options;
    @NonNull
    private final List<ICommand> calledCommands;
    @Nullable
    private final ICommand targetCommand;
    @NonNull
    private final List<String> extraArgs;
  
    @SuppressFBWarnings(value = "CT_CONSTRUCTOR_THROW", justification = "Use of final fields")
    CallingContext(@NonNull CLIProcessor cliProcessor, @NonNull List<String> args) {
      this.cliProcessor = cliProcessor;
  
      @SuppressWarnings("PMD.LooseCoupling") // needed to support getLast
      LinkedList<ICommand> calledCommands = new LinkedList<>();
      List<Option> options = new LinkedList<>(CLIProcessor.OPTIONS);
      List<String> extraArgs = new LinkedList<>();
  
      AtomicBoolean endArgs = new AtomicBoolean();
      args.forEach(arg -> {
        if (endArgs.get() || arg.startsWith("-")) {
          extraArgs.add(arg);
        } else if ("--".equals(arg)) {
          endArgs.set(true);
        } else {
          ICommand command = calledCommands.isEmpty()
              ? cliProcessor.getTopLevelCommandsByName().get(arg)
              : calledCommands.getLast().getSubCommandByName(arg);
  
          if (command == null) {
            extraArgs.add(arg);
            endArgs.set(true);
          } else {
            calledCommands.add(command);
            options.addAll(command.gatherOptions());
          }
        }
      });
  
      this.calledCommands = CollectionUtil.unmodifiableList(calledCommands);
      this.targetCommand = calledCommands.peekLast();
      this.options = CollectionUtil.unmodifiableList(options);
      this.extraArgs = CollectionUtil.unmodifiableList(extraArgs);
    }
  
    /**
     * Get the command line processor instance that generated this calling context.
     *
     * @return the instance
     */
    @NonNull
   public CLIProcessor getCLIProcessor() {
     return cliProcessor;
   }
 
   /**
    * Get the command that was triggered by the CLI arguments.
    *
    * @return the command or {@code null} if no command was triggered
    */
   @Nullable
   public ICommand getTargetCommand() {
     return targetCommand;
   }
 
   /**
    * Get the options that are in scope for the current command context.
    *
    * @return the list of options
    */
   @NonNull
   List<Option> getOptionsList() {
     return options;
   }
 
   @NonNull
   List<ICommand> getCalledCommands() {
     return calledCommands;
   }
 
   /**
    * Get any left over arguments that were not consumed by CLI options.
    *
    * @return the list of remaining arguments, which may be empty
    */
   @NonNull
   List<String> getExtraArgs() {
     return extraArgs;
   }
 
   /**
    * Get the collections of in scope options as an options group.
    *
    * @return the options group
    */
   Options toOptions() {
     Options retval = new Options();
     for (Option option : getOptionsList()) {
       retval.addOption(option);
     }
     return retval;
   }
 
   /**
    * Check for --help and --version options before full parsing.
    * <p>
    * This is phase 1 of command processing.
    *
    * @return an exit status if help or version was requested, or empty to continue
    */
   @NonNull
   protected Optional<ExitStatus> checkHelpAndVersion() {
     Options phase1Options = new Options();
     phase1Options.addOption(CLIProcessor.HELP_OPTION);
     phase1Options.addOption(CLIProcessor.VERSION_OPTION);
 
     try {
       CommandLine cmdLine = new DefaultParser()
           .parse(phase1Options, getExtraArgs().toArray(new String[0]), true);
 
       if (cmdLine.hasOption(CLIProcessor.VERSION_OPTION)) {
         cliProcessor.showVersion();
         return ObjectUtils.notNull(Optional.of(ExitCode.OK.exit()));
       }
       if (cmdLine.hasOption(CLIProcessor.HELP_OPTION)) {
         showHelp();
         return ObjectUtils.notNull(Optional.of(ExitCode.OK.exit()));
       }
     } catch (ParseException ex) {
       String msg = ex.getMessage();
       return ObjectUtils.notNull(Optional.of(handleInvalidCommand(msg != null ? msg : "Invalid command")));
     }
     return ObjectUtils.notNull(Optional.empty());
   }
 
   /**
    * Parse all command line options.
    * <p>
    * This is phase 2 of command processing.
    *
    * @return the parsed command line
    * @throws ParseException
    *           if parsing fails
    */
   @NonNull
   protected CommandLine parseOptions() throws ParseException {
     return ObjectUtils.notNull(
         new DefaultParser().parse(toOptions(), getExtraArgs().toArray(new String[0])));
   }
 
   /**
    * Validate extra arguments for the target command.
    * <p>
    * This is phase 3 of command processing.
    *
    * @param cmdLine
    *          the parsed command line
    * @return an exit status if validation failed, or empty to continue
    */
   @NonNull
   protected Optional<ExitStatus> validateExtraArguments(@NonNull CommandLine cmdLine) {
     ICommand target = getTargetCommand();
     if (target == null) {
       return ObjectUtils.notNull(Optional.empty());
     }
     try {
       target.validateExtraArguments(this, cmdLine);
       return ObjectUtils.notNull(Optional.empty());
     } catch (InvalidArgumentException ex) {
       return ObjectUtils.notNull(Optional.of(handleError(
           ExitCode.INVALID_ARGUMENTS.exitMessage(ex.getLocalizedMessage()),
           cmdLine,
           true)));
     }
   }
 
   /**
    * Validate options for all called commands in the chain.
    * <p>
    * This is phase 4 of command processing.
    *
    * @param cmdLine
    *          the parsed command line
    * @return an exit status if validation failed, or empty to continue
    */
   @NonNull
   protected Optional<ExitStatus> validateCalledCommands(@NonNull CommandLine cmdLine) {
     for (ICommand cmd : getCalledCommands()) {
       try {
         cmd.validateOptions(this, cmdLine);
       } catch (InvalidArgumentException ex) {
         String msg = ex.getMessage();
         return ObjectUtils.notNull(Optional.of(handleInvalidCommand(msg != null ? msg : "Invalid argument")));
       }
     }
     return ObjectUtils.notNull(Optional.empty());
   }
 
   /**
    * Apply global options like --no-color and --quiet.
    * <p>
    * This is phase 5 of command processing.
    *
    * @param cmdLine
    *          the parsed command line
    */
   protected void applyGlobalOptions(@NonNull CommandLine cmdLine) {
     if (cmdLine.hasOption(CLIProcessor.NO_COLOR_OPTION)) {
       CLIProcessor.handleNoColor();
     }
     if (cmdLine.hasOption(CLIProcessor.QUIET_OPTION)) {
       CLIProcessor.handleQuiet();
     }
   }
 
   /**
    * Process the command identified by the CLI arguments.
    *
    * @return the result of processing the command
    */
   @NonNull
   public ExitStatus processCommand() {
     // Phase 1: Check help/version before full parsing
     Optional<ExitStatus> earlyExit = checkHelpAndVersion();
     if (earlyExit.isPresent()) {
       return earlyExit.get();
     }
 
     // Phase 2: Parse all options
     CommandLine cmdLine;
     try {
       cmdLine = parseOptions();
     } catch (ParseException ex) {
       String msg = ex.getMessage();
       return handleInvalidCommand(msg != null ? msg : "Parse error");
     }
 
     // Phase 3-4: Validate arguments and options
     Optional<ExitStatus> validationResult = validateExtraArguments(cmdLine)
         .or(() -> validateCalledCommands(cmdLine));
     if (validationResult.isPresent()) {
       return validationResult.get();
     }
 
     // Phase 5: Apply global options and execute
     applyGlobalOptions(cmdLine);
     return invokeCommand(cmdLine);
   }
 
   /**
    * Directly execute the logic associated with the command.
    *
    * @param cmdLine
    *          the command line information
    * @return the result of executing the command
    */
   @NonNull
   private ExitStatus invokeCommand(@NonNull CommandLine cmdLine) {
     ExitStatus retval;
     try {
       ICommand targetCommand = getTargetCommand();
       if (targetCommand == null) {
         retval = ExitCode.INVALID_COMMAND.exit();
       } else {
         ICommandExecutor executor = targetCommand.newExecutor(this, cmdLine);
         try {
           executor.execute();
           retval = ExitCode.OK.exit();
         } catch (CommandExecutionException ex) {
           retval = ex.toExitStatus();
         } catch (RuntimeException ex) {
           retval = ExitCode.RUNTIME_ERROR
               .exitMessage("Unexpected error occurred: " + ex.getLocalizedMessage())
               .withThrowable(ex);
         }
       }
     } catch (RuntimeException ex) {
       retval = ExitCode.RUNTIME_ERROR
           .exitMessage(String.format("An uncaught runtime error occurred. %s", ex.getLocalizedMessage()))
           .withThrowable(ex);
     }
 
     if (!ExitCode.OK.equals(retval.getExitCode())) {
       retval.generateMessage(cmdLine.hasOption(CLIProcessor.SHOW_STACK_TRACE_OPTION));
 
       if (ExitCode.INVALID_COMMAND.equals(retval.getExitCode())) {
         showHelp();
       }
     }
     return retval;
   }
 
   /**
    * Handle an error that occurred while executing the command.
    *
    * @param exitStatus
    *          the execution result
    * @param cmdLine
    *          the command line information
    * @param showHelp
    *          if {@code true} show the help information
    * @return the resulting exit status
    */
   @NonNull
   public ExitStatus handleError(
       @NonNull ExitStatus exitStatus,
       @NonNull CommandLine cmdLine,
       boolean showHelp) {
     exitStatus.generateMessage(cmdLine.hasOption(CLIProcessor.SHOW_STACK_TRACE_OPTION));
     if (showHelp) {
       showHelp();
     }
     return exitStatus;
   }
 
   /**
    * Generate the help message and exit status for an invalid command using the
    * provided message.
    *
    * @param message
    *          the error message
    * @return the resulting exit status
    */
   @NonNull
   public ExitStatus handleInvalidCommand(
       @NonNull String message) {
     showHelp();
 
     ExitStatus retval = ExitCode.INVALID_COMMAND.exitMessage(message);
     retval.generateMessage(false);
     return retval;
   }
 
   /**
    * Callback for providing a help header.
    *
    * @return the header or {@code null}
    */
   @Nullable
   private static String buildHelpHeader() {
     // TODO: build a suitable header
     return null;
   }
 
   /**
    * Callback for providing a help footer.
    *
    * @param terminalWidth
    *          the terminal width for text wrapping
    * @return the footer or an empty string if no subcommands
    */
   @NonNull
   private String buildHelpFooter(int terminalWidth) {
     ICommand targetCommand = getTargetCommand();
     Collection<ICommand> subCommands;
     if (targetCommand == null) {
       subCommands = cliProcessor.getTopLevelCommands();
     } else {
       subCommands = targetCommand.getSubCommands();
     }
 
     String retval;
     if (subCommands.isEmpty()) {
       retval = "";
     } else {
       StringBuilder builder = new StringBuilder(128);
       builder
           .append(System.lineSeparator())
           .append("The following are available commands:")
           .append(System.lineSeparator());
 
       int commandColWidth = subCommands.stream()
           .mapToInt(command -> command.getName().length())
           .max().orElse(0);
 
       // Calculate description column width: terminal - 3 (leading spaces) -
       // commandCol - 1 (space)
       int prefixWidth = 3 + commandColWidth + 1;
       int descWidth = Math.max(terminalWidth - prefixWidth, 20);
       String continuationIndent = " ".repeat(prefixWidth);
 
       for (ICommand command : subCommands) {
         String wrappedDesc = wrapText(command.getDescription(), descWidth, continuationIndent);
         builder.append(
             ansi()
                 .render(String.format("   @|bold %-" + commandColWidth + "s|@ %s%n",
                     command.getName(),
                     wrappedDesc)));
       }
       builder
           .append(System.lineSeparator())
           .append('\'')
           .append(cliProcessor.getExec())
           .append(" <command> --help' will show help on that specific command.")
           .append(System.lineSeparator());
       retval = builder.toString();
       assert retval != null;
     }
     return retval;
   }
 
   /**
    * Get the CLI syntax.
    *
    * @return the CLI syntax to display in help output
    */
   private String buildHelpCliSyntax() {
     StringBuilder builder = new StringBuilder(64);
     builder.append(cliProcessor.getExec());
 
     List<ICommand> calledCommands = getCalledCommands();
     if (!calledCommands.isEmpty()) {
       builder.append(calledCommands.stream()
           .map(ICommand::getName)
           .collect(Collectors.joining(" ", " ", "")));
     }
 
     // output calling commands
     ICommand targetCommand = getTargetCommand();
     if (targetCommand == null) {
       builder.append(" <command>");
     } else {
       builder.append(getSubCommands(targetCommand));
     }
 
     // output required options
     getOptionsList().stream()
         .filter(Option::isRequired)
         .forEach(option -> {
           builder
               .append(' ')
               .append(OptionUtils.toArgument(ObjectUtils.notNull(option)));
           if (option.hasArg()) {
             builder
                 .append('=')
                 .append(option.getArgName());
           }
         });
 
     // output non-required option placeholder
     builder.append(" [<options>]");
 
     // output extra arguments
     if (targetCommand != null) {
       // handle extra arguments
       builder.append(getExtraArguments(targetCommand));
     }
 
     String retval = builder.toString();
     assert retval != null;
     return retval;
   }
 
   @NonNull
   private static CharSequence getSubCommands(@NonNull ICommand targetCommand) {
     Collection<ICommand> subCommands = targetCommand.getSubCommands();
 
     StringBuilder builder = new StringBuilder();
     if (!subCommands.isEmpty()) {
       builder.append(' ');
       if (!targetCommand.isSubCommandRequired()) {
         builder.append('[');
       }
 
       builder.append("<command>");
 
       if (!targetCommand.isSubCommandRequired()) {
         builder.append(']');
       }
     }
     return builder;
   }
 
   @NonNull
   private static CharSequence getExtraArguments(@NonNull ICommand targetCommand) {
     StringBuilder builder = new StringBuilder();
     for (ExtraArgument argument : targetCommand.getExtraArguments()) {
       builder.append(' ');
       if (!argument.isRequired()) {
         builder.append('[');
       }
 
       builder.append('<')
           .append(argument.getName())
           .append('>');
 
       if (argument.getNumber() > 1) {
         builder.append("...");
       }
 
       if (!argument.isRequired()) {
         builder.append(']');
       }
     }
     return builder;
   }
 
   private static final int DEFAULT_TERMINAL_WIDTH = 80;
 
   /**
    * Get the terminal width from environment or use a default.
    * <p>
    * This method avoids native terminal detection which triggers Java 21+
    * restricted method warnings. Instead, it uses the COLUMNS environment variable
    * which is set by most shells.
    *
    * @return the terminal width in characters
    */
   private static int getTerminalWidth() {
     String columns = System.getenv("COLUMNS");
     if (columns != null) {
       try {
         int width = Integer.parseInt(columns);
         if (width > 0) {
           return width;
         }
       } catch (NumberFormatException e) {
         // Ignore and use default
       }
     }
     return DEFAULT_TERMINAL_WIDTH;
   }
 
   /**
    * Wrap text to fit within the specified width, with proper indentation for
    * continuation lines.
    *
    * @param text
    *          the text to wrap
    * @param maxWidth
    *          the maximum line width
    * @param indent
    *          the indentation string for continuation lines
    * @return the wrapped text
    * @throws IllegalArgumentException
    *           if maxWidth is less than or equal to zero, or if the indent length
    *           is greater than or equal to maxWidth
    */
   @NonNull
   static String wrapText(@NonNull String text, int maxWidth, @NonNull String indent) {
     if (maxWidth <= 0) {
       throw new IllegalArgumentException("maxWidth must be positive, got: " + maxWidth);
     }
     if (indent.length() >= maxWidth) {
       throw new IllegalArgumentException(
           "indent length (" + indent.length() + ") must be less than maxWidth (" + maxWidth + ")");
     }
     if (text.length() <= maxWidth) {
       return text;
     }
 
     StringBuilder result = new StringBuilder(text.length() + 32);
     int lineStart = 0;
     boolean firstLine = true;
     int effectiveWidth = maxWidth;
 
     while (lineStart < text.length()) {
       if (!firstLine) {
         result.append(System.lineSeparator()).append(indent);
         effectiveWidth = maxWidth - indent.length();
       }
 
       int remaining = text.length() - lineStart;
       if (remaining <= effectiveWidth) {
         result.append(text.substring(lineStart));
         break;
       }
 
       // Find last space within the width limit
       int lineEnd = lineStart + effectiveWidth;
       int lastSpace = text.lastIndexOf(' ', lineEnd);
 
       if (lastSpace <= lineStart) {
         // No space found, force break at width
         result.append(text, lineStart, lineEnd);
         lineStart = lineEnd; // Continue from break point (no space to skip)
       } else {
         result.append(text, lineStart, lastSpace);
         lineStart = lastSpace + 1; // Skip the space
       }
       firstLine = false;
     }
 
     return ObjectUtils.notNull(result.toString());
   }
 
   /**
    * Output the help text to the console.
    *
    * @throws UncheckedIOException
    *           if an error occurs while writing help output
    */
   public void showHelp() {
     PrintStream out = cliProcessor.getOutputStream();
     // Get terminal width from environment variable COLUMNS, or default to 80
     // This avoids native terminal detection which triggers Java 21+ warnings
     int terminalWidth = getTerminalWidth();
 
     try (PrintWriter writer = new PrintWriter(
         AutoCloser.preventClose(out),
         true,
         StandardCharsets.UTF_8)) {
       TextHelpAppendable appendable = new TextHelpAppendable(writer);
       appendable.setMaxWidth(Math.max(terminalWidth, 50));
 
       HelpFormatter formatter = HelpFormatter.builder()
           .setHelpAppendable(appendable)
           .setOptionFormatBuilder(OptionFormatter.builder().setOptArgSeparator("="))
           .setShowSince(false)
           .get();
 
       try {
         // Print main help (syntax, header, options) through the formatter
         formatter.printHelp(
             buildHelpCliSyntax(),
             buildHelpHeader(),
             toOptions(),
             "", // Empty footer - we print it directly below
             false);
       } catch (IOException ex) {
         throw new UncheckedIOException("Failed to write help output", ex);
       }
 
       // Print footer directly to bypass TextHelpAppendable's text wrapping,
       // which doesn't account for ANSI escape sequence lengths
       writer.print(buildHelpFooter(terminalWidth));
       writer.flush();
     }
   }
 }