#include <algorithm>
#include <csignal>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <set>
#include <sstream>

#include <locale.h>
#include <wchar.h>
#ifdef _WIN32
#include <windows.h>
#endif

#include "hexeditor.hh"

#ifdef _WIN32
static BOOL WINAPI ConsoleCtrlHandler(DWORD dwCtrlType) {
  if (dwCtrlType == CTRL_C_EVENT) return TRUE;
  return FALSE;
}
#endif

const std::vector<HexEditor::FileSignature> HexEditor::signatures = {
  {{ 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }, "PNG"},
  {{ 0xFF, 0xD8 }, "JPEG"},
  {{ 0x7F, 0x45, 0x4C, 0x46 }, "ELF"},
  {{ 0x4D, 0x5A }, "PE"},
  {{ 0x25, 0x50, 0x44, 0x46 }, "PDF"},
  {{ 0x67, 0x69, 0x6D, 0x70, 0x20, 0x78, 0x63, 0x66 }, "GIMP XCF"},
  {{ 0x1A, 0x45, 0xDF, 0xA3, 0x9F, 0x42, 0x86, 0x81, 0x01, 0x42,
     0xF7, 0x81, 0x01, 0x42, 0xF2, 0x81, 0x04, 0x42, 0xF3, 0x81,
     0x08, 0x42, 0x82, 0x84, 0x77, 0x65, 0x62, 0x6D, 0x42, 0x87,
     0x81, 0x04, 0x42, 0x85, 0x81, 0x02, 0x18, 0x53, 0x80, 0x67,
     0x01, 0x00, 0x00, 0x00, 0x01 }, "WEBM"},
  {{ 0x1A, 0x45, 0xDF, 0xA3, 0xA3, 0x42, 0x86, 0x81, 0x01, 0x42,
     0xF7, 0x81, 0x01, 0x42, 0xF2, 0x81, 0x04, 0x42, 0xF3, 0x81,
     0x08, 0x42, 0x82, 0x88, 0x6D, 0x61, 0x74, 0x72, 0x6F, 0x73,
     0x6B, 0x61, 0x42, 0x87, 0x81, 0x04, 0x42, 0x85, 0x81, 0x02,
     0x18, 0x53, 0x80, 0x67, 0x01, 0x00, 0x00, 0x00}, "Matroska"},
  {{ 0x52, 0x49, 0x46, 0x46 }, "Waveform"},
};

HexEditor::HexEditor(const std::string &filename)
  : curPos(0), dpOffset(0), bpr(16),
    statusMode(Status_Normal), modified(false),
    running(true),
    lastSearchDir(Direction_Forward),
    headerLen(0), headerType("") {
  // SIGINT (CTRL + C)を無効に
#ifdef _WIN32
  SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
#else
  std::signal(SIGINT, SIG_IGN);
#endif

  setlocale(LC_ALL, "");

  // ncurses
  initscr();
  clearok(stdscr, TRUE);
  cbreak();
  noecho();
  keypad(stdscr, TRUE);
  raw();
  start_color();

  init_pair(1, COLOR_BLACK, COLOR_WHITE); // カーソル
  init_pair(2, COLOR_BLACK, COLOR_GREEN); // 変更
  init_pair(3, COLOR_BLACK, COLOR_MAGENTA); // 普通
  init_pair(4, COLOR_BLACK, COLOR_CYAN); // コマンド
  init_pair(5, COLOR_BLACK, COLOR_YELLOW); // 検索
  init_pair(6, COLOR_BLACK, COLOR_YELLOW); // 検索ハイライト
  init_pair(7, COLOR_BLACK, COLOR_RED); // エラー
  init_pair(8, COLOR_WHITE, COLOR_BLACK); // デフォルト
  init_pair(9, COLOR_CYAN,  COLOR_BLACK); // ファイルヘッダー
  refresh();

  // ファイルをバッファーに読み込む
  std::ifstream file(filename, std::ios::binary);
  if (!file) {
    endwin();
    throw std::runtime_error("ファイルを開くに失敗");
  }

  buf.assign((std::istreambuf_iterator<char>(file)), {});
  file.close();

  if (buf.empty()) {
    endwin();
    throw std::runtime_error("ファイルが空です");
  }

  fname = filename;
  
  // ファイルヘッダー
  for (const auto &sig : signatures) {
    if (buf.size() >= sig.signature.size()) {
      bool match = true;
      for (size_t i = 0; i < sig.signature.size(); ++i) {
        if (buf[i] != sig.signature[i]) {
          match = false;
          break;
        }
      }
      
      if (match) {
        headerLen = sig.signature.size();
        headerType = sig.type;
        break;
      }
    }
  }

  // ウィンドウを作成する
  getmaxyx(stdscr, rows, cols);
  if (rows < 4 || cols < 20) {
    endwin();
    throw std::runtime_error("ターミナルが小さ過ぎます");
  }

  bpr = std::min<size_t>(16, (cols / 2 - 10) / 4);
  hexPanel = newwin(rows - 3, cols / 2, 1, 0);
  asciiPanel = newwin(rows - 3, cols / 2, 1, cols / 2);
  scrollok(hexPanel, TRUE);
  scrollok(asciiPanel, TRUE);
  wattrset(hexPanel, COLOR_PAIR(8));
  wattrset(asciiPanel, COLOR_PAIR(8));
}

