terminal.hpp

#pragma once
 
#include <cctype>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <utility>
 
#include "libxr_rw.hpp"
#include "libxr_string.hpp"
#include "ramfs.hpp"
#include "semaphore.hpp"
#include "stack.hpp"
 
namespace LibXR
{
 
template <size_t READ_BUFF_SIZE = 32, size_t MAX_LINE_SIZE = READ_BUFF_SIZE,
          size_t MAX_ARG_NUMBER = 5, size_t MAX_HISTORY_NUMBER = 5>
class Terminal
{
 private:
  static constexpr char CLEAR_ALL[] =
      "\033[2J\033[1H";  
  static constexpr char CLEAR_LINE[] =
      "\033[2K\r";  
  static constexpr char CLEAR_BEHIND[] =
      "\033[K";  
  static constexpr char KEY_RIGHT[] = "\033[C";  
  static constexpr char KEY_LEFT[] = "\033[D";   
  static constexpr char KEY_SAVE[] = "\033[s";   
  static constexpr char KEY_LOAD[] = "\033[u";   
  static constexpr char DELETE_CHAR[] =
      "\b \b";  
 
  char* StrchrRev(char* str, char c)
  {
    auto len = strlen(str);
    for (int i = static_cast<int>(len - 1); i >= 0; i--)
    {
      if (str[i] == c)
      {
        return str + i;
      }
    }
    return nullptr;
  }
 
 public:
  enum class Mode : uint8_t
  {
    CRLF = 0,  
    LF = 1,    
    CR = 2     
  };
 
  Terminal(LibXR::RamFS& ramfs, RamFS::Dir* current_dir = nullptr,
           ReadPort* read_port = STDIO::read_, WritePort* write_port = STDIO::write_,
           Mode MODE = Mode::CRLF)
      : read_status_(ReadOperation::OperationPollingStatus::READY),
        write_status_(WriteOperation::OperationPollingStatus::READY),
        MODE(MODE),
        write_op_(write_status_),
        read_port_(read_port),
        write_port_(write_port),
        write_stream_(write_port_, write_op_),
        ramfs_(ramfs),
        current_dir_(current_dir ? current_dir : &ramfs_.root_),
        input_line_(MAX_LINE_SIZE + 1),
        history_(MAX_HISTORY_NUMBER)
  {
    ASSERT(read_port != nullptr);
    ASSERT(write_port != nullptr);
    ASSERT(read_port->Readable());
    ASSERT(write_port->Writable());
 
    if (write_port == STDIO::write_)
    {
      if (STDIO::write_mutex_ == nullptr)
      {
        STDIO::write_mutex_ = new LibXR::Mutex();
      }
 
      write_mutex_ = STDIO::write_mutex_;
      STDIO::write_stream_ = &write_stream_;
    }
    else
    {
      write_mutex_ = new LibXR::Mutex();
    }
  }
 
  ReadOperation::OperationPollingStatus read_status_;
  WriteOperation::OperationPollingStatus write_status_;
 
  const Mode MODE;                  
  WriteOperation write_op_;         
  ReadPort* read_port_;             
  WritePort* write_port_;           
  WritePort::Stream write_stream_;  
 
  LibXR::Mutex* write_mutex_ = nullptr;  
 
  RamFS& ramfs_;                    
  char read_buff_[READ_BUFF_SIZE];  
 
  size_t request_read_size_ = 0;
  RamFS::Dir* current_dir_;        
  uint8_t flag_ansi_ = 0;          
  int offset_ = 0;                 
  Stack<char> input_line_;         
  char* arg_tab_[MAX_ARG_NUMBER];  
  size_t arg_number_ = 0;          
  Queue<LibXR::String<MAX_LINE_SIZE>> history_;  
  int history_index_ = -1;                       
  bool linefeed_flag_ = false;                   
 
