/*******************************************************************************
    * Copyhacked (H) 2012-2025.
    * This program and the accompanying materials
    * are made available under no term at all, use it like
    * you want, but share and discuss it
    * every time possible with every body.
    *
    * Contributors:
    *      ron190 at ymail dot com - initial implementation
   *******************************************************************************/
  package com.jsql.view.swing.terminal;
  
  import com.jsql.util.LogLevelUtil;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.logging.log4j.LogManager;
  import org.apache.logging.log4j.Logger;
  
  import javax.swing.*;
  import javax.swing.text.BadLocationException;
  import javax.swing.text.Element;
  import java.awt.event.InputEvent;
  import java.awt.event.KeyAdapter;
  import java.awt.event.KeyEvent;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.atomic.AtomicReference;
  
  /**
   * Keyboard key processing for terminal.
   */
  public class KeyAdapterTerminal extends KeyAdapter {
      
      /**
       * Log4j logger sent to view.
       */
      private static final Logger LOGGER = LogManager.getRootLogger();
  
      /**
       * Terminal where keys are processed.
       */
      private final AbstractExploit terminal;
  
      /**
       * Past commands entered by user.
       */
      private final List<String> commandsHistory = new ArrayList<>();
  
      /**
       * Current position in array of past commands.
       */
      private int indexCommandsHistory = 0;
  
      /**
       * Create a keyboard processor for a terminal.
       * @param terminal Terminal where keys are processed
       */
      public KeyAdapterTerminal(AbstractExploit terminal) {
          this.terminal = terminal;
      }
  
      @Override
      public void keyPressed(KeyEvent keyEvent) {
          try {
              var root = this.terminal.getDocument().getDefaultRootElement();
              int caretPosition = this.terminal.getCaretPosition();
              int lineNumber = this.terminal.getLineOfOffset(caretPosition);  // Get current line
  
              if (this.terminal.getIsEdited().get()) {  // Cancel every user keyboard input if another command has just been sent
                  keyEvent.consume();
                  return;
              }
      
              // Get user input
              var command = new AtomicReference<>(StringUtils.EMPTY);
              command.set(
                  this.terminal.getText(
                      root.getElement(lineNumber).getStartOffset(),
                      root.getElement(lineNumber).getEndOffset() - root.getElement(lineNumber).getStartOffset()
                  )
                  .replace(this.terminal.getPrompt(), StringUtils.EMPTY)
                  .trim()
              );
      
              if (keyEvent.getKeyCode() == KeyEvent.VK_ENTER) {  // Validate user input ; disable text editing
                  this.runCommand(keyEvent, command);
              } else if (keyEvent.getKeyCode() == KeyEvent.VK_UP) {  // Get previous command
                  this.appendPreviousCommand(keyEvent, root, lineNumber, command);
              } else if (keyEvent.getKeyCode() == KeyEvent.VK_DOWN) {  // Get next command
                  this.appendNextCommand(keyEvent, root, lineNumber, command);
              } else if (keyEvent.getKeyCode() == KeyEvent.VK_LEFT || keyEvent.getKeyCode() == KeyEvent.VK_BACK_SPACE) {  // Go to the left until prompt
                  this.moveCaretLeft(keyEvent, caretPosition, lineNumber);
              } else if (keyEvent.getKeyCode() == KeyEvent.VK_HOME) {  // Get to the beginning of the line
                  this.moveCaretHome(keyEvent, lineNumber);
              } else if (this.isKeyNotAllowed(keyEvent, caretPosition)) {
                  keyEvent.consume();
              } else if (keyEvent.getKeyCode() == KeyEvent.VK_C && (keyEvent.getModifiersEx() & InputEvent.CTRL_DOWN_MASK) != 0) {
                  this.cancelCommand(keyEvent);
              }
          } catch (BadLocationException e) {
             LOGGER.log(LogLevelUtil.CONSOLE_JAVA, e, e);
         }
     }
 
     private boolean isKeyNotAllowed(KeyEvent keyEvent, int caretPosition) {
         return
             // Cancel the select all shortcut Ctrl+A
             keyEvent.getKeyCode() == KeyEvent.VK_A && (keyEvent.getModifiersEx() & InputEvent.CTRL_DOWN_MASK) != 0
             // Cancel the *beep* sound if deleting while at the end of line
             || keyEvent.getKeyCode() == KeyEvent.VK_DELETE && caretPosition == this.terminal.getDocument().getLength()
             || (keyEvent.getModifiersEx() & InputEvent.CTRL_DOWN_MASK) != 0 && (keyEvent.getModifiersEx() & InputEvent.SHIFT_DOWN_MASK) != 0
             || keyEvent.getKeyCode() == KeyEvent.VK_PAGE_UP
             || keyEvent.getKeyCode() == KeyEvent.VK_PAGE_DOWN
             || keyEvent.getKeyCode() == KeyEvent.VK_TAB;
     }
 
     private void cancelCommand(KeyEvent keyEvent) {
         keyEvent.consume();
         this.terminal.append("\n");
         this.terminal.reset();
     }
 
     private void moveCaretHome(KeyEvent keyEvent, int lineNumber) throws BadLocationException {
         keyEvent.consume();
         this.terminal.setCaretPosition(this.terminal.getLineStartOffset(lineNumber) + this.terminal.getPrompt().length());
     }
 
     private void moveCaretLeft(KeyEvent keyEvent, int caretPosition, int lineNumber) throws BadLocationException {
         int newCaretPosition = caretPosition - this.terminal.getLineStartOffset(lineNumber);
         if (newCaretPosition <= this.terminal.getPrompt().length()) {
             keyEvent.consume();
         }
     }
 
     private void appendNextCommand(
         KeyEvent keyEvent,
         Element root,
         int lineNumber,
         AtomicReference<String> command
     ) throws BadLocationException {
         keyEvent.consume();
    
         if (this.indexCommandsHistory < this.commandsHistory.size()) {
             this.indexCommandsHistory++;
         }
    
         if (!this.commandsHistory.isEmpty() && this.indexCommandsHistory < this.commandsHistory.size()) {
             this.terminal.getDocument().remove(
                 root.getElement(lineNumber).getStartOffset() + this.terminal.getPrompt().length(),
                 command.get().length() - 1
             );
    
             this.terminal.append(this.commandsHistory.get(this.indexCommandsHistory));
             this.terminal.setCaretPosition(this.terminal.getDocument().getLength());
         }
     }
 
     private void appendPreviousCommand(
         KeyEvent keyEvent,
         Element root,
         int lineNumber,
         AtomicReference<String> command
     ) throws BadLocationException {
         keyEvent.consume();
    
         if (this.indexCommandsHistory > 0) {
             this.indexCommandsHistory--;
         }
    
         if (!this.commandsHistory.isEmpty()) {
             if (
                 this.commandsHistory.size() > 1
                 && this.indexCommandsHistory == this.commandsHistory.size() - 1
                 && StringUtils.isNotEmpty(command.get())
             ) {
                 this.indexCommandsHistory--;
             }
    
             this.terminal.getDocument().remove(
                 root.getElement(lineNumber).getStartOffset() + this.terminal.getPrompt().length(),
                 command.get().length() - 1
             );
    
             this.terminal.append(this.commandsHistory.get(this.indexCommandsHistory));
             this.terminal.setCaretPosition(this.terminal.getDocument().getLength());
         }
     }
 
     private void runCommand(KeyEvent keyEvent, AtomicReference<String> command) {
         this.terminal.getIsEdited().set(true);
         keyEvent.consume();
         this.terminal.setEditable(false);
    
         // Populate cmd list for key up/down
         if (StringUtils.isNotEmpty(command.get())) {
             this.commandsHistory.add(command.get());
             this.indexCommandsHistory = this.commandsHistory.size();
         }
 
         new SwingWorker<>() {  // Thread to give back control to user (SwingUtilities does not)
             @Override
             protected Object doInBackground() {
                 // Inside Swing thread to avoid flickering
                 Thread.currentThread().setName("SwingWorkerKeyAdapterTerminal");
 
                 AbstractExploit terminalCommand = KeyAdapterTerminal.this.terminal;
                 terminalCommand.append("\n");
                 
                 if (StringUtils.isNotEmpty(command.get())) {
                     terminalCommand.setCaretPosition(terminalCommand.getDocument().getLength());
                     terminalCommand.action(
                         command.get(),
                         terminalCommand.getUuidShell(),
                         terminalCommand.getUrlShell(),
                         terminalCommand.loginPassword
                     );
                 } else {
                     terminalCommand.reset();
                 }
                 return null;
             }
         }.execute();
     }
 }