HexEditor::~HexEditor() {
  delwin(hexPanel);
  delwin(asciiPanel);
  endwin();
}

void HexEditor::highlightcol(size_t i, size_t row, uint8_t byte) {
  wattron(hexPanel, COLOR_PAIR(1));
  mvwprintw(hexPanel, row, 10 + i * 3, "%02x", byte);
  wattroff(hexPanel, COLOR_PAIR(1));

  wattron(asciiPanel, COLOR_PAIR(1));
  mvwaddch(asciiPanel, row, i, std::isprint(byte) ? byte : '.');
  wattroff(asciiPanel, COLOR_PAIR(1));
}

void HexEditor::topbar() {
  int colorPair = 3;
  std::string status = "Hexagon 1.1.0";
  if (!headerType.empty()) status += " | FILETYPE: " + headerType;

  std::wstring wstatus(status.begin(), status.end());
  wattron(stdscr, COLOR_PAIR(colorPair));
  mvprintw(0, 0, "%s", status.c_str());
  for (int i = status.length(); i < cols; ++i) {
    mvaddch(0, i, ' ');
  }

  wattroff(stdscr, COLOR_PAIR(colorPair));
}

void HexEditor::statusbar() {
  int colorPair;
  switch (statusMode) {
    case Status_Replace: colorPair = 2; break;
    case Status_Normal: colorPair = 3; break;
    case Status_Command: colorPair = 4; break;
    case Status_Search: colorPair = 5; break;
    case Status_Error: colorPair = 7; break;
  }

  std::string status;
  if (statusMode == Status_Normal || statusMode == Status_Error) {
    status = "FILE: " + fname;
    status += " | OFFSET: 0x" + std::to_string(curPos);
    status += " | FILE SIZE: " + std::to_string(buf.size()) + " B";
    if (!lastSearch.empty()) {
      status += " | SEARCH: " + lastSearch;
    } else if (!lastHexSearch.empty()) {
      std::ostringstream hexSearch;
      for (size_t i = 0; i < lastHexSearch.size(); ++i) {
        if (i > 0) hexSearch << " ";
        hexSearch << std::hex << std::setfill('0') << std::setw(2)
          << (int)lastHexSearch[i];
      }
      status += " | SEARCH: " + hexSearch.str();
    }
    status += (modified ? " [+]" : "");
    if (statusMode == Status_Error) status += " | ERROR: " + statusText;
    else status += !statusText.empty() ? " | " + statusText : "";
  } else if (statusMode == Status_Command) {
    status = ":" + statusText;
  } else if (statusMode == Status_Search) {
    status = (lastSearchDir == Direction_Forward ? "/" : "?") + statusText;
  } else if (statusMode == Status_Replace) {
    status = "-- REPLACE --";
  }

  std::wstring wstatus(status.begin(), status.end());
  wattron(stdscr, COLOR_PAIR(colorPair));
  mvprintw(rows - 1, 0, "%s", status.c_str());
  for (int i = status.length(); i < cols; ++i) {
    mvaddch(rows - 1, i, ' ');
  }

  wattroff(stdscr, COLOR_PAIR(colorPair));
}