  void LineFeed()
  {
    if (MODE == Mode::CRLF)
    {
      write_stream_ << ConstRawData("\r\n");
    }
    else if (MODE == Mode::LF)
    {
      write_stream_ << ConstRawData('\n');
    }
    else if (MODE == Mode::CR)
    {
      write_stream_ << ConstRawData('\r');
    }
  }
 
  void UpdateDisplayPosition()
  {
    write_stream_ << ConstRawData(KEY_SAVE) << ConstRawData(CLEAR_BEHIND)
                  << ConstRawData(&input_line_[input_line_.Size() + offset_], -offset_)
                  << ConstRawData(KEY_LOAD);
  }
 
  bool CanDisplayChar() { return input_line_.EmptySize() > 1; }
 
  bool CanDeleteChar() { return input_line_.Size() + offset_ > 0; }
 
  void AddCharToInputLine(char data)
  {
    if (offset_ == 0)
    {
      input_line_.Push(data);
    }
    else
    {
      input_line_.Insert(data, input_line_.Size() + offset_);
    }
    input_line_[input_line_.Size()] = '\0';
  }
 
  void DisplayChar(char data)
  {
    bool use_history = false;
 
    if (history_index_ >= 0)
    {
      CopyHistoryToInputLine();
      use_history = true;
    }
 
    if (CanDisplayChar())
    {
      AddCharToInputLine(data);
      if (use_history)
      {
        ShowHistory();
      }
      else
      {
        write_stream_ << ConstRawData(input_line_[input_line_.Size() - 1 + offset_]);
      }
      if (offset_ != 0)
      {
        UpdateDisplayPosition();
      }
    }
  }
 
  void RemoveCharFromInputLine()
  {
    if (offset_ == 0)
    {
      input_line_.Pop();
    }
    else
    {
      input_line_.Delete(input_line_.Size() + offset_ - 1);
    }
    input_line_[input_line_.Size()] = '\0';
  }
 
  void DeleteChar()
  {
    bool use_history = false;
 
    if (history_index_ >= 0)
    {
      CopyHistoryToInputLine();
      use_history = true;
    }
 
    if (CanDeleteChar())
    {
      RemoveCharFromInputLine();
      if (use_history)
      {
        ShowHistory();
      }
      else
      {
        write_stream_ << ConstRawData(DELETE_CHAR);
      }
 
      if (offset_ != 0)
      {
        UpdateDisplayPosition();
      }
    }
  }
 
  void ShowHeader()
  {
    write_stream_ << ConstRawData(ramfs_.root_->name, strlen(ramfs_.root_->name));
    if (current_dir_ == &ramfs_.root_)
    {
      write_stream_ << ConstRawData(":/");
    }
    else
    {
      write_stream_ << ConstRawData(":") << ConstRawData(current_dir_->data_.name);
    }
 
    write_stream_ << ConstRawData("$ ");
  }
 
  void ClearLine() { write_stream_ << ConstRawData(CLEAR_LINE); }
 
  void Clear() { write_stream_ << ConstRawData(CLEAR_ALL); }
 
  void ShowHistory()
  {
    ClearLine();
    ShowHeader();
    offset_ = 0;
    if (history_index_ >= 0)
    {
      write_stream_ << ConstRawData(history_[-history_index_ - 1].Raw(),
                                    history_[-history_index_ - 1].Length());
    }
    else
    {
      write_stream_ << ConstRawData(&input_line_[0], input_line_.Size());
    }
  }
 
  void CopyHistoryToInputLine()
  {
    input_line_.Reset();
    for (size_t i = 0; i < history_[-history_index_ - 1].Length(); i++)
    {
      input_line_.Push(history_[-history_index_ - 1][i]);
    }
    history_index_ = -1;
    offset_ = 0;
  }
 
  void AddHistory()
  {
    input_line_.Push('\0');
 
    if (history_.EmptySize() == 0)
    {
      history_.Pop();
    }
    history_.Push(*reinterpret_cast<String<MAX_LINE_SIZE>*>(&input_line_[0]));
  }
 
