text: /*
   * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice, this
   *    list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  #include "VirtualConsole.h"
  #include <AK/String.h>
  #include <Kernel/Arch/i386/CPU.h>
  #include <Kernel/Devices/KeyboardDevice.h>
  #include <Kernel/Heap/kmalloc.h>
  #include <LibBareMetal/IO.h>
  #include <LibBareMetal/StdLib.h>
  
  namespace Kernel {
  
  static u8* s_vga_buffer;
  static VirtualConsole* s_consoles[6];
  static int s_active_console;
  
  void VirtualConsole::get_vga_cursor(u8& row, u8& column)
  {
      u16 value;
      IO::out8(0x3d4, 0x0e);
      value = IO::in8(0x3d5) << 8;
      IO::out8(0x3d4, 0x0f);
      value |= IO::in8(0x3d5);
      row = value / columns();
      column = value % columns();
  }
  
  void VirtualConsole::flush_vga_cursor()
  {
      u16 value = m_current_vga_start_address + (m_cursor_row * columns() + m_cursor_column);
      IO::out8(0x3d4, 0x0e);
      IO::out8(0x3d5, MSB(value));
      IO::out8(0x3d4, 0x0f);
      IO::out8(0x3d5, LSB(value));
  }
  
  void VirtualConsole::initialize()
  {
      s_vga_buffer = (u8*)0xc00b8000;
      memset(s_consoles, 0, sizeof(s_consoles));
      s_active_console = -1;
  }
  
  void VirtualConsole::set_graphical(bool graphical)
  {
      if (graphical)
          set_vga_start_row(0);
  
      m_graphical = graphical;
  }
  
  VirtualConsole::VirtualConsole(unsigned index, InitialContents initial_contents)
      : TTY(4, index)
      , m_index(index)
  {
      sprintf(m_tty_name, "/dev/tty%u", m_index);
      set_size(80, 25);
      m_horizontal_tabs = static_cast<u8*>(kmalloc_eternal(columns()));
      for (unsigned i = 0; i < columns(); ++i)
          m_horizontal_tabs[i] = (i % 8) == 0;
      // Rightmost column is always last tab on line.
      m_horizontal_tabs[columns() - 1] = 1;
  
      s_consoles[index] = this;
      m_buffer = (u8*)kmalloc_eternal(rows() * columns() * 2);
      if (initial_contents == AdoptCurrentVGABuffer) {
          memcpy(m_buffer, s_vga_buffer, rows() * columns() * 2);
          get_vga_cursor(m_cursor_row, m_cursor_column);
      } else {
          u16* line_mem = reinterpret_cast<u16*>(m_buffer);
          for (u16 i = 0; i < rows() * columns(); ++i)
              line_mem[i] = 0x0720;
      }
  }
  
  VirtualConsole::~VirtualConsole()
  {
      ASSERT_NOT_REACHED();
  }
  
  void VirtualConsole::clear()
  {
      u16* linemem = m_active ? (u16*)s_vga_buffer : (u16*)m_buffer;
      for (u16 i = 0; i < rows() * columns(); ++i)
          linemem[i] = 0x0720;
      if (m_active)
          set_vga_start_row(0);
      set_cursor(0, 0);
  }
  
  void VirtualConsole::switch_to(unsigned index)
  {
      if ((int)index == s_active_console)
          return;
      ASSERT(index < 6);
      ASSERT(s_consoles[index]);
  
      InterruptDisabler disabler;
      if (s_active_console != -1) {
          auto* active_console = s_consoles[s_active_console];
          // We won't know how to switch away from a graphical console until we
          // can set the video mode on our own. Just stop anyone from trying for
          // now.
          if (active_console->is_graphical())
              return;
          active_console->set_active(false);
      }
      dbg() << "VC: Switch to " << index << " (" << s_consoles[index] << ")";
      s_active_console = index;
      s_consoles[s_active_console]->set_active(true);
      Console::the().set_implementation(s_consoles[s_active_console]);
  }
  
  void VirtualConsole::set_active(bool b)
  {
      if (b == m_active)
          return;
  
      InterruptDisabler disabler;
  
      m_active = b;
      if (!m_active) {
          memcpy(m_buffer, m_current_vga_window, rows() * columns() * 2);
          KeyboardDevice::the().set_client(nullptr);
          return;
      }
  
      memcpy(s_vga_buffer, m_buffer, rows() * columns() * 2);
      set_vga_start_row(0);
      flush_vga_cursor();
  
      KeyboardDevice::the().set_client(this);
  }
  
  inline bool is_valid_parameter_character(u8 ch)
  {
      return ch >= 0x30 && ch <= 0x3f;
  }
  
  inline bool is_valid_intermediate_character(u8 ch)
  {
      return ch >= 0x20 && ch <= 0x2f;
  }
  
  inline bool is_valid_final_character(u8 ch)
  {
      return ch >= 0x40 && ch <= 0x7e;
  }
  
  enum class VGAColor : u8 {
      Black = 0,
      Blue,
      Green,
      Cyan,
      Red,
      Magenta,
      Brown,
      LightGray,
      DarkGray,
      BrightBlue,
      BrightGreen,
      BrightCyan,
      BrightRed,
      BrightMagenta,
      Yellow,
      White,
  };
  
  enum class ANSIColor : u8 {
      Black = 0,
      Red,
      Green,
      Brown,
      Blue,
      Magenta,
      Cyan,
      LightGray,
      DarkGray,
      BrightRed,
      BrightGreen,
      Yellow,
      BrightBlue,
      BrightMagenta,
      BrightCyan,
      White,
  };
  
  static inline VGAColor ansi_color_to_vga(ANSIColor color)
  {
      switch (color) {
      case ANSIColor::Black:
          return VGAColor::Black;
      case ANSIColor::Red:
          return VGAColor::Red;
      case ANSIColor::Brown:
          return VGAColor::Brown;
      case ANSIColor::Blue:
          return VGAColor::Blue;
      case ANSIColor::Magenta:
          return VGAColor::Magenta;
      case ANSIColor::Green:
          return VGAColor::Green;
      case ANSIColor::Cyan:
          return VGAColor::Cyan;
      case ANSIColor::LightGray:
          return VGAColor::LightGray;
      case ANSIColor::DarkGray:
          return VGAColor::DarkGray;
      case ANSIColor::BrightRed:
          return VGAColor::BrightRed;
      case ANSIColor::BrightGreen:
          return VGAColor::BrightGreen;
      case ANSIColor::Yellow:
          return VGAColor::Yellow;
      case ANSIColor::BrightBlue:
          return VGAColor::BrightBlue;
      case ANSIColor::BrightMagenta:
          return VGAColor::BrightMagenta;
      case ANSIColor::BrightCyan:
          return VGAColor::BrightCyan;
      case ANSIColor::White:
          return VGAColor::White;
      }
      ASSERT_NOT_REACHED();
      return VGAColor::LightGray;
  }
  
  static inline u8 ansi_color_to_vga(u8 color)
  {
      return (u8)ansi_color_to_vga((ANSIColor)color);
  }
  
  void VirtualConsole::escape$m(const Vector<unsigned>& params)
  {
      for (auto param : params) {
          switch (param) {
          case 0:
              // Reset
              m_current_attribute = 0x07;
              break;
          case 1:
              // Bold
              m_current_attribute |= 8;
              break;
          case 30:
          case 31:
          case 32:
          case 33:
          case 34:
          case 35:
          case 36:
          case 37:
              // Foreground color
              m_current_attribute &= ~0x7;
              m_current_attribute |= ansi_color_to_vga(param - 30);
              break;
          case 40:
          case 41:
          case 42:
          case 43:
          case 44:
          case 45:
          case 46:
          case 47:
              // Background color
              m_current_attribute &= ~0x70;
              m_current_attribute |= ansi_color_to_vga(param - 30) << 8;
              break;
          }
      }
  }
  
  void VirtualConsole::escape$s(const Vector<unsigned>&)
  {
      m_saved_cursor_row = m_cursor_row;
      m_saved_cursor_column = m_cursor_column;
  }
  
  void VirtualConsole::escape$u(const Vector<unsigned>&)
  {
      set_cursor(m_saved_cursor_row, m_saved_cursor_column);
  }
  
  void VirtualConsole::escape$H(const Vector<unsigned>& params)
  {
      unsigned row = 1;
      unsigned col = 1;
      if (params.size() >= 1)
          row = params[0];
      if (params.size() >= 2)
          col = params[1];
      set_cursor(row - 1, col - 1);
  }
  
  void VirtualConsole::escape$A(const Vector<unsigned>& params)
  {
      int num = 1;
      if (params.size() >= 1)
          num = params[0];
      int new_row = (int)m_cursor_row - num;
      if (new_row < 0)
          new_row = 0;
      set_cursor(new_row, m_cursor_column);
  }
  
  void VirtualConsole::escape$D(const Vector<unsigned>& params)
  {
      int num = 1;
      if (params.size() >= 1)
          num = params[0];
      int new_column = (int)m_cursor_column - num;
      if (new_column < 0)
          new_column = 0;
      set_cursor(m_cursor_row, new_column);
  }
  
  void VirtualConsole::escape$J(const Vector<unsigned>& params)
  {
      int mode = 0;
      if (params.size() >= 1)
          mode = params[0];
      switch (mode) {
      case 0:
          // FIXME: Clear from cursor to end of screen.
          ASSERT_NOT_REACHED();
          break;
      case 1:
          // FIXME: Clear from cursor to beginning of screen.
          ASSERT_NOT_REACHED();
          break;
      case 2:
          clear();
          break;
      case 3:
          // FIXME: <esc>[3J should also clear the scrollback buffer.
          clear();
          break;
      }
  }
  
  void VirtualConsole::execute_escape_sequence(u8 final)
  {
      auto paramparts = String::copy(m_parameters).split(';');
      Vector<unsigned> params;
      for (auto& parampart : paramparts) {
          bool ok;
          unsigned value = parampart.to_uint(ok);
          if (!ok) {
              // FIXME: Should we do something else?
              return;
          }
          params.append(value);
      }
      switch (final) {
      case 'A':
          escape$A(params);
          break;
      case 'D':
          escape$D(params);
          break;
      case 'H':
          escape$H(params);
          break;
      case 'J':
          escape$J(params);
          break;
      case 'm':
          escape$m(params);
          break;
      case 's':
          escape$s(params);
          break;
      case 'u':
          escape$u(params);
          break;
      default:
          break;
      }
  
      m_parameters.clear();
      m_intermediates.clear();
  }
  
  void VirtualConsole::clear_vga_row(u16 row)
  {
      u16* linemem = (u16*)&m_current_vga_window[row * 160];
      for (u16 i = 0; i < columns(); ++i)
          linemem[i] = 0x0720;
  }
  
  void VirtualConsole::scroll_up()
  {
      if (m_cursor_row == (rows() - 1)) {
          if (m_active) {
              if (m_vga_start_row >= 160) {
                  memcpy(s_vga_buffer, m_current_vga_window + 160, (rows() - 1) * columns() * 2);
                  set_vga_start_row(0);
                  clear_vga_row(24);
              } else {
                  set_vga_start_row(m_vga_start_row + 1);
                  clear_vga_row(24);
              }
          } else {
              memmove(m_buffer, m_buffer + 160, 160 * 24);
              u16* linemem = (u16*)&m_buffer[24 * 160];
              for (u16 i = 0; i < columns(); ++i)
                  linemem[i] = 0x0720;
          }
      } else {
          ++m_cursor_row;
      }
      m_cursor_column = 0;
  }
  
  void VirtualConsole::set_cursor(unsigned row, unsigned column)
  {
      ASSERT(row < rows());
      ASSERT(column < columns());
      m_cursor_row = row;
      m_cursor_column = column;
      if (m_active)
          flush_vga_cursor();
  }
  
  void VirtualConsole::put_character_at(unsigned row, unsigned column, u8 ch)
  {
      ASSERT(row < rows());
      ASSERT(column < columns());
      u16 cur = (row * 160) + (column * 2);
      if (m_active) {
          u16 cur = (row * 160) + (column * 2);
          m_current_vga_window[cur] = ch;
          m_current_vga_window[cur + 1] = m_current_attribute;
      } else {
          m_buffer[cur] = ch;
          m_buffer[cur + 1] = m_current_attribute;
      }
  }
  
  void VirtualConsole::on_char(u8 ch)
  {
      // ignore writes in graphical mode
      if (m_graphical)
          return;
  
      switch (m_escape_state) {
      case ExpectBracket:
          if (ch == '[')
              m_escape_state = ExpectParameter;
          else
              m_escape_state = Normal;
          return;
      case ExpectParameter:
          if (is_valid_parameter_character(ch)) {
              m_parameters.append(ch);
              return;
          }
          m_escape_state = ExpectIntermediate;
          [[fallthrough]];
      case ExpectIntermediate:
          if (is_valid_intermediate_character(ch)) {
              m_intermediates.append(ch);
              return;
          }
          m_escape_state = ExpectFinal;
          [[fallthrough]];
      case ExpectFinal:
          if (is_valid_final_character(ch)) {
              m_escape_state = Normal;
              execute_escape_sequence(ch);
              return;
          }
          m_escape_state = Normal;
          return;
      case Normal:
          break;
      }
  
      switch (ch) {
      case '\0':
          return;
      case '\033':
          m_escape_state = ExpectBracket;
          return;
      case 8: // Backspace
          if (m_cursor_column) {
              set_cursor(m_cursor_row, m_cursor_column - 1);
              put_character_at(m_cursor_row, m_cursor_column, ' ');
              return;
          }
          break;
      case '\a':
          // FIXME: Bell!
          return;
      case '\t': {
          for (unsigned i = m_cursor_column; i < columns(); ++i) {
              if (m_horizontal_tabs[i]) {
                  set_cursor(m_cursor_row, i);
                  return;
              }
          }
          return;
      }
      case '\n':
          scroll_up();
          set_cursor(m_cursor_row, m_cursor_column);
          return;
      }
  
      put_character_at(m_cursor_row, m_cursor_column, ch);
  
      ++m_cursor_column;
      if (m_cursor_column >= columns())
          scroll_up();
      set_cursor(m_cursor_row, m_cursor_column);
  }
  
  void VirtualConsole::on_key_pressed(KeyboardDevice::Event key)
  {
      // ignore keyboard in graphical mode
      if (m_graphical)
          return;
  
      if (!key.is_press())
          return;
      if (key.ctrl()) {
          if (key.character >= 'a' && key.character <= 'z') {
              emit(key.character - 'a' + 1);
              return;
          } else if (key.character == '\\') {
              emit(0x1c);
              return;
          }
      }
      emit(key.character);
  }
  
  void VirtualConsole::on_sysconsole_receive(u8 ch)
  {
      InterruptDisabler disabler;
      auto old_attribute = m_current_attribute;
      m_current_attribute = 0x03;
      on_char(ch);
      m_current_attribute = old_attribute;
  }
  
  ssize_t VirtualConsole::on_tty_write(const u8* data, ssize_t size)
  {
      InterruptDisabler disabler;
      for (ssize_t i = 0; i < size; ++i)
          on_char(data[i]);
      return size;
  }
  
  StringView VirtualConsole::tty_name() const
  {
      return m_tty_name;
  }
  
  void VirtualConsole::echo(u8 ch)
  {
      if (should_echo_input()) {
          on_tty_write(&ch, 1);
      }
  }
  
  void VirtualConsole::set_vga_start_row(u16 row)
  {
      m_vga_start_row = row;
      m_current_vga_start_address = row * columns();
      m_current_vga_window = s_vga_buffer + row * 160;
      IO::out8(0x3d4, 0x0c);
      IO::out8(0x3d5, MSB(m_current_vga_start_address));
      IO::out8(0x3d4, 0x0d);
      IO::out8(0x3d5, LSB(m_current_vga_start_address));
  }
  
  }
  