void HexEditor::render() {
  werase(hexPanel);
  werase(asciiPanel);

  getmaxyx(stdscr, rows, cols);
  size_t maxRows = rows - 3;

  topbar();

  std::set<size_t> matchBytes;
  if (!lastSearch.empty()) {
    for (size_t i = 0; i <= buf.size() - lastSearch.size(); ++i) {
      bool match = true;
      for (size_t j = 0; j < lastSearch.size(); ++j) {
        if (buf[i + j] != static_cast<uint8_t>(lastSearch[j])) {
          match = false;
          break;
        }
      }

      if (match) {
        for (size_t j = 0; j < lastSearch.size(); ++j) {
          matchBytes.insert(i + j);
        }
      }
    }
  } else if (!lastHexSearch.empty()) {
    for (size_t i = 0; i <= buf.size() - lastHexSearch.size(); ++i) {
      bool match = true;
      for (size_t j = 0; j < lastHexSearch.size(); ++j) {
        if (buf[i + j] != lastHexSearch[j]) {
          match = false;
          break;
        }
      }

      if (match) {
        for (size_t j = 0; j < lastHexSearch.size(); ++j) {
          matchBytes.insert(i + j);
        }
      }
    }
  }

  // HEXとASCIIの表示
  for (size_t row = 0; row < maxRows; ++row) {
    size_t offset = dpOffset + row * bpr;
    if (offset >= buf.size()) break;

    std::ostringstream hexLine, asciiLine;
    hexLine << std::hex << std::setfill('0') << std::setw(8) << offset << ": ";
    mvwprintw(hexPanel, row, 0, "%s", hexLine.str().c_str());

    // HEXとASCIIのデータ
    for (size_t i = 0; i < bpr && (offset + i) < buf.size(); ++i) {
      uint8_t byte = buf[offset + i];
      bool isMatch = matchBytes.count(offset + i) > 0;
      bool isHeader = (offset + i) < headerLen;

      if (offset + i == curPos) {
        highlightcol(i, row, byte);
      } else if (isHeader) {
        wattron(hexPanel, COLOR_PAIR(9));
        mvwprintw(hexPanel, row, 10 + i * 3, "%02x", byte);
        wattroff(hexPanel, COLOR_PAIR(9));

        wattron(asciiPanel, COLOR_PAIR(9));
        mvwaddch(asciiPanel, row, i, std::isprint(byte) ? byte : '.');
        wattroff(asciiPanel, COLOR_PAIR(9));
      } else if (isMatch) {
        wattron(hexPanel, COLOR_PAIR(6));
        mvwprintw(hexPanel, row, 10 + i * 3, "%02x", byte);
        wattroff(hexPanel, COLOR_PAIR(6));

        wattron(asciiPanel, COLOR_PAIR(6));
        mvwaddch(asciiPanel, row, i, std::isprint(byte) ? byte : '.');
        wattroff(asciiPanel, COLOR_PAIR(6));
      } else {
        wattron(hexPanel, COLOR_PAIR(8));
        mvwprintw(hexPanel, row, 10 + i * 3, "%02x", byte);
        wattroff(hexPanel, COLOR_PAIR(8));

        wattron(asciiPanel, COLOR_PAIR(8));
        mvwaddch(asciiPanel, row, i, std::isprint(byte) ? byte : '.');
        wattroff(asciiPanel, COLOR_PAIR(8));
      }
    }
  }

  statusbar();

  redrawwin(hexPanel);
  redrawwin(asciiPanel);
  wrefresh(hexPanel);
  wrefresh(asciiPanel);
  refresh();
}