  void GetArgs()
  {
    for (int i = 0; input_line_[i] != '\0'; i++)
    {
      if (input_line_[i] == ' ')
      {
        input_line_[i] = '\0';
      }
      else if (i == 0 || input_line_[i - 1] == '\0')
      {
        if (arg_number_ >= MAX_ARG_NUMBER)
        {
          return;
        }
        arg_tab_[arg_number_++] = &input_line_[i];
      }
    }
  }
 
  RamFS::Dir* Path2Dir(char* path)
  {
    if (path == nullptr)
    {
      return nullptr;
    }
 
    size_t index = 0;
    RamFS::Dir* dir = current_dir_;
 
    if (*path == '/')
    {
      index++;
      dir = &ramfs_.root_;
    }
 
    for (size_t i = 0; i < MAX_LINE_SIZE; i++)
    {
      auto tmp = strchr(path + index, '/');
      if (tmp == nullptr)
      {
        return dir->FindDir(path + index);
      }
      else if (tmp == path + index)
      {
        return nullptr;
      }
      else
      {
        tmp[0] = '\0';
        dir = dir->FindDir(path + index);
        tmp[0] = '/';
        index += tmp - path + 1;
        if (path[index] == '\0' || dir == nullptr)
        {
          return dir;
        }
      }
    }
 
    return nullptr;
  }
 
  RamFS::File* Path2File(char* path)
  {
    if (path == nullptr)
    {
      return nullptr;
    }
 
    auto name = StrchrRev(path, '/');
 
    if (name == nullptr)
    {
      return current_dir_->FindFile(path);
    }
 
    if (name[1] == '\0')
    {
      return nullptr;
    }
 
    *name = '\0';
    RamFS::Dir* dir = Path2Dir(path);
    *name = '/';
    if (dir != nullptr)
    {
      return dir->FindFile(name + 1);
    }
    else
    {
      return nullptr;
    }
  }
 
  void ExecuteCommand()
  {
    AddHistory();
 
    GetArgs();
 
    if (arg_number_ < 1 || arg_number_ > MAX_ARG_NUMBER)
    {
      return;
    }
 
    if (strcmp(arg_tab_[0], "cd") == 0)
    {
      RamFS::Dir* dir = Path2Dir(arg_tab_[1]);
      if (dir != nullptr)
      {
        current_dir_ = dir;
      }
      LineFeed();
      return;
    }
 
    if (strcmp(arg_tab_[0], "ls") == 0)
    {
      auto ls_fun = [&](RBTree<const char*>::Node<RamFS::FsNode>& item)
      {
        switch (item->type)
        {
          case RamFS::FsNodeType::DIR:
            write_stream_ << ConstRawData("d ");
            break;
          case RamFS::FsNodeType::FILE:
            write_stream_ << ConstRawData("f ");
            break;
          case RamFS::FsNodeType::DEVICE:
            write_stream_ << ConstRawData("c ");
            break;
          case RamFS::FsNodeType::STORAGE:
            write_stream_ << ConstRawData("b ");
            break;
          default:
            write_stream_ << ConstRawData("? ");
            break;
        }
        write_stream_ << ConstRawData(item.data_.name);
        this->LineFeed();
        return ErrorCode::OK;
      };
 
      current_dir_->data_.rbt.Foreach<RamFS::FsNode>(ls_fun);
      return;
    }
 
    auto ans = Path2File(arg_tab_[0]);
    if (ans == nullptr)
    {
      write_stream_ << ConstRawData("Command not found.");
      LineFeed();
      return;
    }
 
    if ((*ans)->type != RamFS::FileType::EXEC)
    {
      write_stream_ << ConstRawData("Not an executable file.");
      LineFeed();
      return;
    }
    write_stream_.Commit();
    write_mutex_->Unlock();
    (*ans)->Run(arg_number_, arg_tab_);
    write_mutex_->Lock();
  }
 
  void Parse(RawData& raw_data)
  {
    char* buff = static_cast<char*>(raw_data.addr_);
    for (size_t i = 0; i < raw_data.size_; i++)
    {
      HandleCharacter(buff[i]);
    }
  }
 
