#include "TextEditor.h"

namespace LiveCoder {

void TextEditor::UpdateLog() {

if (logIndex != -1) {

nowCursor = log[logIndex].cursor;

buffer = log[logIndex].buffer;

lineOffset = log[logIndex].lineOffset;

std::vector<TextEditorLog>::iterator ite = log.begin() + logIndex;

log.erase(ite, log.end());

logIndex = -1;

SnapShot();

}

}

void TextEditor::ScrollDown() {

// 下方向にスクロール

if (nowCursor.col > lineOffset + maxLineNum - 1) {

lineOffset ++;

}

}

void TextEditor::ScrollUp() {

// 上方向にスクロール

if (nowCursor.col < lineOffset) {

lineOffset --;

}

}

void TextEditor::PageUp() {

UpdateLog();

if (nowCursor.col - maxLineNum >= 0) {

nowCursor.col -= maxLineNum;

lineOffset -= maxLineNum;

if (lineOffset < 0)

lineOffset = 0;

} else {

}

}

void TextEditor::MoveHead() {

UpdateLog();

nowCursor.col = 0;

nowCursor.row = 0;

lineOffset = 0;

}

void TextEditor::MoveTail() {

UpdateLog();

nowCursor.col = buffer.size() - 1;

nowCursor.row = buffer[buffer.size() - 1].length();

lineOffset = nowCursor.col - maxLineNum + 1;

if (lineOffset < 0)

lineOffset = 0;

}

void TextEditor::PageDown() {

UpdateLog();

if (nowCursor.col + maxLineNum < buffer.size()) {

nowCursor.col += maxLineNum;

lineOffset += maxLineNum;

}

}

void TextEditor::MoveCursor(enum EditorCursorMoveType type) {

UpdateLog();

switch (type) {

case ECMT_DOWN:

if (buffer.size() > nowCursor.col + 1) {

nowCursor.col ++;

if (buffer[nowCursor.col].length() < nowCursor.row) {

nowCursor.row = buffer[nowCursor.col].length();

}

ScrollDown();

}

break;

case ECMT_UP:

if (0 <= nowCursor.col - 1) {

nowCursor.col --;

if (buffer[nowCursor.col].length() < nowCursor.row) {

nowCursor.row = buffer[nowCursor.col].length();

}

ScrollUp();

}

break;

case ECMT_LEFT:

if (0 <= nowCursor.row - 1) {

nowCursor.row --;

} else { // nowCursor.row == 0

if (nowCursor.col > 0) {

nowCursor.col --;

nowCursor.row = buffer[nowCursor.col].length();

ScrollUp();

}

}

break;

case ECMT_RIGHT:

if (buffer[nowCursor.col].length() >= nowCursor.row + 1) {

nowCursor.row ++;

} else { // nowCursor.rowが右端

if (nowCursor.col + 1 < buffer.size()) {

nowCursor.col ++;

nowCursor.row = 0;

ScrollDown();

}

}

break;

}

}

std::string TextEditor::ToString() {

std::string str;

if (logIndex == -1) {

for (int i = 0; i < buffer.size(); i ++)

str += buffer[i] + '\n';

} else {

for (int i = 0; i < log[logIndex].buffer.size(); i ++)

str += log[logIndex].buffer[i] + '\n';

}

return str;

}

TextEditorPtrBuffer TextEditor::GetText() {

TextEditorPtrBuffer buf;

if (logIndex == -1) {

for (int i = 0; i < buffer.size(); i ++) {

buf.push_back(&buffer[i]);

}

} else {

int offset = log[logIndex].lineOffset;

for (int i = 0; i < log[logIndex].buffer.size(); i ++) {

buf.push_back(&log[logIndex].buffer[i]);

}

}

return buf;

}

TextEditorPtrBuffer TextEditor::GetVisibleText() {

TextEditorPtrBuffer buf;

if (logIndex == -1) {

for (int i = lineOffset; i < lineOffset + maxLineNum && i < buffer.size(); i ++) {

buf.push_back(&buffer[i]);

}

} else {

int offset = log[logIndex].lineOffset;

for (int i = offset; i < offset + maxLineNum && i < log[logIndex].buffer.size(); i ++) {

buf.push_back(&log[logIndex].buffer[i]);

}

}

return buf;

}

EditorCursor TextEditor::GetCursorPosition() {

if (logIndex == -1) {

EditorCursor cursor;

cursor.row = nowCursor.row;

cursor.col = nowCursor.col - lineOffset;

return cursor;

} else {

EditorCursor cursor;

cursor.row = log[logIndex].cursor.row;

cursor.col = log[logIndex].cursor.col - log[logIndex].lineOffset;

return cursor;

}

}

void TextEditor::Copy() {

if (!IsSelectMode())

return;

EditorCursor selectStart_ = selectStart;

EditorCursor selectEnd_ = nowCursor;

if (selectStart_.col > selectEnd_.col)

std::swap(selectStart_, selectEnd_);

copyBuffer.clear();

if (selectStart_.col == selectEnd_.col) { // single line

int start = selectStart_.row;

int end = selectEnd_.row;

if (start > end)

std::swap(start, end);

copyBuffer.push_back(buffer[selectStart_.col].substr(start, end - start));

} else { // multi line

for (int i = selectStart_.col; i <= selectEnd_.col; i ++) {

std::cout << buffer[i];

if (i == selectStart_.col) {

int start = selectStart_.row;

int end = buffer[i].length();

copyBuffer.push_back(buffer[i].substr(start, end - start));

} else if (i < selectEnd_.col) {

copyBuffer.push_back(buffer[i]);

} else {

int start = 0;

int end = selectEnd_.row;

copyBuffer.push_back(buffer[i].substr(start, end - start));

}

}

}

}

void TextEditor::DeleteSelectedArea() {

if (!IsSelectMode())

return;

SnapShot();

EditorCursor selectStart_ = selectStart;

EditorCursor selectEnd_ = nowCursor;

if (selectStart_.col > selectEnd_.col)

std::swap(selectStart_, selectEnd_);

if (selectStart_.col == selectEnd_.col) { // single line

if (selectStart_.row > selectEnd_.row)

std::swap(selectStart_, selectEnd_);

int start = selectStart_.row;

int end = selectEnd_.row;

buffer[selectStart_.col].erase(start, end - start);

} else { // multi line

for (int i = selectStart_.col; i <= selectEnd_.col; i ++) {

std::cout << buffer[i];

if (i == selectStart_.col) {

int start = selectStart_.row;

int end = buffer[i].length();

buffer[i].erase(start, end - start);

} else if (i < selectEnd_.col) {

// とりあえず何もしない

// copyBuffer.push_back(buffer[i]);

} else {

int start = 0;

int end = selectEnd_.row;

buffer[i].erase(start, end - start);

}

}

buffer[selectStart_.col] += buffer[selectEnd_.col];

buffer.erase(buffer.begin() + selectStart_.col + 1, buffer.begin() + selectEnd_.col + 1);

}

nowCursor = selectStart_;

if (nowCursor.col < lineOffset) {

lineOffset = nowCursor.col - 1;

}

EndSelect();

}

void TextEditor::Paste() {

SnapShot();

for (int i = 0; i < copyBuffer.size(); i ++) {

if (i > 0)

InsertCharacter('\n', false, false);

for (int j = 0; j < copyBuffer[i].length(); j ++) {

InsertCharacter(copyBuffer[i][j], false, false);

}

}

}

EditorCursor TextEditor::GetSelectStart() {

EditorCursor cursor;

cursor.row = selectStart.row;

cursor.col = selectStart.col - lineOffset;

return cursor;

}

void TextEditor::BeginSelect() {

selectMode = true;

selectStart = nowCursor;

}

void TextEditor::EndSelect() {

selectMode = false;

}

void TextEditor::SnapShot() {

log.push_back(TextEditorLog(nowCursor, buffer, lineOffset));

if (log.size() > 1000) {

log.erase(log.begin(), log.begin() + 1);

}

}

void TextEditor::Backspace() {

SnapShot();

UpdateLog();

if (nowCursor.row == 0) {

if (nowCursor.col > 0) {

nowCursor.row = buffer[nowCursor.col - 1].length();

buffer[nowCursor.col - 1] += buffer[nowCursor.col];

std::vector<std::string>::iterator ite = buffer.begin() + nowCursor.col;

buffer.erase(ite);

nowCursor.col --;

ScrollUp();

}

} else {

buffer[nowCursor.col].erase(nowCursor.row - 1, 1);

nowCursor.row --;

}

}

void TextEditor::Delete() {

SnapShot();

UpdateLog();

if (nowCursor.row == buffer[nowCursor.col].length()) {

if (nowCursor.col < buffer.size() - 1) {

buffer[nowCursor.col] += buffer[nowCursor.col + 1];

std::vector<std::string>::iterator ite = buffer.begin() + nowCursor.col + 1;

buffer.erase(ite);

}

} else {

buffer[nowCursor.col].erase(nowCursor.row, 1);

}

}

void TextEditor::Home() {

int v = 0;

for (int i = 0; i < buffer[nowCursor.col].length(); i ++)

if (buffer[nowCursor.col][i] != ' ')

break;

else

v ++;

nowCursor.row = v;

}

void TextEditor::End() {

nowCursor.row = buffer[nowCursor.col].length();

}

void TextEditor::Undo() {

EndSelect();

if (logIndex == -1) {

logIndex = log.size() - 1;

} else {

if (logIndex > 0)

logIndex --;

}

}

void TextEditor::Redo() {

EndSelect();

if (logIndex == -1) {

} else {

if (logIndex < log.size() - 1) {

logIndex ++;

} else

logIndex = -1;

}

}

void TextEditor::Save(std::string filename) {

FILE *fp = fopen(filename.c_str(), "wt");

if (fp != NULL){

fprintf(fp, ToString().c_str());

fclose(fp);

}

}

void TextEditor::ClearBuffer() {

buffer.clear();

buffer.push_back("");

nowCursor = EditorCursor();

lineOffset = 0;

logIndex = -1;

log.clear();

// log.push_back(TextEditorLog(nowCursor, buffer, lineOffset));

}

void TextEditor::Load(std::string filename) {

FILE *fp = fopen(filename.c_str(), "rt");

EndSelect();

ClearBuffer();

if (fp != NULL){

char buf[1024];

buffer.clear();

while (fgets(buf, 1024, fp) != NULL){

int l = strlen(buf);

if (buf[l - 1] == '\n')

buf[l - 1] = '\0';

buffer.push_back(buf);

}

fclose(fp);

}

}

void TextEditor::InsertCharacter(char ch, bool historyEnable, bool autoIndent) {

if (historyEnable) {

SnapShot();

}

UpdateLog();

if (ch == '\n') {

std::string a = buffer[nowCursor.col].substr(0, nowCursor.row);

std::string b = "";

if (buffer[nowCursor.col].length() >= nowCursor.row)

b = buffer[nowCursor.col].substr(nowCursor.row);

std::vector<std::string>::iterator ite = buffer.begin() + nowCursor.col + 1;

buffer[nowCursor.col] = a;

buffer.insert(ite, b);

nowCursor.col ++;

nowCursor.row = 0;

ScrollDown();

// begin auto indent

if (!autoIndent)

return;

if (nowCursor.col > 0) {

int indent = 0;

int bracket = 0;

bool pref = true;

for (int i = 0; i < buffer[nowCursor.col - 1].length(); i++) {

if (buffer[nowCursor.col - 1][i] == ' ') {

if (pref)

indent ++;

} else pref = false;

if (buffer[nowCursor.col - 1][i] == '{')

bracket ++;

}

if (bracket > 0)

indent += 2;

for (int i = 0; i < indent; i ++)

InsertCharacter(' ', false);

// buffer[nowCursor.col].insert(0, indent, ' ');

}

} else {

buffer[nowCursor.col].insert(nowCursor.row, 1, ch);

nowCursor.row ++;

}

}

void TextEditor::Output() {

std::cout << ">>> Begin" << std::endl;

for (int i = 0; i < buffer.size(); i ++) {

std::cout << "Line: " << i << std::endl;

std::cout << buffer[i] << std::endl;

}

std::cout << "<<< End" << std::endl;

}

TextEditor::TextEditor(void)

{

maxLineNum = 28;

lineOffset = 0;

selectMode = false;

// 一行目

buffer.push_back("");

log.push_back(TextEditorLog(nowCursor, buffer, lineOffset));

logIndex = -1;

}

TextEditor::~TextEditor(void)

{

}

};