void HexEditor::findNextMatch() {
  if (lastSearch.empty() && lastHexSearch.empty()) return;

  size_t searchSize = lastSearch.empty() ? lastHexSearch.size() : lastSearch.size();
  size_t startPos = curPos + 1;

  for (size_t i = startPos; i <= buf.size() - searchSize; ++i) {
    bool match = true;
    if (!lastSearch.empty()) {
      for (size_t j = 0; j < lastSearch.size(); ++j) {
        if (buf[i + j] != static_cast<uint8_t>(lastSearch[j])) {
          match = false;
          break;
        }
      }
    } else {
      for (size_t j = 0; j < lastHexSearch.size(); ++j) {
        if (buf[i + j] != lastHexSearch[j]) {
          match = false;
          break;
        }
      }
    }
    if (match) {
      curPos = i;
      dpOffset = curPos - (curPos % bpr);
      render();
      return;
    }
  }

  for (size_t i = 0; i < startPos && i <= buf.size() - searchSize; ++i) {
    bool match = true;
    if (!lastSearch.empty()) {
      for (size_t j = 0; j < lastSearch.size(); ++j) {
        if (buf[i + j] != static_cast<uint8_t>(lastSearch[j])) {
          match = false;
          break;
        }
      }
    } else {
      for (size_t j = 0; j < lastHexSearch.size(); ++j) {
        if (buf[i + j] != lastHexSearch[j]) {
          match = false;
          break;
        }
      }
    }
    if (match) {
      curPos = i;
      dpOffset = curPos - (curPos % bpr);
      render();
      return;
    }
  }
}

void HexEditor::findPrevMatch() {
  if (lastSearch.empty() && lastHexSearch.empty()) return;

  size_t searchSize = lastSearch.empty() ? lastHexSearch.size() : lastSearch.size();
  size_t startPos = curPos > 0 ? curPos - 1 : buf.size() - searchSize;

  for (size_t i = startPos + 1; i > 0; --i) {
    size_t pos = i - 1;
    if (pos > buf.size() - searchSize) continue;
    bool match = true;
    if (!lastSearch.empty()) {
      for (size_t j = 0; j < lastSearch.size(); ++j) {
        if (buf[pos + j] != static_cast<uint8_t>(lastSearch[j])) {
          match = false;
          break;
        }
      }
    } else {
      for (size_t j = 0; j < lastHexSearch.size(); ++j) {
        if (buf[pos + j] != lastHexSearch[j]) {
          match = false;
          break;
        }
      }
    }
    if (match) {
      curPos = pos;
      dpOffset = curPos - (curPos % bpr);
      render();
      return;
    }
  }

  for (size_t i = buf.size() - searchSize; i > startPos; --i) {
    bool match = true;
    if (!lastSearch.empty()) {
      for (size_t j = 0; j < lastSearch.size(); ++j) {
        if (buf[i + j] != static_cast<uint8_t>(lastSearch[j])) {
          match = false;
          break;
        }
      }
    } else {
      for (size_t j = 0; j < lastHexSearch.size(); ++j) {
        if (buf[i + j] != lastHexSearch[j]) {
          match = false;
          break;
        }
      }
    }
    if (match) {
      curPos = i;
      dpOffset = curPos - (curPos % bpr);
      render();
      return;
    }
  }
}