  void HandleAnsiCharacter(char data)
  {
    if (flag_ansi_ == 1)
    {
      if (isprint(data))
      {
        flag_ansi_++;
      }
      else
      {
        flag_ansi_ = 0;
      }
    }
    else if (flag_ansi_ == 2)
    {
      switch (data)
      {
        case 'A':
          if (history_index_ < int(history_.Size()) - 1)
          {
            history_index_++;
            ShowHistory();
          }
          break;
        case 'B':
          if (history_index_ >= 0)
          {
            history_index_--;
            ShowHistory();
          }
          break;
        case 'C':
          if (history_index_ >= 0)
          {
            CopyHistoryToInputLine();
            ShowHistory();
          }
          if (offset_ < 0)
          {
            offset_++;
            write_stream_ << ConstRawData(KEY_RIGHT, sizeof(KEY_RIGHT) - 1);
          }
 
          break;
        case 'D':
          if (history_index_ >= 0)
          {
            CopyHistoryToInputLine();
            ShowHistory();
          }
          if (offset_ + input_line_.Size() > 0)
          {
            offset_--;
            write_stream_ << ConstRawData(KEY_LEFT, sizeof(KEY_LEFT) - 1);
          }
          break;
        default:
          break;
      }
 
      flag_ansi_ = 0;
    }
  }
 
  void AutoComplete()
  {
    /* skip space */
    char* path = &input_line_[0];
    while (*path == ' ')
    {
      path++;
    }
 
    /* find last '/' in first argument */
    char *tmp = path, *path_end = path;
 
    while (*tmp != ' ' && *tmp != '\0')
    {
      if (*tmp == '/')
      {
        path_end = tmp;
      }
      tmp++;
    }
 
    /* return if not need complete */
    if (tmp - &input_line_[0] != static_cast<int>(input_line_.Size() + offset_))
    {
      return;
    }
 
    /* get start of prefix */
    char* prefix_start = nullptr;
    RamFS::Dir* dir = nullptr;
 
    if (path_end == path)
    {
      dir = current_dir_;
      prefix_start = path_end;
    }
    else
    {
      prefix_start = path_end + 1;
    }
 
    /* find dir*/
    if (dir == nullptr)
    {
      *path_end = '\0';
      dir = Path2Dir(path);
      *path_end = '/';
      if (dir == nullptr)
      {
        return;
      }
    }
 
    /* prepre for match */
    RBTree<const char*>::Node<RamFS::FsNode>* ans_node = nullptr;
    uint32_t number = 0;
    size_t same_char_number = 0;
 
    if (*prefix_start == '/')
    {
      prefix_start++;
    }
 
    int prefix_len = static_cast<int>(tmp - prefix_start);
 
    auto foreach_fun_find = [&](RBTree<const char*>::Node<RamFS::FsNode>& node)
    {
      if (strncmp(node->name, prefix_start, prefix_len) == 0)
      {
        ans_node = &node;
        number++;
      }
 
      return ErrorCode::OK;
    };
 
    /* start match */
    (*dir)->rbt.Foreach<RamFS::FsNode>(foreach_fun_find);
 
    if (number == 0)
    {
      return;
    }
    else if (number == 1)
    {
      auto name_len = strlen(ans_node->data_.name);
      for (size_t i = 0; i < name_len - prefix_len; i++)
      {
        DisplayChar(ans_node->data_.name[i + prefix_len]);
      }
    }
    else
    {
      ans_node = nullptr;
      LineFeed();
 
      auto foreach_fun_show = [&](RBTree<const char*>::Node<RamFS::FsNode>& node)
      {
        if (strncmp(node->name, prefix_start, prefix_len) == 0)
        {
          auto name_len = strlen(node->name);
          write_stream_ << ConstRawData(node->name, name_len);
          this->LineFeed();
          if (ans_node == nullptr)
          {
            ans_node = &node;
            same_char_number = name_len;
            return ErrorCode::OK;
          }
 
          for (size_t i = 0; i < name_len; i++)
          {
            if (node->name[i] != ans_node->data_.name[i])
            {
              same_char_number = i;
              break;
            }
          }
 
          if (same_char_number > name_len)
          {
            name_len = same_char_number;
          }
 
          ans_node = &node;
        }
 
        return ErrorCode::OK;
      };
 
      (*dir)->rbt.Foreach<RamFS::FsNode>(foreach_fun_show);
 
      ShowHeader();
      write_stream_ << ConstRawData(&input_line_[0], input_line_.Size());
 
      for (size_t i = 0; i < same_char_number - prefix_len; i++)
      {
        DisplayChar(ans_node->data_.name[i + prefix_len]);
      }
    }
  }
 