void HexEditor::handleCommand() {
  statusMode = Status_Command;
  statusText.clear();
  render();

  int ch;
  while ((ch = getch()) != '\n' && ch != 27) {
#ifdef _WIN32
    if (ch == KEY_BACKSPACE || ch == 8) {
#else
    if (ch == KEY_BACKSPACE || ch == 127) {
#endif
      if (!statusText.empty()) {
        statusText.pop_back();
      }
    } else if (ch >= 32 && ch <= 126) { // 書き込める文字
      statusText += ch;
    }

    render();
  }

  if (ch == 27) { // Esc
    statusMode = Status_Normal;
    statusText.clear();
    render();
    return;
  }

  bool isCommand = false;
  if (statusText == "w") {
    handleSave();
    isCommand = true;
  } else if (statusText == "q") {
    handleQuit(false);
    isCommand = true;
  } else if (statusText == "wq") {
    handleSave();
    handleQuit(false);
    isCommand = true;
  } else if (statusText == "q!") {
    handleQuit(true);
    isCommand = true;
  } else if (statusText == "wq!") {
    handleSave();
    handleQuit(true);
    isCommand = true;
  } else if (statusText == "noh") {
    lastSearch = "";
    isCommand = true;
  } else {
    statusMode = Status_Error;
    statusText.clear();
  }

  if (isCommand) {
    statusMode = Status_Normal;
    statusText.clear();
  }
  render();
}

void HexEditor::handleQuit(bool force) {
  if (force || (!force && !modified)) {
    running = false;
  } else {
    statusMode = Status_Error;
    statusText.clear();
    render();
  }
}

void HexEditor::handleSave() {
  std::ofstream file(fname, std::ios::binary);
  if (file) {
    file.write(reinterpret_cast<const char *>(buf.data()), buf.size());
    file.close();
    modified = false;
    statusText = "保存済み";
  }
}

void HexEditor::handleSearch() {
  statusMode = Status_Search;
  lastSearchDir = Direction_Forward;
  statusText.clear();
  render();

  int ch;
  while ((ch = getch()) != '\n' && ch != 27) {
#ifdef _WIN32
    if (ch == KEY_BACKSPACE || ch == 8) {
#else
    if (ch == KEY_BACKSPACE || ch == 127) {
#endif
      if (!statusText.empty()) statusText.pop_back();
    } else if (ch >= 32 && ch <= 126) { // 書き込める文字
      statusText += ch;
    }

    render();
  }

  if (ch == 27) { // Esc
    statusMode = Status_Normal;
    statusText.clear();
    render();
    return;
  }

  lastSearch.clear();
  lastHexSearch.clear();
  matchOff.clear();

  std::istringstream iss(statusText);
  std::string hexByte;
  bool isHexSearch = true;
  std::vector<uint8_t> hexSearch;
  while (iss >> hexByte) {
    if (hexByte.size() != 2 || !std::all_of(hexByte.begin(), hexByte.end(), [](char c) { return std::isxdigit(c); })) {
      isHexSearch = false;
      break;
    }
    try {
      hexSearch.push_back(static_cast<uint8_t>(std::stoul(hexByte, nullptr, 16)));
    } catch (...) {
      isHexSearch = false;
      break;
    }
  }

  if (isHexSearch && !hexSearch.empty()) { // HEX検索
    lastHexSearch = hexSearch;
    for (size_t i = curPos + 1; i <= buf.size() - lastHexSearch.size(); ++i) {
      bool match = true;
      for (size_t j = 0; j < lastHexSearch.size(); ++j) {
        if (buf[i + j] != lastHexSearch[j]) {
          match = false;
          break;
        }
      }
      if (match) {
        matchOff.push_back(i);
        curPos = i;
        dpOffset = curPos - (curPos % bpr);
        break;
      }
    }
  } else { // ASCII検索
    lastSearch = statusText;
    for (size_t i = curPos + 1; i <= buf.size() - lastSearch.size(); ++i) {
      bool match = true;
      for (size_t j = 0; j < lastSearch.size(); ++j) {
        if (buf[i + j] != static_cast<uint8_t>(lastSearch[j])) {
          match = false;
          break;
        }
      }
      if (match) {
        matchOff.push_back(i);
        curPos = i;
        dpOffset = curPos - (curPos % bpr);
        break;
      }
    }
  }

  statusMode = Status_Normal;
  statusText.clear();
  render();
}

void HexEditor::handleReverseSearch() {
  statusMode = Status_Search;
  lastSearchDir = Direction_Reverse;
  statusText.clear();
  render();

  int ch;
  while ((ch = getch()) != '\n' && ch != 27) {
#ifdef _WIN32
    if (ch == KEY_BACKSPACE || ch == 8) {
#else
    if (ch == KEY_BACKSPACE || ch == 127) {
#endif
      if (!statusText.empty()) statusText.pop_back();
    } else if (ch >= 32 && ch <= 126) {
      statusText += ch;
    }
    render();
  }

  if (ch == 27) { // Esc
    statusMode = Status_Normal;
    statusText.clear();
    render();
    return;
  }

  lastSearch.clear();
  lastHexSearch.clear();
  matchOff.clear();

  std::istringstream iss(statusText);
  std::string hexByte;
  bool isHexSearch = true;
  std::vector<uint8_t> hexSearch;
  while (iss >> hexByte) {
    if (hexByte.size() != 2 || !std::all_of(hexByte.begin(), hexByte.end(), [](char c) { return std::isxdigit(c); })) {
      isHexSearch = false;
      break;
    }
    try {
      hexSearch.push_back(static_cast<uint8_t>(std::stoul(hexByte, nullptr, 16)));
    } catch (...) {
      isHexSearch = false;
      break;
    }
  }

  if (isHexSearch && !hexSearch.empty()) {
    lastHexSearch = hexSearch;
    size_t startPos = curPos > 0 ? curPos - 1 : buf.size() - lastHexSearch.size();
    for (size_t i = startPos + 1; i > 0; --i) {
      size_t pos = i - 1;
      if (pos > buf.size() - lastHexSearch.size()) continue;
      bool match = true;
      for (size_t j = 0; j < lastHexSearch.size(); ++j) {
        if (buf[pos + j] != lastHexSearch[j]) {
          match = false;
          break;
        }
      }
      if (match) {
        matchOff.push_back(pos);
        curPos = pos;
        dpOffset = curPos - (curPos % bpr);
        break;
      }
    }
  } else {
    lastSearch = statusText;
    size_t startPos = curPos > 0 ? curPos - 1 : buf.size() - lastSearch.size();
    for (size_t i = startPos + 1; i > 0; --i) {
      size_t pos = i - 1;
      if (pos > buf.size() - lastSearch.size()) continue;
      bool match = true;
      for (size_t j = 0; j < lastSearch.size(); ++j) {
        if (buf[pos + j] != static_cast<uint8_t>(lastSearch[j])) {
          match = false;
          break;
        }
      }
      if (match) {
        matchOff.push_back(pos);
        curPos = pos;
        dpOffset = curPos - (curPos % bpr);
        break;
      }
    }
  }

  statusMode = Status_Normal;
  statusText.clear();
  render();
}

void HexEditor::handleReplace() {
  statusMode = Status_Replace;
  statusText.clear();
  render();

  std::string hexInput;
  int ch;
  while ((ch = getch()) != 27) {
    if (std::isxdigit(ch) && hexInput.size() < 2) {
      hexInput += ch;
      statusText = "REPLACE: " + hexInput;
      render();
    }

    if (hexInput.size() == 2) {
      uint8_t byte = std::stoul(hexInput, nullptr, 16);
      if (curPos < buf.size()) {
        undoStack.push_back({curPos, buf[curPos], byte});
        redoStack.clear();
        buf[curPos] = byte;
        modified = true;
        curPos = std::min(curPos + 1, buf.size() - 1);
      }

      hexInput.clear();
      statusText.clear();
      render();
    }
  }

  statusMode = Status_Normal;
  statusText.clear();
  render();
}

void HexEditor::undo() {
  if (undoStack.empty()) {
    statusMode = Status_Error;
    statusText = "既に一番古い変更です";
    render();
    return;
  }

  Edit edit = undoStack.back();
  undoStack.pop_back();
  redoStack.push_back({edit.offset, edit.newByte, edit.oldByte});
  buf[edit.offset] = edit.oldByte;
  if (undoStack.empty()) modified = false;
  else modified = true;
  curPos = edit.offset;
  dpOffset = curPos - (curPos % bpr);
  render();
}

void HexEditor::redo() {
  if (redoStack.empty()) {
    statusMode = Status_Error;
    statusText = "既に一番新しい変更です";
    render();
    return;
  }

  Edit edit = redoStack.back();
  redoStack.pop_back();
  undoStack.push_back({edit.offset, edit.newByte, edit.oldByte});
  buf[edit.offset] = edit.newByte;
  modified = true;
  curPos = edit.offset;
  dpOffset = curPos - (curPos % bpr);
  render();
}

void HexEditor::input() {
  int ch;

  while (running) {
    if (statusMode != Status_Normal && statusMode != Status_Error) continue;

    ch = getch();
    if ((ch == 'j' || ch == KEY_DOWN) && curPos + bpr < buf.size()) {
      curPos += bpr; // 下
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if ((ch == 'k' || ch == KEY_UP) && curPos >= bpr) {
      curPos -= bpr; // 上
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if ((ch == 'l' || ch == KEY_RIGHT) && curPos + 1 < buf.size()) {
      curPos += 1; // 右
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if ((ch == 'h' || ch == KEY_LEFT) && curPos > 0) {
      curPos -= 1; // 左
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if ((ch == 'J' || ch == KEY_PPAGE) && curPos >= bpr) {
      size_t pageSize = (rows - 3) * bpr;
      if (curPos >= pageSize) curPos -= pageSize;
      else curPos = 0;
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if ((ch == 'K' || ch == KEY_NPAGE) && curPos + bpr < buf.size()) {
      size_t pageSize = (rows - 3) * bpr;
      if (curPos + pageSize < buf.size()) {
        curPos += pageSize;
        dpOffset = curPos - ((rows - 4) * bpr);
      }
      else {
        curPos = buf.size() - 1;
        dpOffset = (buf.size() - 1) - ((rows - 4) * bpr);
        if (dpOffset > buf.size()) dpOffset = 0;
      }
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if (ch == '^' || ch == '0' || ch == KEY_HOME) {
      curPos = (curPos / bpr) * bpr;
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if (ch == '$' || ch == KEY_END) {
      size_t rowStart = (curPos / bpr) * bpr;
      curPos = std::min(rowStart + bpr - 1, buf.size() - 1);
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if (ch == 'i') {
      if (curPos - 1 > 0) curPos--;
      handleReplace();
    } else if (ch == 'r') {
      handleReplace();
    } else if (ch == 'a') {
      if (curPos + 1 < buf.size()) curPos++;
      handleReplace();
    } else if (ch == ':') {
      handleCommand();
    } else if (ch == '/') {
      handleSearch();
    } else if (ch == '?') {
      handleReverseSearch();
    } else if (ch == 'n') {
      if (lastSearchDir == Direction_Forward) findNextMatch();
      else findPrevMatch();
    } else if (ch == 'N') {
      if (lastSearchDir == Direction_Forward) findPrevMatch();
      else findNextMatch();
    } else if (ch == 'u') {
      undo();
    } else if (ch == 'R') {
      redo();
    } else if (ch == 'g') {
      if (getch() == 'g') {
        curPos = 0; // ファイルの一番上
        if (statusMode == Status_Error) statusMode = Status_Normal;
      }
    } else if (ch == 'G') {
      curPos = buf.size() - 1; // ファイルの一番下
      if (statusMode == Status_Error) statusMode = Status_Normal;
    } else if (ch == 'Z') {
      int next = getch();
      if (next == 'Q') {
        handleQuit(true);
        break;
      } else if (next == 'Z') {
        handleSave();
        handleQuit(true);
        break;
      } else if (next == 'S') {
        handleSave();
        if (statusMode == Status_Error) statusMode = Status_Normal;
      }
    }

    // 画面の動き
    int rows, cols;
    getmaxyx(stdscr, rows, cols);
    if (curPos < dpOffset) {
      dpOffset = curPos - (curPos % bpr);
    } else if (curPos >= dpOffset + (rows - 3) * bpr) {
      dpOffset = curPos - ((rows - 4) * bpr);
    }

    render();
  }
}

void HexEditor::run() {
  render();
  input();
}