  void HandleControlCharacter(char data)
  {
    if (data != '\r' && data != '\n')
    {
      linefeed_flag_ = false;
    }
 
    switch (data)
    {
      case '\n':
      case '\r':
        if (linefeed_flag_)
        {
          linefeed_flag_ = false;
          return;
        }
        if (history_index_ >= 0)
        {
          CopyHistoryToInputLine();
        }
        LineFeed();
        if (input_line_.Size() > 0)
        {
          ExecuteCommand();
          arg_number_ = 0;
        }
        ShowHeader();
        input_line_.Reset();
        input_line_[0] = '\0';
        offset_ = 0;
        break;
      case 0x7f:
      case '\b':
        DeleteChar();
        break;
      case '\t':
        AutoComplete();
        break;
      case '\033':
        flag_ansi_ = 1;
        break;
      default:
        break;
    }
  }
 
  void HandleCharacter(char data)
  {
    if (flag_ansi_)
    {
      HandleAnsiCharacter(data);
    }
    else if (isprint(data))
    {
      DisplayChar(data);
    }
    else
    {
      HandleControlCharacter(data);
    }
  }
 
  static void ThreadFun(Terminal* term)
  {
    Semaphore read_sem, write_sem;
    ReadOperation op(read_sem);
 
    term->write_op_ = WriteOperation(write_sem, 10);
 
    while (true)
    {
      term->request_read_size_ = LibXR::min(term->read_port_->Size(), READ_BUFF_SIZE);
      auto buffer = RawData(term->read_buff_, term->request_read_size_);
 
      if ((*term->read_port_)(buffer, op) == ErrorCode::OK &&
          term->request_read_size_ > 0)
      {
        term->write_mutex_->Lock();
        term->Parse(buffer);
        term->write_stream_.Commit();
        term->write_mutex_->Unlock();
      }
    }
  }
 
  static void TaskFun(Terminal* term)
  {
    ReadOperation op(term->read_status_);
 
    auto start_read = [&]()
    {
      term->request_read_size_ =
          LibXR::min(LibXR::max(1u, term->read_port_->Size()), READ_BUFF_SIZE);
      auto buffer = RawData(term->read_buff_, term->request_read_size_);
      (*term->read_port_)(buffer, op);
    };
 
    while (true)
    {
      switch (term->read_status_)
      {
        case ReadOperation::OperationPollingStatus::READY:
        {
          term->request_read_size_ =
              LibXR::min(LibXR::max(1u, term->read_port_->Size()), READ_BUFF_SIZE);
          auto buffer = RawData(term->read_buff_, term->request_read_size_);
          (*term->read_port_)(buffer, op);
          continue;
        }
        case ReadOperation::OperationPollingStatus::RUNNING:
          return;
        case ReadOperation::OperationPollingStatus::DONE:
        {
          term->write_mutex_->Lock();
          auto buffer = RawData(term->read_buff_, term->request_read_size_);
          term->Parse(buffer);
          term->write_stream_.Commit();
          term->write_mutex_->Unlock();
          start_read();
          return;
        }
        case ReadOperation::OperationPollingStatus::ERROR:
        {
          start_read();
          return;
        }
      }
    }
  }
};
}  // namespace LibXR