text_editor.c

#include "log.h"
#include "file_browser.h"
#include "thoth.h"
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#ifndef SDL_COMPILE
#endif

#ifdef SDL_COMPILE
#ifdef SDL2_COMPILE
#include <SDL2/SDL.h>
#else
#include <SDL3/SDL.h>
#endif

#ifdef LINUX_COMPILE
#ifndef SDL_COMPILE
#include "x11.h"
#include <termios.h>
#include <ncurses.h>
#endif
#ifdef __OpenBSD__
#include <util.h>
#else
#include <sys/wait.h>
#include <pty.h>
#endif
#endif
#endif
#ifdef WINDOWS_API_COMPILE
#include <windows.h>
#include "thoth.h"
#include "log.h"
#include "file_browser.h"
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#endif
#include <math.h>
#ifdef WINDOWS_API_COMPILE
void clear(){}
#endif
enum {
	SCR_NORM = 0,
	SCR_CENT,
};

#ifndef UNUSED
#define UNUSED(x) (void)(x)
#endif


static void Comment(Thoth_Editor *t, Thoth_EditorCmd *c);
static void ToggleCommentMulti(Thoth_Editor *t, Thoth_EditorCmd *c);
static void PutsCursor(Thoth_Editor *t, Thoth_EditorCur c);
static void LoggingMoveLines(Thoth_Editor *t, int num);
static void LoggingRemoveCharacter(Thoth_Editor *t);
static void LoggingAddCharacter(Thoth_Editor *t, char c);
static void ClearAutoComplete(Thoth_Editor *t);
static void FreeFile(Thoth_EditorFile *f);
static void RefreshFile(Thoth_Editor *t);
static int AddFile(Thoth_Editor *t, Thoth_EditorFile *f);
static Thoth_EditorFile *CreateTextEditorFile(char *path);
static void EndLogging(Thoth_Editor *t);
static void StartLogging(Thoth_Editor *t, int mode);
static void AlertLog(Thoth_Editor *t, const char *str);
static int FindInsensitive(char *text, char *str, int len);
static void FindTextGoto(Thoth_Editor *t, int dir, int insensitive);
static void ScrollToLine(Thoth_Editor *t);
static int MoveByWordsFunc(char *text, int len, int start, int dir);
static void DoSwitchFile(Thoth_Editor *t);
static void DoFileBrowser(Thoth_Editor *t);
static void FindTextInsensitive(Thoth_Editor *t, Thoth_EditorCmd *c);
static void CloseFile(Thoth_Editor *t, Thoth_EditorCmd *c);
static void AddSavedText(Thoth_Editor *t, char *str, int len, int *cursorIndex);
static void EraseAllSelectedText(Thoth_Editor *t, int *cursorIndex, Thoth_EditorCmd *c);
static void AutoComplete(Thoth_Editor *t);
static int IsToken(char c);
static char CaseLower(char c);
static int IsDigit(char c);
static int IsHexadecimal(char c);
static int GetStartOfNextLine(char *text, int textLen, int cPos);
static int GetNumLinesToPos(char *text, int cPos);
static int GetCharsIntoLine(char *text, int cPos);
static void GetWordStartEnd(char *text, int cPos, int *s, int *e);
static int GetWordEnd(char *text, int cPos);
static int GetWordStart(char *text, int cPos);
static int GetStartOfPrevLine(char *text, int cPos);
static void DoOpenFile(Thoth_Editor *t);
static void DoSaveFile(Thoth_Editor *t);
static void OpenFileZim(Thoth_Editor *t, Thoth_EditorCmd *c);
static void NewFile(Thoth_Editor *t, Thoth_EditorCmd *c);
static void SwitchFile(Thoth_Editor *t, Thoth_EditorCmd *c);
void Thoth_Editor_LoadFile(Thoth_Editor *t, char *path);
static void SaveAsFile(Thoth_Editor *t, Thoth_EditorCmd *c);
static void SaveFile(Thoth_Editor *t, Thoth_EditorCmd *c);
// static void RefreshEditorCommand(Thoth_EditorCmd *c);
static void ResolveCursorCollisions(Thoth_Editor *t, int *cursorIndex);
static void MoveCursorsAndSelection(Thoth_Editor *t, int pos, int by, int *cursorIndex);
static void MoveLineUp(Thoth_Editor *t, Thoth_EditorCur *c);
static void MoveLineDown(Thoth_Editor *t, Thoth_EditorCur *c);
static void RemoveSelections(Thoth_Editor *t);
static void OpenFileBrowser(Thoth_Editor *t, Thoth_EditorCmd *c);
static void SetCursorToSelection(Thoth_EditorCur *cursor, int n);
static void MoveByChars(Thoth_Editor *t, Thoth_EditorCmd *c);
static void SelectAll(Thoth_Editor *t, Thoth_EditorCmd *c);
static void MoveByWords(Thoth_Editor *t, Thoth_EditorCmd *c);
static void FreeCursors(Thoth_Editor *t);
static void InitCursors(Thoth_Editor *t);
static int MoveCursorUpLine(Thoth_Editor *t, Thoth_EditorCur *cursor);
static int MoveCursorDownLine(Thoth_Editor *t, Thoth_EditorCur *cursor);
static void MoveLines(Thoth_Editor *t, Thoth_EditorCmd *c);
// static void ExpandSelectionChars(Thoth_Editor *t,Thoth_EditorCmd *c);
static void ExpandSelectionWords(Thoth_Editor *t,Thoth_EditorCmd *c);
static void AddCursorCommand(Thoth_Editor *t, Thoth_EditorCmd *c);
static Thoth_EditorCur *AddCursor(Thoth_Editor *t);
static int Find(char *text, char *str, int len);
static void SelectNextWord(Thoth_Editor *t, Thoth_EditorCmd *c);
static void EventEnter(Thoth_Editor *t, int key);
static void EventCtrlEnter(Thoth_Editor *t, Thoth_EditorCmd *c);
static void SaveCursors(Thoth_Editor *t, Thoth_EditorCmd *c);
static void LoadCursors(Thoth_Editor *t, Thoth_EditorCmd *c);
static void RemoveExtraCursorsCommand(Thoth_Editor *t, Thoth_EditorCmd *c);
static void AddStrToText(Thoth_Editor *t, int *cursorIndex, char *text);
static void RemoveStrFromText(Thoth_Editor *t, int *cursorIndex, int len);
static void UndoRemoveCharacters(Thoth_Editor *t, Thoth_EditorCmd *c);
static void RemoveCharacters(Thoth_Editor *t, Thoth_EditorCmd *c);
static void UndoAddCharacters(Thoth_Editor *t, Thoth_EditorCmd *c);
static void AddCharacters(Thoth_Editor *t, Thoth_EditorCmd *c);
static void Undo(Thoth_Editor *t, Thoth_EditorCmd *c);
static void Copy(Thoth_Editor *t, Thoth_EditorCmd *c);
static void MoveBrackets(Thoth_Editor *t, Thoth_EditorCmd *c);
static int GetBetweenBrackets(char *text, int len, int pos, int *first, int *last);
static void ExpandSelectionLines(Thoth_Editor *t, Thoth_EditorCmd *c);
static void DeleteLine(Thoth_Editor *t, Thoth_EditorCmd *c);
static void UndoDeleteLine(Thoth_Editor *t, Thoth_EditorCmd *c);
static void Cut(Thoth_Editor *t, Thoth_EditorCmd *c);
static void UndoCut(Thoth_Editor *t, Thoth_EditorCmd *c);
static void Redo(Thoth_Editor *t, Thoth_EditorCmd *c);
static void FreeCommand(Thoth_EditorCmd *c);
static void UpdateScrollCenter(Thoth_Editor *t);
static void UpdateScroll(Thoth_Editor *t);
static Thoth_EditorCmd *CopyCommand(Thoth_EditorCmd *c);
static Thoth_EditorCmd *CreateCommand(const char *name, const unsigned int binding[], const char *keys, int n, int scroll,
	void (*E)(Thoth_Editor *, Thoth_EditorCmd *), void (*U)(Thoth_Editor *, Thoth_EditorCmd *));
static void UndoCommands(Thoth_Editor *t, int num);
static void RedoCommands(Thoth_Editor *t, int num);
static void RemoveExtraCursors(Thoth_Editor *t);
static void ExecuteCommand(Thoth_Editor *t ,Thoth_EditorCmd *c);
static void AddCommand(Thoth_Editor *t, Thoth_EditorCmd *c);
static char *Thoth_basename(char *path);

const char *keywords[] = {
	"int8", "int16", "int32", "int64", "break", "and", "case", "continue", "default", "do", "else", "false", "for", "if", "namespace",
	"abstract", "final", "from", "cast", "funcdef", "get", "import", "in", "inout", "interface", "is", "mixin", "not", "null", "or",
	"out", "override", "private", "protected", "return", "set", "shared", "super", "switch", "this", "true", "typedef", "uint",
	"uint8", "uint16", "uint32", "uint64", "void", "while", "xor", "end", "function", "local", "nil", "repeat", "then", "until",
	"auto", "bool", "char", "class", "double", "float", "int", "enum", "const", "static", "include", "define", "ifndef", "endif", 
	"ifdef", "struct", "unsigned","def",
};

static char *Thoth_basename(char *path){
	int j;
	for(j = strlen(path)-1; j >= 0; j--)
		if(path[j] == '/' || path[j] == '\\')
			break;
	
	return &path[j+1];
}

static inline int IsDigit(char c){
	if(c >= '0' && c <= '9') return 1;
	return 0;

}
static inline int IsHexadecimal(char c){
	if(IsDigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'Z')) return 1;
	return 0;
}

static char CaseLower(char c){
	return tolower(c);
}
static int CaseLowerStrnCmp(char *str, char *cmp, int len){
	int k;
	for(k = 0; k < len; k++){
		if(CaseLower(str[k]) != CaseLower(cmp[k])) break;
	}
	return len == k;

}

static int IsToken(char c){
	if(c == '(' || c == ' ' || c == '\n'|| c == ',' || c == '+' || c == '=' || c == '~' || c == '<' || 
		c == '>' || c == '*' || c == ')' || c == '/' || c == '{' || c == '}' || c == '%' || c == '^' || 
		c == ':' || c == '.' || c == ';' || c == ']' || c == '[' || c == '-' || c == ']' || c == '"' ||
		c == '\''|| c == '|' || c == '\t'|| c == '\0' || c == '#' || c == '&' || c == '!') return 1;

	return 0;
}

static int GetNumLinesToPos(char *text, int cPos){

	int k, lines = 0;
	for(k = 0; k < cPos; k++)
		if(text[k] == '\n') lines++;

	return lines;
}


static int GetCharsIntoLine(char *text, int cPos){

	if(cPos == 0) return 0;

	int k = cPos-1;

	for(; k > 0; k--)
		if(text[k] == '\n') { k++; break; }

	return (cPos - k);
}

static void AlertLog(Thoth_Editor *t, const char *str){
	EndLogging(t);
	StartLogging(t, THOTH_LOGMODE_ALERT);
	int bufferLen = strlen(str);
	t->loggingText = malloc(bufferLen+1);
	strcpy(t->loggingText, str);
	t->loggingText[bufferLen] = 0;
}

static void StartLogging(Thoth_Editor *t, int mode){
	t->logging = mode; 
}

static void EndLogging(Thoth_Editor *t){
	t->logIndex = -1;

#ifndef SDL_COMPILE
#ifdef LINUX_COMPILE
		bkgd(COLOR_PAIR(THOTH_COLOR_NORMAL));	
		wclear(stdscr);
#endif
#endif
	if(t->loggingText) free(t->loggingText);

	if(t->logging == THOTH_LOGMODE_CONSOLE){
#ifdef LINUX_COMPILE
		//fsync(STDERR_FILENO);
		//fsync(STDOUT_FILENO);
		//dup2(t->_stderr, STDERR_FILENO);
		//dup2(t->_stdout, STDOUT_FILENO);

#ifndef SDL_COMPILE
		initscr();		
#endif
		//if(t->ttyMaster) close(t->ttyMaster);
		//if(t->ttySlave) close(t->ttySlave);
#endif
	}

	t->logging = 0;
	t->loggingText = NULL;
}

static void ClearAutoComplete(Thoth_Editor *t){
	t->autoCompleteSearchLen = 0;
	t->autoCompleteLen = 0;
	t->autoCompleteIndex = 0;
}

static void FindTextGoto(Thoth_Editor *t, int dir, int insensitive){

	RemoveSelections(t);
	RemoveExtraCursors(t);
	if(!t->loggingText) return;
	int searchLen = strlen(t->loggingText);

	int (*sensitiveFind)(char *text, char *str, int len);
	if(insensitive)
		sensitiveFind = FindInsensitive;
	else
		sensitiveFind = Find;

	if(dir > 0){

		int next = sensitiveFind(&t->file->text[t->cursors[0].pos], t->loggingText, searchLen);

		if(next < 0 || t->cursors[0].pos == strlen(t->file->text)){
	
			next = sensitiveFind(&t->file->text[0], t->loggingText, searchLen);
	
			if(next < 0)
				next = 0;
			else
				t->cursors[0].selection.len = searchLen;

			t->cursors[0].pos = next;
		
		} else if(next == 0){
			next = sensitiveFind(&t->file->text[t->cursors[0].pos+searchLen], t->loggingText, searchLen);

			if(next < 0){
				next = sensitiveFind(&t->file->text[0], t->loggingText, searchLen);
				t->cursors[0].pos = next;
				
				if(next >= 0)
					t->cursors[0].selection.len = searchLen;
			} else {
				t->cursors[0].pos += next + searchLen;
				t->cursors[0].selection.len = searchLen;
			}
		} else {
			t->cursors[0].pos += next;
			t->cursors[0].selection.len = searchLen;
		}

		t->cursors[0].selection.startCursorPos = t->cursors[0].pos;
	}

	if(dir < 0){

		t->file->textLen = strlen(t->file->text);

		int curr = sensitiveFind(&t->file->text[0], t->loggingText, searchLen);
		if(curr < 0) {
			return;
		}

		int start = curr;
		int next = 0;

		do{
			curr += next+searchLen;
			next = sensitiveFind(&t->file->text[curr], t->loggingText, searchLen);

		} while(next > 0 && curr+next+searchLen < t->cursors[0].pos && curr+next+searchLen < t->file->textLen);


		if(curr-searchLen == start && t->cursors[0].pos == curr-searchLen){ // sensitiveFind last occurance
			do{
				curr += next+searchLen;
				next = sensitiveFind(&t->file->text[curr], t->loggingText, searchLen);

			} while(next > 0 && curr+next+searchLen < t->file->textLen);

		}

		t->cursors[0].pos = curr-searchLen;            
		t->cursors[0].selection.startCursorPos = t->cursors[0].pos;
		t->cursors[0].selection.len = searchLen;
	}
	
	UpdateScrollCenter(t);
}
static void UpdateScroll(Thoth_Editor *t){

	if(t->file->text == NULL) return;

	int nLinesToCursor = GetNumLinesToPos(t->file->text,t->cursors[t->nCursors-1].pos);

	if(nLinesToCursor < t->file->scroll)
		t->file->scroll = nLinesToCursor;
	else if(nLinesToCursor >= (t->file->scroll + t->linesY) - t->logY )
		t->file->scroll = (nLinesToCursor - t->linesY)+1+t->logY;

}


static void UpdateScrollCenter(Thoth_Editor *t){

	int nLinesToCursor = GetNumLinesToPos(t->file->text,t->cursors[t->nCursors-1].pos);

	if(nLinesToCursor >= t->file->scroll && nLinesToCursor < t->file->scroll + t->linesY - t->logY){
		return;
	}	

	t->file->scroll = nLinesToCursor  - (t->linesY/2);

	if(t->file->scroll < 0) t->file->scroll = 0;
}

static void ScrollToLine(Thoth_Editor *t){

	t->logging = 0;
	RemoveSelections(t);
	RemoveExtraCursors(t);

	if(!t->loggingText) return;

	int line = atoi(t->loggingText);

	if(t->loggingText) free(t->loggingText);
	t->loggingText = NULL;

	if(line == 0){
		t->cursors[0].pos = 0;
		return;
	}
	if(!t->file->text) return;

	t->file->textLen = strlen(t->file->text);

	int scroll = 0, scrollPos = 0;

	int k;
	for(k = 0; k < t->file->textLen; k++){

		if(t->file->text[k] == '\n'){
			scroll++;
			if(scroll == line+1){
				break;
			}
			scrollPos = k+1;
		}
	}

	if(scroll == 0) return;

	if(scrollPos >= t->file->textLen)
		scrollPos = t->file->textLen-1;

	t->cursors[0].pos = scrollPos;
	UpdateScrollCenter(t);
}

static void EventCtrlEnter(Thoth_Editor *t, Thoth_EditorCmd *c){
	if(t->logging == THOTH_LOGMODE_TEXT) FindTextGoto(t, -1, 0);
	if(t->logging == THOTH_LOGMODE_TEXT_INSENSITIVE) FindTextGoto(t, -1, 1);
}
static void NewLinesElastic(Thoth_Editor *t){
	Thoth_EditorCmd *command;
	if(t->nCursors == 1){
		int into = t->cursors[0].pos - GetCharsIntoLine(t->file->text, t->cursors[0].pos);
		int tabs = 0;
		int k;
		for(k = into; k < t->cursors[0].pos; k++, tabs++){
			if(t->file->text[k] != '\t') break;
		}
		if(t->file->text[t->cursors[0].pos-1] == '{') tabs++;

		char *buffer = malloc(tabs + 2);
		buffer[0] = '\n';
		for(k = 1; k < tabs+1; k++) buffer[k] = '\t';
		buffer[k] = 0;
		command = CreateCommand("AddCharacters",(const unsigned int[]){0}, buffer, 0, 
			SCR_CENT, AddCharacters, UndoAddCharacters);


	} else {
		command = CreateCommand("AddCharacters",(const unsigned int[]){0}, "\n", 0, 
			SCR_CENT, AddCharacters, UndoAddCharacters);
	}
	
	ExecuteCommand(t,command);
	FreeCommand(command);
}

static void EventEnter(Thoth_Editor *t, int key){

	if(t->logging == THOTH_LOGMODE_SAVE){
		if(!t->loggingText) return;
		strcpy(t->file->path,t->loggingText);
		strcpy(t->file->name,t->loggingText);
		DoSaveFile(t);
		return;
	}
	if(t->logging == THOTH_LOGMODE_OPEN){
		DoOpenFile(t);
		return;
	}
	if(t->logging == THOTH_LOGMODE_SWITCH_FILE){
		DoSwitchFile(t);
		return;
	}
	if(t->logging == THOTH_LOGMODE_FILEBROWSER){
		DoFileBrowser(t);
		return;
	}
	if(t->logging == THOTH_LOGMODE_NUM){
		ScrollToLine(t);
		return;
	}
	if(t->logging == THOTH_LOGMODE_TEXT){
		FindTextGoto(t, 1, 0);
		return;
	}
	if(t->logging == THOTH_LOGMODE_TEXT_INSENSITIVE){
		FindTextGoto(t, 1, 1);
		return;
	}

	if(t->autoCompleteLen){
		Thoth_AutoCompleteOffset *ac = &t->autoComplete[t->autoCompleteIndex];
	
		char buffer[THOTH_MAX_AUTO_COMPLETE_STRLEN];
		int len = ac->len - t->autoCompleteSearchLen;
		int offset = ac->offset+t->autoCompleteSearchLen;
		memcpy(buffer, &t->file->text[offset], len);
		buffer[len] = 0;
	
	
		Thoth_EditorCmd *command = 
		CreateCommand("AddCharacters",(const unsigned int[]){0}, buffer, 0, SCR_CENT, AddCharacters, UndoAddCharacters);
		ExecuteCommand(t,command);
		FreeCommand(command);
	
	
		ClearAutoComplete(t);
		return;
	}

	NewLinesElastic(t);
}

static void GetWordStartEnd(char *text, int cPos, int *s, int *e){

	int k;
	for(k = cPos; k >= 0; k--)
		if(!IsToken(text[k])) break;

	for(; k >= 0; k--)
		if(IsToken(text[k])) break;

	*s = k+1;

	for(k = *s; k < (int)strlen(text); k++)
		if(IsToken(text[k])) break;

	*e = k;
}

static int GetWordEnd(char *text, int cPos){

	int k;
	for(k=cPos; k < (int)strlen(text); k++)
		if(IsToken(text[k])) break;

	return k;
}

static int GetWordStart(char *text, int cPos){

	int k;
	for(k=cPos; k >= 0; k--)
		if(IsToken(text[k])) break;

	return k+1;
}

static int GetStartOfPrevLine(char *text, int cPos){

	int k;
	for(k = cPos-1; k >= 0; k--)
		if(text[k] == '\n'){
			for(k = k-1; k >= 0; k--)
				if(text[k] == '\n') break;

			break;
		}

	return k < 0 ? 0 : k+1;
}

static void ResolveCursorCollisions(Thoth_Editor *t, int *cursorIndex){

	int j, f;
	for(j = 0; j < t->nCursors; j++){
		for(f = 0; f < t->nCursors; f++){
	
			if(f != j){
					Thoth_EditorCur *c1 = &t->cursors[j];
					Thoth_EditorCur *c2 = &t->cursors[f];

					if((c1->selection.len && c2->selection.len && 
					((c1->selection.startCursorPos <= c2->selection.startCursorPos + 
					c2->selection.len)
						&& c1->selection.startCursorPos >= c2->selection.startCursorPos)) ||
						 c1->pos == c2->pos){

						// absorb selection
						if((c1->selection.startCursorPos < c2->selection.startCursorPos && (c2->selection.startCursorPos <= 
							c1->selection.startCursorPos+c1->selection.len))){

							int overlap = c2->selection.startCursorPos - 
							(c1->selection.startCursorPos+c1->selection.len);
							
							c2->selection.startCursorPos = c1->selection.startCursorPos;
							c2->selection.len = (c2->selection.len + c1->selection.len) - overlap;
						}
						if((c2->selection.startCursorPos < c1->selection.startCursorPos && (c1->selection.startCursorPos <= 
							c2->selection.startCursorPos+c2->selection.len))){

							int overlap = c1->selection.startCursorPos - 
							(c2->selection.startCursorPos+c2->selection.len);
							
							c2->selection.len = (c2->selection.len + c1->selection.len) - overlap;
						}
					

					if(j+1 < t->nCursors){

						if(t->cursors[j].savedText){
							
							if(t->cursors[f].savedText){
								int len1 = strlen(t->cursors[j].savedText);
								int len2 = strlen(t->cursors[f].savedText);
								t->cursors[j].savedText = realloc(t->cursors[j].savedText, len1+len2+1);
								t->cursors[j].savedText[len1+len2] = 0;

								memcpy(&t->cursors[j].savedText[len1], t->cursors[f].savedText, len2);
								free(t->cursors[f].savedText);
							}
							

							t->cursors[f].savedText = t->cursors[j].savedText;
						}

						t->cursors[f].addedLen += t->cursors[j].addedLen;
					}
					
					int m;
					for(m = j; m < t->nCursors-1; m++){
						t->cursors[m] = t->cursors[m+1];
					}


					t->cursors = realloc(t->cursors, --t->nCursors * sizeof(Thoth_EditorCur));                 


					if(cursorIndex && *cursorIndex >= j)
						(*cursorIndex)--;

					j--;
					//break;
				}
			}
		}
	}
}

static void MoveCursorsAndSelection(Thoth_Editor *t, int pos, int by, int *cursorIndex){

	int k;
	for(k = 0; k < t->nCursors; k++){
		if(k == *cursorIndex) continue;

		if(t->cursors[k].selection.len > 0){

			if(t->cursors[k].selection.startCursorPos > pos){
				t->cursors[k].selection.startCursorPos += by;
			}
		}

		if(t->cursors[k].pos > pos)
			t->cursors[k].pos += by;

	}
	ResolveCursorCollisions(t, cursorIndex);
}

static void RemoveSelections(Thoth_Editor *t){
	
	t->selectNextWordLen = 0;
	t->selectNextWordTerminator = 0;    
	ClearAutoComplete(t);

	// memset(&t->cursors[0].selection, 0, sizeof(Thoth_EditorSelection));

	// if(t->nCursors > 1)
	//  t->cursors = (Thoth_EditorCur *)realloc(t->cursors, sizeof(Thoth_EditorCur));
	// t->nCursors = 1;

	int k;
	for(k = 0; k < t->nCursors; k++)
		memset(&t->cursors[k].selection, 0, sizeof(Thoth_EditorSelection));

}

static void SetCursorToSelection(Thoth_EditorCur *cursor, int n){

	if(n < 0) cursor->pos = cursor->selection.startCursorPos;
	else cursor->pos = cursor->selection.startCursorPos+cursor->selection.len;
}


static void MoveByChars(Thoth_Editor *t, Thoth_EditorCmd *c){

	int textLen = t->file->textLen;

	int k;
	for(k = 0; k < t->nCursors; k++){
		
		if(t->cursors[k].selection.len != 0){
			SetCursorToSelection(&t->cursors[k], c->num);
			continue;   
		}

		t->cursors[k].pos += c->num;

		if(t->cursors[k].pos < 0) t->cursors[k].pos = 0;
		if(t->cursors[k].pos > textLen) t->cursors[k].pos = textLen;
	}

	RemoveSelections(t);

	ResolveCursorCollisions(t, 0);
}
static int MoveByWordsFunc(char *text, int len, int start, int dir){

	if((start > len && dir > 0) || (start == 0 && dir < 0)) return start;

	if(dir < 0 && start > 0){
		
		if(text[start] == '\n'){
			start -= 1;
		}
		
		// @#$|(a)sdff
		if((!IsToken(text[start] && IsToken(text[start-1])))
		|| text[start] == '\n'){
			start--;
		} else {
			start--;

			if(IsToken(text[start]))
				start -= 1;

			if(text[start] != '\n' && IsToken(text[start])){
				while(start >= 0){
					char c = text[--start];
					if(c == '\n') { ++start; break; }
					if(!IsToken(c)) { ++start; break; }
				}
			} else {
				start = GetWordStart(text, start); 
			}
		}

	} else {

		if(!IsToken(text[start] && IsToken(text[start+1])) || text[start] == '\n'){

			start++;

		} else {

			if(IsToken(text[start]))
				start++;

			if(text[start] != '\n' && text[start-1] != '\n' && IsToken(text[start])){
				while(start < len){
					char c = text[++start];
					if(c == '\n') { --start; break; }
					if(!IsToken(c)) break;
				}
			} else {
				int  end = GetWordEnd(text, start);
				start = end;
			}
		}
	}


	if(start < 0) start = 0;
	if(start > len) start = len;

	return start;
}

static void MoveByWords(Thoth_Editor *t, Thoth_EditorCmd *c){

	int k;
	for(k = 0; k < t->nCursors; k++){

		if(t->cursors[k].selection.len != 0){
			SetCursorToSelection(&t->cursors[k], c->num);
			continue;   
		}

		memset(&t->cursors[k].selection, 0, sizeof(Thoth_EditorSelection));


		t->cursors[k].pos = MoveByWordsFunc(t->file->text, t->file->textLen,t->cursors[k].pos,c->num);
	}

	ResolveCursorCollisions(t,0);
}
static void InitCursors(Thoth_Editor *t){
	t->cursors = (Thoth_EditorCur *)malloc(sizeof(Thoth_EditorCur) * ++t->nCursors);
	memset(&t->cursors[0], 0, sizeof(Thoth_EditorCur));
}
static void FreeCursors(Thoth_Editor *t){

	int k;
	for(k = 0; k < t->nCursors; k++){
		if(t->cursors[k].clipboard){
			free(t->cursors[k].clipboard);
			t->cursors[k].clipboard = NULL;
		}
		if(t->cursors[k].savedText){
			free(t->cursors[k].savedText);
			t->cursors[k].savedText = NULL;
		}
	}

	t->nCursors = 0;
	if(t->cursors) free(t->cursors);
	t->cursors = NULL;
}

static void MoveLineUp(Thoth_Editor *t, Thoth_EditorCur *cursor){
	if(t->file->text == NULL) return;

	// int k;
	// for(k = 0; k < t->nCursors; k++){
	
	// Thoth_EditorCur *cursor = &t->cursors[k];            


	if(cursor->selection.len == 0){

		int lineStart = cursor->pos == 0 ? 0 : cursor->pos-1;
		for(; lineStart > 0 && t->file->text[lineStart] != '\n'; lineStart--);
		if(lineStart > 0) lineStart++; // skip \n of prev line
		else return;

		int charsOnLine = cursor->pos;
		for(; charsOnLine < t->file->textLen && t->file->text[charsOnLine] != '\n'; charsOnLine++);
		charsOnLine = (charsOnLine - lineStart);

		int startOfPrevLine = lineStart-2;
		for(; startOfPrevLine > 0 && t->file->text[startOfPrevLine] != '\n'; startOfPrevLine--);
		if(startOfPrevLine > 0) startOfPrevLine++;
		int prevLineLen = lineStart - startOfPrevLine;

		if(lineStart < 0) return;
		if(startOfPrevLine < 0) return;

		if(prevLineLen > charsOnLine){

			char *tmp = malloc(charsOnLine);
			memcpy(tmp, &t->file->text[lineStart], charsOnLine);

			memcpy(&t->file->text[startOfPrevLine+charsOnLine+1], &t->file->text[startOfPrevLine], prevLineLen);
			t->file->text[startOfPrevLine+charsOnLine] = '\n';
			memcpy(&t->file->text[startOfPrevLine], tmp, charsOnLine);

			free(tmp);
		} else {
			char *tmp = malloc(prevLineLen);
			memcpy(tmp, &t->file->text[startOfPrevLine], prevLineLen);

			memcpy(&t->file->text[startOfPrevLine], &t->file->text[lineStart], charsOnLine);
			t->file->text[startOfPrevLine+charsOnLine] = '\n';
			memcpy(&t->file->text[startOfPrevLine+charsOnLine+1], tmp, prevLineLen);
			free(tmp);
		}

		cursor->pos = startOfPrevLine + (cursor->pos - lineStart);
	} else {

		int lineStart = cursor->selection.startCursorPos <= 0 ? 0 : cursor->selection.startCursorPos-1;
		for(; lineStart > 0 && t->file->text[lineStart] != '\n'; lineStart--);
		if(lineStart > 0) lineStart++; // skip \n of prev line
		else return;

		int charsOnLine = cursor->selection.startCursorPos+cursor->selection.len-1;
		for(; charsOnLine < t->file->textLen && t->file->text[charsOnLine] != '\n'; charsOnLine++);
		charsOnLine = (charsOnLine - lineStart);

		int startOfPrevLine = lineStart-2;
		for(; startOfPrevLine > 0 && t->file->text[startOfPrevLine] != '\n'; startOfPrevLine--);
		if(startOfPrevLine > 0) startOfPrevLine++;
		int prevLineLen = lineStart - startOfPrevLine;

		if(prevLineLen > charsOnLine){

			char *tmp = malloc(charsOnLine);
			memcpy(tmp, &t->file->text[lineStart], charsOnLine);

			memcpy(&t->file->text[startOfPrevLine+charsOnLine+1], &t->file->text[startOfPrevLine], prevLineLen);
			t->file->text[startOfPrevLine+charsOnLine] = '\n';
			memcpy(&t->file->text[startOfPrevLine], tmp, charsOnLine);

			free(tmp);

		} else {
			char *tmp = malloc(prevLineLen);
			memcpy(tmp, &t->file->text[startOfPrevLine], prevLineLen);

			memcpy(&t->file->text[startOfPrevLine], &t->file->text[lineStart], charsOnLine);
			t->file->text[startOfPrevLine+charsOnLine] = '\n';
			memcpy(&t->file->text[startOfPrevLine+charsOnLine+1], tmp, prevLineLen);
			free(tmp);

		}

		cursor->selection.startCursorPos = startOfPrevLine + (cursor->selection.startCursorPos - lineStart);
		cursor->pos = startOfPrevLine + (cursor->pos - lineStart);

	}
	// }
}

static void MoveLineDown(Thoth_Editor *t, Thoth_EditorCur *cursor){
	if(t->file->text == NULL) return;

	// int k;
	// for(k = 0; k < t->nCursors; k++){
		
	//     Thoth_EditorCur *cursor = &t->cursors[k];            


	if(cursor->selection.len == 0){

		int lineStart = cursor->pos == 0 ? 0 : cursor->pos-1;
		for(; lineStart > 0 && t->file->text[lineStart] != '\n'; lineStart--);
		if(lineStart > 0) lineStart++; // skip \n of prev line

		int charsOnLine = cursor->pos;
		for(; charsOnLine < t->file->textLen && t->file->text[charsOnLine] != '\n'; charsOnLine++);
		if(charsOnLine >= t->file->textLen || t->file->text[charsOnLine] != '\n') return; // end of file dont move down
		charsOnLine = (charsOnLine - lineStart);

		int startOfNextLine = lineStart+charsOnLine+1;
		if(startOfNextLine >= t->file->textLen) return;
		int nextLineLen = startOfNextLine;
		for(; nextLineLen < t->file->textLen && t->file->text[nextLineLen] != '\n'; nextLineLen++);

		nextLineLen = (nextLineLen - startOfNextLine);
		
		if(lineStart + nextLineLen >= t->file->textLen-1) return; // already last line
				
		if(nextLineLen > charsOnLine){
			char *tmp = malloc(charsOnLine);
			memcpy(tmp, &t->file->text[lineStart], charsOnLine);
			memcpy(&t->file->text[lineStart], &t->file->text[startOfNextLine], nextLineLen);
			t->file->text[lineStart+nextLineLen] = '\n';
			memcpy(&t->file->text[lineStart+nextLineLen+1], tmp, charsOnLine);

			free(tmp);
		} else {
			char *tmp = malloc(nextLineLen);
			memcpy(tmp, &t->file->text[startOfNextLine], nextLineLen);

			memcpy(&t->file->text[lineStart+nextLineLen+1], &t->file->text[lineStart], charsOnLine);
			t->file->text[lineStart+nextLineLen] = '\n';
			memcpy(&t->file->text[lineStart], tmp, nextLineLen);
			free(tmp);
		}

		cursor->pos = lineStart+nextLineLen+1 + (cursor->pos - lineStart);
	} else {

		int lineStart = cursor->selection.startCursorPos == 0 ? 0 : cursor->selection.startCursorPos-1;
		for(; lineStart > 0 && t->file->text[lineStart] != '\n'; lineStart--);
		if(lineStart > 0) lineStart++; // skip \n of prev line

		int charsOnLine = cursor->selection.startCursorPos+cursor->selection.len-1;
		for(; charsOnLine < t->file->textLen && t->file->text[charsOnLine] != '\n'; charsOnLine++);
		if(charsOnLine >= t->file->textLen || t->file->text[charsOnLine] != '\n') return; // end of file dont move down

		charsOnLine = (charsOnLine - lineStart);

		int startOfNextLine = lineStart+charsOnLine+1;
		if(startOfNextLine >= t->file->textLen) return;
		int nextLineLen = startOfNextLine;
		for(; nextLineLen < t->file->textLen && t->file->text[nextLineLen] != '\n'; nextLineLen++);

		nextLineLen = (nextLineLen - startOfNextLine);

		if(lineStart + nextLineLen >= t->file->textLen-1) return; // already last line

		if(nextLineLen > charsOnLine){
			char *tmp = malloc(charsOnLine);
			memcpy(tmp, &t->file->text[lineStart], charsOnLine);
			memcpy(&t->file->text[lineStart], &t->file->text[startOfNextLine], nextLineLen);
			t->file->text[lineStart+nextLineLen] = '\n';
			memcpy(&t->file->text[lineStart+nextLineLen+1], tmp, charsOnLine);

			free(tmp);
		} else {
			char *tmp = malloc(nextLineLen);
			memcpy(tmp, &t->file->text[startOfNextLine], nextLineLen);

			memcpy(&t->file->text[lineStart+nextLineLen+1], &t->file->text[lineStart], charsOnLine);
			t->file->text[lineStart+nextLineLen] = '\n';
			memcpy(&t->file->text[lineStart], tmp, nextLineLen);
			free(tmp);
		}

		cursor->pos = lineStart+nextLineLen+1 + (cursor->pos - lineStart);
		cursor->selection.startCursorPos = lineStart+nextLineLen+1 + (cursor->selection.startCursorPos - lineStart);

	}
	// }
}

static void MoveLinesText(Thoth_Editor *t, Thoth_EditorCmd *c){
	LoadCursors(t,c);
	int k;

	if(t->file->text == NULL || !t->file->textLen)
		return;

	for(k = 0; k < t->nCursors; k++){

		Thoth_EditorCur *cursor = &t->cursors[k];

		if(c->num > 0)
			MoveLineDown(t, cursor);
		else if(c->num < 0 && GetNumLinesToPos(t->file->text, cursor->pos) > 0)
			MoveLineUp(t, cursor);
	}

	SaveCursors(t,c);
	ResolveCursorCollisions(t,0);
}

static void UndoMoveLinesText(Thoth_Editor *t, Thoth_EditorCmd *c){

	int k;
	LoadCursors(t,c);

	if(t->file->text == NULL || !t->file->textLen)
		return;

	for(k = 0; k < t->nCursors; k++){

		Thoth_EditorCur *cursor = &t->cursors[k];

		if(c->num > 0)
			MoveLineUp(t, cursor);
		else if(c->num < 0 && GetNumLinesToPos(t->file->text, cursor->pos) > 0)
			MoveLineDown(t, cursor);
	}

	ResolveCursorCollisions(t,0);
	SaveCursors(t,c);
}


static void GotoLine(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	StartLogging(t, THOTH_LOGMODE_NUM);
}

static void DoOpenFile(Thoth_Editor *t){
	Thoth_Editor_LoadFile(t, t->loggingText);
	RefreshFile(t);
	EndLogging(t);
}

static void LogLineSelectorEnter(Thoth_Editor *t){

	int nFiles = t->logging == THOTH_LOGMODE_FILEBROWSER ? t->fileBrowser.nFiles : t->nFiles;

	int matches = 0;
	int k;
	for(k = 0; k < nFiles; k++){
		char *name = t->logging == THOTH_LOGMODE_FILEBROWSER ? t->fileBrowser.files[k].name : t->files[k]->name;
		int nameLen = strlen(name);
		char *logName = t->loggingText ? Thoth_basename(t->loggingText) : NULL;
		int logNameLen = logName ? strlen(logName) : 0;

		if(logNameLen <= nameLen){
			if(logNameLen == 0 || CaseLowerStrnCmp(logName, name, logNameLen)){
				if(t->logIndex == matches){
					if(t->logging == THOTH_LOGMODE_FILEBROWSER){

						if(t->fileBrowser.files[k].dir){
							strcpy(t->fileBrowser.directory, t->fileBrowser.files[k].path);
							Thoth_FileBrowser_ChangeDirectory(&t->fileBrowser);
							int dirlen = strlen(t->fileBrowser.directory);
							t->loggingText = realloc(t->loggingText, dirlen+1);
							strcpy(t->loggingText, t->fileBrowser.directory);
							t->loggingText[dirlen] = 0;
							t->logIndex = 0;
						} else {
							Thoth_Editor_LoadFile(t, t->fileBrowser.files[k].path);
							RefreshFile(t);
							EndLogging(t);
							break;
						}
					} else if(t->logging == THOTH_LOGMODE_SWITCH_FILE){

						t->file = t->files[k];

						if(t->file != t->files[k]){
							int j;
							for(j = 1; j <= k; j++){
								t->files[j] = t->files[j-1];
							}
							t->files[0] = t->file; // stack like
						}

						RefreshFile(t);
						EndLogging(t);
						break;
					}
				}
				matches++;
			}
		}
	}
}

static void DoFileBrowser(Thoth_Editor *t){
	LogLineSelectorEnter(t);
}

static void DoSwitchFile(Thoth_Editor *t){
	t->file->cursorPos = t->cursors[0].pos;
	LogLineSelectorEnter(t);
}

static void FileBrowserPath(Thoth_Editor *t){
	if(strlen(t->file->path) == 0) return;
	strcpy(t->fileBrowser.directory, t->file->path);
	int k;
	for(k = strlen(t->fileBrowser.directory)-2; k >= 0; k--)
		if(t->fileBrowser.directory[k] == '/' || t->fileBrowser.directory[k] == '\\') break;

	if(k > 0)
		t->fileBrowser.directory[k+1] = 0;
	Thoth_FileBrowser_ChangeDirectory(&t->fileBrowser);
}
static void DoSaveFile(Thoth_Editor *t){
	t->file->unsaved = 0;
	FILE *fp = fopen(t->file->path, "wb");

	fwrite(t->file->text,1,strlen(t->file->text),fp);
	FileBrowserPath(t);
	fclose(fp);
	EndLogging(t);
}
static void RefreshFile(Thoth_Editor *t){
	FreeCursors(t);
	InitCursors(t);
	t->cursors[0].pos = t->file->cursorPos;
	ClearAutoComplete(t);
	FileBrowserPath(t);
	t->selectNextWordTerminator = 0;
	t->selectNextWordLen = 0;
}
static void NewFile(Thoth_Editor *t, Thoth_EditorCmd *c){
	Thoth_Editor_LoadFile(t, NULL);
	RefreshFile(t);
}
static void CloseFile(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(t->file->unsaved){
		AlertLog(t, "Unsaved file! Repeat `close keybind` to ignore & `escape` to close this message.");
		return;
	}

	int k;
	for(k = 0; k < t->nFiles; k++){
		if(t->files[k] == t->file){
			FreeFile(t->file);
			t->file = NULL;
			for(; k < t->nFiles-1; k++)
				t->files[k] = t->files[k+1];
			
			t->files = (Thoth_EditorFile **)realloc(t->files,sizeof(Thoth_EditorFile*) * --t->nFiles);
			break;
		}
	}
	if(t->nFiles == 0){
		Thoth_Editor_LoadFile(t, NULL);
	}
	else{
		t->file = t->files[0];
	}

	RefreshFile(t);
}
static void OpenFileBrowser(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	t->logIndex = 0;
	StartLogging(t, THOTH_LOGMODE_FILEBROWSER);
}
static void OpenFileZim(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	t->loggingText = malloc(strlen(t->fileBrowser.directory)+1);
	strcpy(t->loggingText, t->fileBrowser.directory);
	t->loggingText[strlen(t->fileBrowser.directory)] = 0;
	StartLogging(t, THOTH_LOGMODE_OPEN);
}
static void HelpZim(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);

	StartLogging(t, THOTH_LOGMODE_HELP);
}
static void SwitchFile(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	t->logIndex = 0;
	StartLogging(t, THOTH_LOGMODE_SWITCH_FILE);
}

static void SaveAsFile(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	t->loggingText = malloc(strlen(t->fileBrowser.directory)+1);
	strcpy(t->loggingText, t->fileBrowser.directory);
	t->loggingText[strlen(t->fileBrowser.directory)] = 0;
	StartLogging(t, THOTH_LOGMODE_SAVE);
}
static void SaveFile(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	if(strlen(t->file->path) == 0){
		StartLogging(t, THOTH_LOGMODE_SAVE);
		int k;
		for(k=0;k<strlen(t->fileBrowser.directory);k++){
			LoggingAddCharacter(t,t->fileBrowser.directory[k]);
		}
		return;
	}
	DoSaveFile(t);
}

static void FindTextZim(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	StartLogging(t, THOTH_LOGMODE_TEXT);
}

static void FindTextInsensitive(Thoth_Editor *t, Thoth_EditorCmd *c){
	EndLogging(t);
	StartLogging(t, THOTH_LOGMODE_TEXT_INSENSITIVE);
}

static int MoveCursorUpLine(Thoth_Editor *t, Thoth_EditorCur *cursor){

	if(t->file->text == NULL) return 0;
	if(GetNumLinesToPos(t->file->text, cursor->pos) == 0) return 0;

	int charsIntoLine = GetCharsIntoLine(t->file->text, cursor->pos);
	int startOfPrevLine = GetStartOfPrevLine(t->file->text, cursor->pos);

	int k;
	for(k = startOfPrevLine; k < (int)t->file->textLen; k++)
		if(t->file->text[k] == '\n') break;

	int charsOnPrevLine = (k - startOfPrevLine);
	cursor->pos = charsIntoLine <= charsOnPrevLine ? startOfPrevLine + charsIntoLine: startOfPrevLine + charsOnPrevLine; 

	return 1;
}

static int GetStartOfNextLine(char *text, int textLen, int cPos){

	int k;
	for(k = cPos; k < textLen; k++)
		if(text[k] == '\n') { k++; break; }

	if(k == textLen) k++;
	return k;
}

static int MoveCursorDownLine(Thoth_Editor *t, Thoth_EditorCur *cursor){

	if(t->file->text == NULL) return 0;

	t->file->textLen = strlen(t->file->text);

	int charsIntoLine = GetCharsIntoLine(t->file->text, cursor->pos);
	int startOfNextLine = GetStartOfNextLine(t->file->text, t->file->textLen, cursor->pos);

	if(startOfNextLine == (int)t->file->textLen) return 0;

	int k;
	for(k = startOfNextLine; k < (int)t->file->textLen; k++)
		if(t->file->text[k] == '\n') break;

	int charsOnNextLine = (k - startOfNextLine);

	cursor->pos = charsIntoLine <= charsOnNextLine ? startOfNextLine + charsIntoLine : startOfNextLine + charsOnNextLine;
	cursor->pos = cursor->pos > t->file->textLen ? t->file->textLen : cursor->pos;
	return 1;
}


static void MoveLines(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(t->autoCompleteLen > 0){
		t->autoCompleteIndex += c->num;
		if(t->autoCompleteIndex < 0) t->autoCompleteIndex = 0;
		if(t->autoCompleteIndex > t->autoCompleteLen-1) t->autoCompleteIndex = t->autoCompleteLen-1;
		return;
	}


	int k;

	if(t->file->text == NULL || !t->file->textLen){
		// FreeCursors(t);
		return;
	}

	for(k = 0; k < t->nCursors; k++){

		Thoth_EditorCur *cursor = &t->cursors[k];

		
		if(c->num > 0) {

			MoveCursorDownLine(t, cursor);

		} else if(c->num < 0 && GetNumLinesToPos(t->file->text, cursor->pos) > 0){

			MoveCursorUpLine(t, cursor);
		}
	}

	RemoveSelections(t);
	ResolveCursorCollisions(t,0);
}

static void ExpandSelectionWords(Thoth_Editor *t,Thoth_EditorCmd *c){

	int k;
	for(k = 0; k < t->nCursors; k++){

		int prev = t->cursors[k].pos;
		t->cursors[k].pos = MoveByWordsFunc(t->file->text, t->file->textLen, t->cursors[k].pos,c->num);
		
		if(t->cursors[k].selection.len == 0 || 
			(t->cursors[k].selection.startCursorPos+t->cursors[k].selection.len < t->cursors[k].pos
		 && (t->cursors[k].selection.dir < 0)) || 
			(t->cursors[k].selection.startCursorPos > t->cursors[k].pos && (t->cursors[k].selection.dir >= 0)
		)){
			t->cursors[k].selection.startCursorPos = prev;
			t->cursors[k].selection.dir = c->num;
		}

		if(t->cursors[k].selection.dir >= 0){
			t->cursors[k].selection.len = t->cursors[k].pos - t->cursors[k].selection.startCursorPos;
		} else {
			
			t->cursors[k].selection.len += t->cursors[k].selection.startCursorPos - t->cursors[k].pos;
			t->cursors[k].selection.startCursorPos = t->cursors[k].pos;
		}

	}
	ResolveCursorCollisions(t,0);
}

static Thoth_EditorCur *AddCursor(Thoth_Editor *t){

	t->cursors = (Thoth_EditorCur *)realloc(t->cursors, ++t->nCursors * sizeof(Thoth_EditorCur));

	Thoth_EditorCur *cursor = &t->cursors[t->nCursors-1];

	memset(cursor, 0, sizeof(Thoth_EditorCur));

	// char *last = t->cursors[t->nCursors-2].clipboard;

	// if(last){

	//     int len = strlen(last);

	//     cursor->clipboard = (char *)malloc(len + 1);
	//     cursor->clipboard[len] = 0;

	//     memcpy(cursor->clipboard, last, len);
	// }

	return cursor;
}

static void AddCursorCommand(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(t->file->text == NULL) return;

	Thoth_EditorCur *cursor = AddCursor(t);

	int minCursor = -1;
	int maxCursor = -1;

	int k;
	for(k = 0; k < t->nCursors-1; k++){
		
		if(t->cursors[k].pos < minCursor || minCursor < 0)
			minCursor = t->cursors[k].pos;
		
		if(t->cursors[k].pos > maxCursor || maxCursor < 0)
			maxCursor = t->cursors[k].pos;
	}

	if(c->num < 0){

		cursor->pos = minCursor;

		if(!MoveCursorUpLine(t, cursor)){
			t->cursors = (Thoth_EditorCur *)realloc(t->cursors, --t->nCursors * sizeof(Thoth_EditorCur));
		}

	} else if(c->num > 0) {

		cursor->pos = maxCursor;

		if(!MoveCursorDownLine(t, cursor)){

			t->file->textLen = strlen(t->file->text);
			if(t->file->textLen == 0){
				t->file->text = realloc(t->file->text, t->file->textLen+3);
				t->file->text[t->file->textLen] = '\n';
				t->file->text[t->file->textLen+1] = '\n';
				t->file->text[t->file->textLen+2] = '\0';
			} else{
				t->file->text = realloc(t->file->text, t->file->textLen+2);
				t->file->text[t->file->textLen] = '\n';
				t->file->text[t->file->textLen+1] = '\0';
			}
			MoveCursorDownLine(t, cursor);

//			 t->cursors = (Thoth_EditorCur *)realloc(t->cursors, --t->nCursors * sizeof(Thoth_EditorCur));

		}
	}
}

static int Find(char *text, char *str, int len){
	char *res = (char *)malloc(len + 1);
	res[len] = 0;
	memcpy(res, str, len);
	char *pch = strstr(text, res);
	free(res);
	return pch == NULL ? -1 : pch - text;
}

static int FindInsensitive(char *text, char *str, int len){

	int k;
	for(k = 0; k < len; k++)
		str[k] = CaseLower(str[k]);

	int textLen = strlen(text);

	int match = 0;
	for(k = 0; k < textLen; k++){

		char c = CaseLower(text[k]);

		if(str[match] == c){
			match++;
			if(match == len)
				break;
		} else {
			match = 0;
		}
	}

	return match == len ? (k-len)+1 : -1;
}

static void SelectNextWord(Thoth_Editor *t, Thoth_EditorCmd *c){

	UNUSED(c);

	if(t->file->text == NULL) return;

	if(t->nCursors <= 0) return;

	int f;

	if(t->cursors[0].selection.len == 0){
	
		for(f = 0; f < t->nCursors; f++){

			Thoth_EditorCur *cursor = &t->cursors[f];

			int start = 0;
			GetWordStartEnd(t->file->text, cursor->pos, &start, &cursor->pos);

			t->selectNextWordTerminator = 1;

			cursor->selection.startCursorPos = start;
			cursor->selection.len = cursor->pos - start;
		}

	} else {
	
		Thoth_EditorCur *prev = &t->cursors[t->nCursors-1];

		int startPos, end;

		startPos = prev->selection.startCursorPos;
		end = startPos+prev->selection.len;
		
		int len = t->selectNextWordLen;
		if(!t->selectNextWordLen){
			len = prev->selection.len;
			t->selectNextWordLen = len;
		}
		int next = 0;

		while(next >= 0){
			next = Find(&t->file->text[end], &t->file->text[startPos], len);
			if(next >= 0){
				if(t->selectNextWordTerminator && !IsToken(t->file->text[end+next+len])){
					end += next+len;
					continue;
				}
			}
			break;
		}
		
		if(next >= 0){
			next += end;
			Thoth_EditorCur *cursor = AddCursor(t);
			cursor->pos = next+len;
			cursor->selection.startCursorPos = next;
			cursor->selection.len = len;
		} else {
			next = Find(&t->file->text[0], &t->file->text[startPos], len);
			if(next >= 0 && next != startPos){
				Thoth_EditorCur *cursor = AddCursor(t);
				cursor->pos = next+len;
				cursor->selection.startCursorPos = next;
				cursor->selection.len = len;
				
			}
		}
		
	}

	ResolveCursorCollisions(t,0);
}

// static void ExpandSelectionBrackets(Thoth_Editor *t,Thoth_EditorCmd *c){

// }

static void Paste(Thoth_Editor *t, Thoth_EditorCmd *c){
	LoadCursors(t, c);

	// RefreshEditorCommand(c);
#ifdef SDL_COMPILE
	if(t->clipboard) free(t->clipboard);
	char *temp = SDL_GetClipboardText();
	t->clipboard = malloc(strlen(temp)+1);
	strcpy(t->clipboard, temp);
	SDL_free(temp);
#else
#ifdef LINUX_COMPILE
	X11_Paste(&t->clipboard);
#endif
#endif
	
	char *clipboard = t->clipboard;

	if(c->keys && strlen(c->keys)){
		clipboard = c->keys;
	} else {
		if(c->keys) free(c->keys);
		c->keys = malloc(strlen(clipboard)+1);
		strcpy(c->keys,clipboard);
		c->keys[strlen(clipboard)] = 0;
	}
	int clipboardLen = strlen(clipboard);

	int k;

	int lines = 0;
	for(k = 0; k < clipboardLen; k++){
		if(clipboard[k] == '\n') lines++;
	}
	lines--;

	// if cursorpos is the same as number of tabs dont paste them
	if(lines == 1){

		int charsInto = GetCharsIntoLine(t->file->text, t->cursors[0].pos);
		int tabs = 0;
		for(k = t->cursors[0].pos - charsInto; k < t->cursors[0].pos; k++){
			if(t->file->text[k] != '\t') break;
			tabs++;
		}
		if(tabs == charsInto){
			for(k = 0; k < tabs; k++){
				if(clipboard[k] != '\t') break;
			}
			if(k == tabs){
				char *tmp = malloc((clipboardLen - tabs)+1);
				memcpy(tmp, &clipboard[tabs], clipboardLen-tabs);
				free(clipboard);
				clipboard = tmp;
				clipboardLen -= tabs;
				clipboard[clipboardLen] = 0;
				if(c->keys) free(c->keys);
				c->keys = malloc(strlen(clipboard)+1);
				strcpy(c->keys,clipboard);
				c->keys[strlen(clipboard)] = 0;
				t->clipboard = clipboard;
			}
		}
	}


	if(lines == t->nCursors){
		
		int curline = 0;
		for(k = 0; k < t->nCursors; k++){
				int start = curline;
				char tmp = 0;
				for(; curline < clipboardLen; curline++){
					if(clipboard[curline] == '\n'){
						tmp = clipboard[curline];
						clipboard[curline] = 0;
						break;
					}
				}
				
				EraseAllSelectedText(t, &k, c);
				AddStrToText(t, &k, &clipboard[start]);
				clipboard[curline] = tmp;
				t->cursors[k].addedLen = curline - start;
				curline++;
		}		

	} else {
		for(k = 0; k < t->nCursors; k++){
			char tmp = clipboard[clipboardLen-1];
			if(clipboard[clipboardLen-1] == '\n'){
				clipboard[clipboardLen-1] = 0;
				clipboardLen--;
			}
			
			EraseAllSelectedText(t, &k, c);
			AddStrToText(t, &k, clipboard);
			clipboard[clipboardLen] = tmp;
			t->cursors[k].addedLen = clipboardLen;
		}
	}


	SaveCursors(t, c);

	for(k = 0; k < t->nCursors; k++)
		memset(&t->cursors[k].selection, 0, sizeof(Thoth_EditorSelection));

}

static void UndoPaste(Thoth_Editor *t, Thoth_EditorCmd *c){

	LoadCursors(t, c);

	int k;
	for(k = c->nSavedCursors-1; k >= 0; k--){
		RemoveStrFromText(t, &k, c->savedCursors[k].addedLen);

		if(k < c->nSavedCursors && c->savedCursors[k].savedText){
			AddStrToText(t, &k, c->savedCursors[k].savedText);
			t->cursors[k].selection.len = strlen(c->savedCursors[k].savedText);
		}
	}

	SaveCursors(t, c);

}

static int GetBetweenBrackets(char *text, int len, int pos, int *first, int *last){

	*first = -1;
	int endBracket = -1;
	int j;

	struct {
		int scope;
		char start;
		char end;
		int found;
	} brackets[3] = {
		{0,'{','}',0},
		{0,'[',']',0},
		{0,'(',')',0},
	};

	for(j = pos; j >= 0; j--){

		if(j > 1 && text[j] == '/' && text[j-1] == '*'){ // comment /*  -> */
			j -= 2;
			for(; j > 0 && text[j-1] != '*' && text[j] != '/'; j--);
			if(j < 0) break;
		}

		if(text[j] == '"'){ //string ""
			j--;
			for(; j >= 0; j--){
				if(j > 0 && text[j-1] == '\\') { j--; continue; } // escaped
				if(text[j] == '"') break;
			}
			if(j < 0) break;
			continue;
		}
		if(text[j] == '\''){ // char string ''
			j--;
			for(; j >= 0; j--){
				if(j > 0 && text[j-1] == '\\') { j--; continue; } // escaped
				if(text[j] == '\'') { break; }
			}
			if(j < 0) break;
			continue;
		}

		int m;
		for(m = 0; m < 3; m++){
			if(text[j] == brackets[m].end && j < pos) brackets[m].scope++;

			if(text[j] == brackets[m].start){
				if(brackets[m].scope)
					brackets[m].scope--;
				else 
					endBracket = m;
			}
		}

		if(endBracket != -1){ // comment , check up to first '\n' of line its on
			int f;
			for(f = j; f >= 1; f--){
				if(text[f] == '\n') break;
				if(text[f] == '/' && text[f-1] == '/'){
					endBracket = -1;
					break;
				}
			}
			if(endBracket != -1) break;
		}    
	}

	if(endBracket == -1) return 0;

	*first = j;

	for(j = pos; j < len; j++){

		if(j < len-1 && text[j] == '/' && text[j+1] == '*'){ // comment /*  -> */
			j += 2;
			for(; j < len-1 && text[j+1] != '*' && text[j] != '/'; j++);
			if(j >= len) break;
		}

		if(j < len-1 && text[j] == '/' && text[j+1] == '/'){ // comment //
			for(; j < len; j++)
				if(text[j] == '\n') break;
			if(j >= len) break;
		}
		if(text[j] == '"'){ //string ""
			j++;
			for(; j < len; j++){
				if(text[j] == '\\') { j++; continue; } // escaped
				if(text[j] == '"') break;
			}
			if(j >= len) break;
			continue;
		}
		if(text[j] == '\''){ // char string ''
			j++;
			for(; j < len; j++){
				if(text[j] == '\\') { j++; continue; } // escaped
				if(text[j] == '\'') break;
			}
			if(j >= len) break;
			continue;
		}

		if(text[j] == brackets[endBracket].start && j > pos){
			brackets[endBracket].scope++;
		}

		if(text[j] == brackets[endBracket].end){
			if(brackets[endBracket].scope){

				brackets[endBracket].scope--;
			} else {
				*last = j;
				return 1;

			}

		}
	}
	*last = -1;
	return 0;

}
static void IndentLine(Thoth_Editor *t, Thoth_EditorCmd *c){
/*
	needs saved text for knowing if
	[indent
		indent]

*/
	LoadCursors(t,c);
//	RemoveExtraCursors(t);

	if(c->hiddenCursors){
		RemoveSelections(t);
		int k;
		for(k = 0; k < c->nHiddenCursors; k++){
			int index = c->hiddenCursors[k].hiddenIndex;
			t->cursors[index].pos = c->hiddenCursors[k].pos;

			if(c->hiddenCursors[k].addedLen){
				AddStrToText(t, &index, "\t");
				int m;
				for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos++;
			}

			if(c->hiddenCursors[k].savedText){
				RemoveStrFromText(t, &index, 1);
				int m;
				for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos--;
			}
		}
		return;
	}

	int k;
	for(k = 0; k < t->nCursors; k++){

		Thoth_EditorSelection *sel = &t->cursors[k].selection;
		
		if(!sel->len){
			sel->startCursorPos = t->cursors[k].pos - 
				GetCharsIntoLine(t->file->text, t->cursors[k].pos);

					if(t->file->text[sel->startCursorPos] == '\n')
						sel->startCursorPos++;

					sel->len =GetStartOfNextLine(t->file->text, t->file->textLen, 
						sel->startCursorPos) - sel->startCursorPos;
		}

		int startCursorPos=sel->startCursorPos;
		int next = startCursorPos;
		next = startCursorPos - GetCharsIntoLine(t->file->text, next);
		
		if(next < startCursorPos){
			sel->startCursorPos = next;
			sel->len += startCursorPos - next;
		}
		ResolveCursorCollisions(t,&k);		
	}
	for(k = 0; k < t->nCursors; k++){
		Thoth_EditorSelection *sel = &t->cursors[k].selection;
		int next = sel->startCursorPos;
		if(t->file->text[next] == '\n') next++;
		do {

			t->cursors[k].pos = next;
			if(c->num > 0 && t->file->text[next] != '\n'){
				c->hiddenCursors = (Thoth_EditorCur *)realloc(c->hiddenCursors, sizeof(Thoth_EditorCur) * ++c->nHiddenCursors);
				Thoth_EditorCur *cur = &c->hiddenCursors[c->nHiddenCursors-1];			
				memset(cur, 0, sizeof(Thoth_EditorCur));
				t->cursors[k].pos = next;
				cur->addedLen = 1;
				AddStrToText(t, &k, "\t");
				cur->pos = t->cursors[k].pos;
				sel->len++;
			} else {
				if (t->file->text[next] == '\t' || t->file->text[next] == ' '){
					c->hiddenCursors = (Thoth_EditorCur *)realloc(c->hiddenCursors, sizeof(Thoth_EditorCur) * ++c->nHiddenCursors);
					Thoth_EditorCur *cur = &c->hiddenCursors[c->nHiddenCursors-1];
					memset(cur, 0, sizeof(Thoth_EditorCur));
					cur->pos = next;
					t->cursors[k].pos= next+1;
					cur->savedText = malloc(2);
					cur->savedText[0] = '\t';
					cur->savedText[1] = 0;
					Thoth_EditorSelection backup = *sel;
					
					RemoveStrFromText(t, &k, 1);
					*sel = backup;
					sel->len--;
				}
			}
			next = GetStartOfNextLine(t->file->text, t->file->textLen, next);
		} while(next < sel->startCursorPos+sel->len);
		t->cursors[k].pos = next-1;
	}
	SaveCursors(t,c);
}

static void UndoIndentLine(Thoth_Editor *t, Thoth_EditorCmd *c){
	LoadCursors(t, c);

	RemoveExtraCursors(t);
	RemoveSelections(t);
	int k;
	for(k = 0; k < c->nHiddenCursors; k++){
		int index = c->hiddenCursors[k].hiddenIndex;
		t->cursors[index].pos = c->hiddenCursors[k].pos;

		if(c->hiddenCursors[k].addedLen){
			RemoveStrFromText(t, &index, c->hiddenCursors[k].addedLen);
			int m;
			for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos--;
		}

		if(k < c->nHiddenCursors && c->hiddenCursors[k].savedText){
			AddStrToText(t, &index, c->hiddenCursors[k].savedText);
			int m;
			for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos++;
		}
	}

	SaveCursors(t, c);
}
static void ToggleCommentMulti(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(!t->file->text) return;
	if(t->nCursors > 1) return;
	
	t->file->textLen = strlen(t->file->text);
	LoadCursors(t,c);


	int k = 0;
	if(t->cursors[0].selection.len == 0){
		if(t->cursors[0].pos >= 2){
			if(strncmp(&t->file->text[t->cursors[0].pos-2],"/**/",4) == 0){
				t->cursors[0].pos += 2;
				RemoveStrFromText(t, &k, 4);
				SaveCursors(t,c);
				return;
			}
		}
		
		AddStrToText(t, &k, "/**/");
		t->cursors[0].pos -= 2;
		SaveCursors(t,c);
		return;
	}

	int startSelection = t->cursors[0].selection.startCursorPos;

	if(t->file->text[startSelection] == '\n')
		startSelection++;

	int endSelection = (t->cursors[0].selection.startCursorPos+t->cursors[0].selection.len);


	int m;
	for(m = startSelection; m < endSelection; m++){
		
		while((t->file->text[m] == '\t' || t->file->text[m] == ' ')
		 && m < endSelection) m++;

		if(t->file->text[m] == '\n') continue;

		if(strncmp(&t->file->text[m], "/*", 2) == 0) {
			t->cursors[0].pos = m+2;
			RemoveStrFromText(t, &k, 2);
			endSelection -= 2;
			break;
		} else {
			t->cursors[0].pos = m;
			AddStrToText(t, &k, "/*");
			endSelection+=2;
			t->cursors[0].selection.len+=2;
			m += 2;
			break;
		}
	}
	t->cursors[0].pos =endSelection;
	if(strncmp(&t->file->text[endSelection-2], "*/", 2) == 0) {
		RemoveStrFromText(t, &k, 2);
		endSelection -= 2;
	} else {
		AddStrToText(t, &k, "*/");
		t->cursors[0].selection.len+=2;
		endSelection+=2;
		m += 2;
	}

	SaveCursors(t,c);
}

static void Comment(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(!t->file->text) return;

	t->file->textLen = strlen(t->file->text);

	LoadCursors(t,c);

	if(c->hiddenCursors){
		RemoveSelections(t);
		int k;
		for(k = 0; k < c->nHiddenCursors; k++){
			int index = c->hiddenCursors[k].hiddenIndex;
			t->cursors[index].pos = c->hiddenCursors[k].pos;

			if(c->hiddenCursors[k].addedLen){
				AddStrToText(t, &index, "//");
				int m;
				for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos+=2;
			}

			if(c->hiddenCursors[k].savedText){
				RemoveStrFromText(t, &index, 2);
				int m;
				for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos-=2;
			}
		}
		return;
	}


	int k;
	for(k = 0; k < t->nCursors; k++){

		if(t->cursors[k].selection.len == 0){

			int lineEnd = GetStartOfNextLine(t->file->text, t->file->textLen, t->cursors[k].pos)-1;
			int lineStart = t->cursors[k].pos - 
			GetCharsIntoLine(t->file->text, t->cursors[k].pos);
			if(t->file->text[lineStart] =='\n') lineStart++;;

			int j;
			int toggled = 0;
			for(j = lineEnd-1; j > lineStart; j--){

				if(t->file->text[j] == '/' && t->file->text[j-1] == '/') {
					t->cursors[k].pos = j+1;
					RemoveStrFromText(t, &k, 2);
					c->hiddenCursors = (Thoth_EditorCur *)realloc(c->hiddenCursors, sizeof(Thoth_EditorCur) * ++c->nHiddenCursors);
					Thoth_EditorCur *cur = &c->hiddenCursors[c->nHiddenCursors-1];			
					memset(cur, 0, sizeof(Thoth_EditorCur));
					cur->pos = t->cursors[k].pos;
					cur->savedText = malloc(3);
					strcpy(cur->savedText,"//");
					toggled = 1;
					break;
				}
			}

			if(toggled) continue;
			t->cursors[k].pos = lineStart;
			int m = lineStart;
			while((t->file->text[m] == '\t' || t->file->text[m] == ' ')
			 && m < lineEnd) m++;
			
			t->cursors[k].pos = m;
			AddStrToText(t, &k, "//");
			
			c->hiddenCursors = (Thoth_EditorCur *)realloc(c->hiddenCursors, sizeof(Thoth_EditorCur) * ++c->nHiddenCursors);
			Thoth_EditorCur *cur = &c->hiddenCursors[c->nHiddenCursors-1];			
			memset(cur, 0, sizeof(Thoth_EditorCur));
			cur->addedLen = 2;
			cur->pos = m+2;
			continue;
		}

		int toggled = 0;
		int startSelection = t->cursors[k].selection.startCursorPos;
		int endSelection = t->cursors[k].selection.startCursorPos+t->cursors[k].selection.len;
		int m;
		for(m = startSelection; m < endSelection; m++){
			
			while((t->file->text[m] == '\t' || t->file->text[m] == ' ')
			 && m < endSelection) m++;
			
			if(t->file->text[m] == '\n') continue;
			
			if((!toggled || toggled == 1) && strncmp(&t->file->text[m], "//", 2) == 0) {
				t->cursors[k].pos = m+2;
				toggled = 1;
				RemoveStrFromText(t, &k, 2);
				endSelection -= 2;

				c->hiddenCursors = (Thoth_EditorCur *)realloc(c->hiddenCursors, sizeof(Thoth_EditorCur) * ++c->nHiddenCursors);
				Thoth_EditorCur *cur = &c->hiddenCursors[c->nHiddenCursors-1];			
				memset(cur, 0, sizeof(Thoth_EditorCur));
				cur->pos = t->cursors[k].pos;
				cur->savedText = malloc(3);
				strcpy(cur->savedText,"//");

			} else if(!toggled || toggled == 2){

				c->hiddenCursors = (Thoth_EditorCur *)realloc(c->hiddenCursors, sizeof(Thoth_EditorCur) * ++c->nHiddenCursors);
				Thoth_EditorCur *cur = &c->hiddenCursors[c->nHiddenCursors-1];			
				memset(cur, 0, sizeof(Thoth_EditorCur));
				cur->addedLen = 2;
				cur->pos = m+2;

				t->cursors[k].pos = m;
				AddStrToText(t, &k, "//");
				endSelection+=2;
				m += 2;
				toggled = 2;
			}

			t->cursors[k].pos = startSelection;
			t->cursors[k].selection.len = endSelection - startSelection;
			for(; m < endSelection; m++)
				if(t->file->text[m] == '\n') break;
		}
	}

	SaveCursors(t,c);
}

static void UndoComment(Thoth_Editor *t, Thoth_EditorCmd *c){
	LoadCursors(t, c);

	RemoveExtraCursors(t);
	RemoveSelections(t);
	int k;
	for(k = 0; k < c->nHiddenCursors; k++){
		int index = c->hiddenCursors[k].hiddenIndex;
		t->cursors[index].pos = c->hiddenCursors[k].pos;

		if(c->hiddenCursors[k].addedLen){
			RemoveStrFromText(t, &index, c->hiddenCursors[k].addedLen);
			int m;
			for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos-=c->hiddenCursors[k].addedLen;
		}

		if(k < c->nHiddenCursors && c->hiddenCursors[k].savedText){
			AddStrToText(t, &index, c->hiddenCursors[k].savedText);
			int m;
			for(m = k; m < c->nHiddenCursors; m++) c->hiddenCursors[m].pos+=strlen(c->hiddenCursors[k].savedText);
		}
	}

	SaveCursors(t, c);

}


static void MoveBrackets(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(!t->file->text) return;

	t->file->textLen = strlen(t->file->text);

	int k;
	for(k = 0; k < t->nCursors; k++){
		int first, last;
		if(GetBetweenBrackets(t->file->text, t->file->textLen, t->cursors[k].pos, &first, &last)){
			if(last == t->cursors[k].pos){
				t->cursors[k].pos = first+1; 
			} else {
				t->cursors[k].pos = last;
			}
		}
	}


	ResolveCursorCollisions(t,0);
}

static void SelectBrackets(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(!t->file->text) return;

	t->file->textLen = strlen(t->file->text);

	int k;
	for(k = 0; k < t->nCursors; k++){

		Thoth_EditorCur *cursor = &t->cursors[k];
		int first, last;
		if(GetBetweenBrackets(t->file->text, t->file->textLen, cursor->pos, &first, &last)){
			if(last == cursor->pos){
				cursor->pos = first; 
			} else {
				cursor->pos = last;
			}
			cursor->selection.startCursorPos = first + 1;
			if(t->file->text[first+1] == '\n') cursor->selection.startCursorPos++;
			cursor->selection.len = (last - first) - 1; // exclude brackets from selection
			
			last--;
			while(t->file->text[last] == '\t' || t->file->text[last] == ' '
			 || t->file->text[last] == '\n') {cursor->selection.len--; last--;}
			cursor->pos = last;
		}
	}

	ResolveCursorCollisions(t,0);
}

static void ExpandSelectionLines(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(t->file->text == NULL) return;

	RemoveExtraCursors(t);
	t->file->textLen = strlen(t->file->text);

	int f;
	for(f = 0; f < t->nCursors; f++){

		Thoth_EditorCur *cursor = &t->cursors[f];
		if(cursor->selection.len == 0){
			cursor->selection.startCursorPos = 
			cursor->pos - GetCharsIntoLine(t->file->text, cursor->pos);
			if(cursor->pos == cursor->selection.startCursorPos) cursor->pos++;
		} else {
			cursor->pos++;
		}

		if(c->num < 0)
			cursor->pos = GetStartOfPrevLine(t->file->text, cursor->pos);
		else
			cursor->pos = GetStartOfNextLine(t->file->text, t->file->textLen, cursor->pos);

		if(cursor->pos < 0) cursor->pos = 0;
		if(cursor->pos > (int)t->file->textLen) cursor->pos = t->file->textLen;

		cursor->selection.len = cursor->pos - cursor->selection.startCursorPos;
	}
}

static void RemoveExtraCursorsCommand(Thoth_Editor *t, Thoth_EditorCmd *c){
	SaveCursors(t,c);
	RemoveSelections(t);
	RemoveExtraCursors(t);
	t->lastCmd = NULL;
	t->autoCompleteIndex = 0;
	UpdateScrollCenter(t);
}
static void UndoRemoveExtraCursorsCommand(Thoth_Editor *t, Thoth_EditorCmd *c){
	LoadCursors(t,c);
}

static void SelectAll(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(t->file->text == NULL) return;

	RemoveExtraCursors(t);
	t->file->textLen = strlen(t->file->text);
	t->cursors[0].selection.len = t->file->textLen;
	t->cursors[0].selection.startCursorPos = 0;
	t->cursors[0].pos = 0;
}

static void UndoDeleteLine(Thoth_Editor *t, Thoth_EditorCmd *c){

	UNUSED(c);

	if(t->file->text == NULL) return;

	// RemoveSelections(t);
	LoadCursors(t, c);
	// RefreshEditorCommand(c);

	int k;
	for(k = 0; k < t->nCursors; k++){

		// Thoth_EditorCur *cursor = &t->cursors[k];
		int pos = t->cursors[k].pos;
		AddStrToText(t, &k, c->savedCursors[k].savedText);
		t->cursors[k].pos = pos;

	}
	SaveCursors(t, c);
}

static void DeleteLine(Thoth_Editor *t, Thoth_EditorCmd *c){

	UNUSED(c);

	if(t->file->text == NULL) return;

	LoadCursors(t,c);
	// RefreshEditorCommand(c);
//	RemoveExtraCursors(t);
	RemoveSelections(t);

	int k = 0;
	for(k = 0; k < t->nCursors; k++){
	
		Thoth_EditorCur *cursor = &t->cursors[k];
	
		int start;
		int end;
	
		start = cursor->pos - GetCharsIntoLine(t->file->text, cursor->pos);
		end = GetStartOfNextLine(t->file->text,t->file->textLen, cursor->pos);
	
		cursor->pos = end;
		AddSavedText(t, &t->file->text[start], end-start, &k);
		RemoveStrFromText(t, &k, end-start);
	}
	SaveCursors(t,c);
}

static void X11Copy(Thoth_Editor *t){

	if(t->file->text == NULL) return;

	char *buffer = NULL;
	int bufferLen = 0;

	int k;
	for(k = 0; k < t->nCursors; k++){

		int start, end;

		start = t->cursors[k].selection.startCursorPos;
		end = start+t->cursors[k].selection.len;


		if(buffer){
			bufferLen += (end-start);
			if(t->nCursors > 1){
				bufferLen++;
			}
			buffer = realloc(buffer, bufferLen+1);
			if(t->nCursors > 1){
				buffer[bufferLen - 1] = '\n';
				memcpy(&buffer[bufferLen-((end-start)+1)], &t->file->text[start], end-start);
			} else {
				memcpy(&buffer[bufferLen-((end-start))], &t->file->text[start], end-start);
			}
			buffer[bufferLen] = 0;

		} else {
			bufferLen += (end-start);
			if(t->nCursors > 1){
				bufferLen++;
			}
			buffer = malloc(bufferLen+1);
			buffer[bufferLen] = 0;
			if(t->nCursors > 1) buffer[bufferLen - 1] = '\n';
			memcpy(buffer, &t->file->text[start], end-start);
		}

		 //if(t->cursors[k].clipboard) free(t->cursors[k].clipboard);

		 //t->cursors[k].clipboard = (char *)malloc((end-start) + 1);
		 //t->cursors[k].clipboard[end-start] = 0;

		 //memcpy(t->cursors[k].clipboard, &t->file->text[start], end-start);
	}
	if(buffer){
		if(t->clipboard) free(t->clipboard);
		bufferLen++;
		buffer = realloc(buffer, bufferLen+1);
		buffer[bufferLen-1] = '\n';
		buffer[bufferLen] = 0;
		t->clipboard=buffer;
#ifdef SDL_COMPILE
		SDL_SetClipboardText(t->clipboard);
#elif LINUX_COMPILE
		X11_Copy(&t->clipboard);
#endif 

	}

}

static void Copy(Thoth_Editor *t, Thoth_EditorCmd *c){
	UNUSED(c);
	X11Copy(t);
}

static void Cut(Thoth_Editor *t, Thoth_EditorCmd *c){

	LoadCursors(t,c);
	if(t->file->text == NULL) return;
	
	if(t->nCursors == 1 && t->cursors[0].selection.len == 0){
		t->file->textLen = strlen(t->file->text);

		int f;
		for(f = 0; f < t->nCursors; f++){

			Thoth_EditorCur *cursor = &t->cursors[f];
			if(cursor->selection.len == 0){
				cursor->selection.startCursorPos = 
				cursor->pos - GetCharsIntoLine(t->file->text, cursor->pos);
				if(cursor->pos == cursor->selection.startCursorPos) cursor->pos++;
			} else {
				cursor->pos++;
			}

			if(c->num < 0)
				cursor->pos = GetStartOfPrevLine(t->file->text, cursor->pos);
			else
				cursor->pos = GetStartOfNextLine(t->file->text, t->file->textLen, cursor->pos);

			if(cursor->pos < 0) cursor->pos = 0;
			if(cursor->pos > (int)t->file->textLen) cursor->pos = t->file->textLen;

			cursor->selection.len = cursor->pos - cursor->selection.startCursorPos;

		}
	}
	X11Copy(t);
	
	int k;
	for(k = 0; k < t->nCursors; k++)
		EraseAllSelectedText(t,&k,c);

	SaveCursors(t,c);
}

static void UndoCut(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(t->logging) return;

	LoadCursors(t, c);

	int k;
	for(k = t->nCursors-1; k >= 0; k--){
		int pos = t->cursors[k].pos;
		
		if(k < c->nSavedCursors && t->cursors[k].savedText){
			AddStrToText(t, &k, t->cursors[k].savedText);
		}
		t->cursors[k].selection.startCursorPos = pos;
		t->cursors[k].selection.len =t->cursors[k].pos -  pos;				
		t->cursors[k].pos = pos;
	}
	SaveCursors(t,c);
}

static void AddSavedText(Thoth_Editor *t, char *str, int len, int *cursorIndex){
	if(len <= 0) return;
	if(t->cursors[*cursorIndex].savedText){
		free(t->cursors[*cursorIndex].savedText);
	}
	//     int len2 = strlen(t->cursors[*cursorIndex].savedText);
	//     t->cursors[*cursorIndex].savedText = (char *)realloc(t->cursors[*cursorIndex].savedText, len2 + len + 1);
	//     t->cursors[*cursorIndex].savedText[len+len2] = 0;
	//     memcpy(&t->cursors[*cursorIndex].savedText[len2], str, len);
	// } else {
		t->cursors[*cursorIndex].savedText = (char *)malloc(len + 1);
		t->cursors[*cursorIndex].savedText[len] = 0;
		memcpy(t->cursors[*cursorIndex].savedText, str, len);
	// }
}

static void EraseAllSelectedText(Thoth_Editor *t, int *cursorIndex, Thoth_EditorCmd *command){
		

	if(t->file->text == NULL) return;
	
	Thoth_EditorCur *cursor = &t->cursors[*cursorIndex];

	if(t->file->text == NULL || cursor->selection.len == 0) return;

	int textLen = strlen(t->file->text);

	int startCursorPos, endCursorPos;

	startCursorPos = cursor->selection.startCursorPos;
	endCursorPos = startCursorPos + cursor->selection.len;

	int newSize = textLen - (endCursorPos - startCursorPos);

	AddSavedText(t, &t->file->text[startCursorPos], cursor->selection.len, cursorIndex);
	cursor->pos = endCursorPos;
	RemoveStrFromText(t, cursorIndex, cursor->selection.len);
	

	if(newSize <= 0){
		if(t->file->text) free(t->file->text);
		t->file->text = malloc(1);
		t->file->text[0] = 0;
		return;
	} else {
		t->file->textLen = strlen(t->file->text);
	}

}

static void PutsCursor(Thoth_Editor *t, Thoth_EditorCur c){
	
	fprintf(t->logFile, "CURSOR:\n");
	fprintf(t->logFile, "\tselection: startPos: %i len: %i \n", 
		c.selection.startCursorPos, c.selection.len);

	if(c.clipboard)
		fprintf(t->logFile, "\tclipboard: %s \n", c.clipboard);

	if(c.savedText)
		fprintf(t->logFile, "\tsavedText: %s \n", c.savedText);

	fprintf(t->logFile, "\taddedLen: %i\n", c.addedLen);
	fprintf(t->logFile, "\tpos: %i\n", c.pos);
}

static void SaveCursors(Thoth_Editor *t, Thoth_EditorCmd *c){
	
	fprintf(t->logFile, "SAVEDCURSORS:\n");
	
	int k;

	for(k = 0; k < c->nSavedCursors; k++){
		 PutsCursor(t, c->savedCursors[k]);
	}

	if(c->savedCursors){

		free(c->savedCursors);
	}
	

	c->savedCursors = (Thoth_EditorCur *)malloc(sizeof(Thoth_EditorCur) * t->nCursors);
	c->nSavedCursors = t->nCursors;

	for(k = 0; k < t->nCursors; k++){

		if(t->cursors[k].pos < 0) t->cursors[k].pos = 0;

		memcpy(&c->savedCursors[k], &t->cursors[k], sizeof(Thoth_EditorCur));

		if(t->cursors[k].savedText){
			int len = strlen(t->cursors[k].savedText);
			c->savedCursors[k].savedText = malloc(len+1);
			c->savedCursors[k].savedText[len] = 0;
			memcpy(c->savedCursors[k].savedText, t->cursors[k].savedText, len);
			free(t->cursors[k].savedText);
			t->cursors[k].savedText = NULL;
		}
		t->cursors[k].addedLen = 0;
	}

}

static void LoadCursors(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(c->nSavedCursors <= 0){
		SaveCursors(t, c);
		return;
	}

	// FreeCursors(t);
	// t->cursors = (Thoth_EditorCur *)malloc(sizeof(Thoth_EditorCur) * c->nSavedCursors);

	t->cursors = (Thoth_EditorCur *)realloc(t->cursors, sizeof(Thoth_EditorCur) * c->nSavedCursors);

	t->nCursors = c->nSavedCursors;

	int k;
	for(k = 0; k < c->nSavedCursors; k++){
		memcpy(&t->cursors[k], &c->savedCursors[k], sizeof(Thoth_EditorCur));
	}
}

static void AddStrToText(Thoth_Editor *t, int *cursorIndex, char *text){

	t->file->unsaved = 1;

	int len = strlen(text);

	int pos = t->cursors[*cursorIndex].pos;

	int textLen = strlen(t->file->text);
	
	if(pos > textLen) pos = textLen;

	if(textLen > 0){
		char *text1 = (char *)malloc(textLen);

		memcpy(text1,t->file->text,textLen);

		free(t->file->text);
		t->file->text = (char *)malloc(textLen+len+1);
		t->file->text[textLen+len] = 0;
	
		memcpy(t->file->text, text1, pos);

		if(textLen - pos > 0){
			memcpy(&t->file->text[pos + len], &text1[pos], (textLen - pos));
		}
		free(text1);

		memcpy(&t->file->text[pos], text, len);
	
	} else {
		t->file->text = (char *)realloc(t->file->text,len+1);
		memcpy(&t->file->text[0], text, len);
		t->file->text[len] = 0;
	}

	t->file->text[textLen + len] = 0;


	t->file->textLen = strlen(t->file->text);
	t->cursors[*cursorIndex].pos += len;
	MoveCursorsAndSelection(t, pos, len, cursorIndex);
}

static void RemoveStrFromText(Thoth_Editor *t, int *cursorIndex, int len){
	if(t->file->text == NULL) return;

	int pos = t->cursors[*cursorIndex].pos;
	if(pos < 0) return;

	t->file->unsaved = 1;

	if(pos - len < 0) len = pos;

	pos -= len;


	int textLen = strlen(t->file->text);

	if(pos <= textLen){
		len = pos + len >= textLen ? textLen - pos : len;
		memcpy(&t->file->text[pos], &t->file->text[pos+len], textLen - (pos + len));
	}

	t->file->text = (char *)realloc(t->file->text, (textLen - len) + 1);

	Thoth_EditorCur *cur = &t->cursors[*cursorIndex];
	
	// fixes bug
	cur->selection.len = cur->selection.len > len ? 
	cur->selection.len - len : 0;
	// cur->selection.startCursorPos = pos;

	t->file->text[textLen - len] = 0;
	t->file->textLen = strlen(t->file->text);
	t->cursors[*cursorIndex].pos = pos;
	MoveCursorsAndSelection(t, pos, -len, cursorIndex);
}

static void UndoRemoveCharacters(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(t->logging) return;

	LoadCursors(t, c);

	int k;
	for(k = t->nCursors-1; k >= 0; k--){

		if(k < c->nSavedCursors && t->cursors[k].savedText){
			AddStrToText(t, &k, t->cursors[k].savedText);
		}
	}

	SaveCursors(t,c);

}

static void AutoComplete(Thoth_Editor *t){

	t->autoCompleteLen = 0;
	if(t->autoCompleteSearchLen > 0 && t->nCursors == 1){
		if(t->autoCompleteSearchLen > THOTH_MAX_AUTO_COMPLETE_STRLEN) return;

		Thoth_EditorCur *c = &t->cursors[t->nCursors-1];


		if(t->autoCompleteSearchLen > 3 && t->autoCompleteSearchLen < THOTH_MAX_AUTO_COMPLETE_STRLEN){

			int search = c->pos - t->autoCompleteSearchLen;
			int findEnd = 0;
			int res;

			while(findEnd+t->autoCompleteSearchLen < t->file->textLen &&
				(res = Find(&t->file->text[findEnd], &t->file->text[search], t->autoCompleteSearchLen)) != -1){

				if(findEnd+res == search){
					findEnd = c->pos;
					continue;
				}

				int j;
				for(j = 0; findEnd + res + j < t->file->textLen && 
					j < THOTH_MAX_AUTO_COMPLETE_STRLEN && 
					!IsToken(t->file->text[findEnd+res+j]); j++){
				}


				int m;
				for(m = 0; m < t->autoCompleteLen; m++){
					if(t->autoComplete[m].len == j && 
						memcmp(&t->file->text[t->autoComplete[m].offset], &t->file->text[findEnd+res],j) == 0){
		
						break;
					}
				}
				if(m != t->autoCompleteLen) {
					findEnd += res + j;
					continue;
				}



				t->autoComplete[t->autoCompleteLen].offset = findEnd+res;
				t->autoComplete[t->autoCompleteLen].len = j;
				++t->autoCompleteLen;
				findEnd += res + j;
				if(t->autoCompleteLen >= THOTH_MAX_AUTO_COMPLETE) break;
			}
		}

	}
}

static void ScrollScreen(Thoth_Editor *t, Thoth_EditorCmd *c){
	RemoveSelections(t);
	RemoveExtraCursors(t);

	int scroll = t->linesY;
	int k = 0;

	if(c->num < 0){
		for(k = t->cursors[0].pos; k > 0; k--){
			if(t->file->text[k] == '\n'){
				scroll--;
				if(scroll == 0) { 
					k++;
					break; 
				}
			}
		}
	}else{
		for(k = t->cursors[0].pos; k < strlen(t->file->text); k++){
			if(t->file->text[k] == '\n'){
				scroll--;
				if(scroll == 1) {
					k++;
					break;
				}
			}
		}
	}

	t->cursors[0].pos = k;
}


static void RemoveCharacters(Thoth_Editor *t, Thoth_EditorCmd *c){


	if(t->file->text == NULL) return;

	LoadCursors(t, c);

	// RefreshEditorCommand(c);


	int k;
	for(k = 0; k < t->nCursors; k++){

		if(t->cursors[k].selection.len == 0){
			if(t->cursors[k].pos >= c->num){
				AddSavedText(t, &t->file->text[t->cursors[k].pos-c->num], c->num, &k);
				RemoveStrFromText(t, &k, c->num);
			}
		} else {
			EraseAllSelectedText(t, &k, c);
		}
	}

	SaveCursors(t, c);

	if(t->autoCompleteSearchLen > 0){
		t->autoCompleteSearchLen -= c->num;
		AutoComplete(t);
	}

	for(k = 0; k < t->nCursors; k++)
		memset(&t->cursors[k].selection, 0, sizeof(Thoth_EditorSelection));

}

static void UndoAddCharacters(Thoth_Editor *t, Thoth_EditorCmd *c){
	
	if(t->file->text == NULL) return;

	LoadCursors(t, c);

	int k;
	for(k = c->nSavedCursors-1; k >= 0; k--){
		RemoveStrFromText(t, &k, strlen(c->keys));
		if(k < c->nSavedCursors && c->savedCursors[k].savedText){
			t->cursors[k].selection.startCursorPos = t->cursors[k].pos;
			AddStrToText(t, &k, c->savedCursors[k].savedText);
			t->cursors[k].selection.len = strlen(c->savedCursors[k].savedText);
		
		}
	}

	if(t->autoCompleteSearchLen > 0){
		t->autoCompleteSearchLen -= strlen(c->keys);
		if(t->autoCompleteSearchLen > 0)
			AutoComplete(t);
		else {
			t->autoCompleteSearchLen = 0;
		}
	}

	SaveCursors(t, c);

	c->num = 0;

}

// static void RefreshEditorCommand(Thoth_EditorCmd *c){

	// if(c->addedLens) free(c->addedLens);

	// if(c->savedTexts){

	//     int k;
	//     for(k = 0; k < c->nSavedCursors; k++)
	//         if(c->savedTexts[k]) free(c->savedTexts[k]);
	
	//     free(c->savedTexts);
	// }

	// c->addedLens = (int *)malloc(c->nSavedCursors * sizeof(int));
	// memset(c->addedLens, 0, sizeof(int) * c->nSavedCursors);

	// c->savedTexts = (char **)malloc(c->nSavedCursors * sizeof(char*));
	// memset(c->savedTexts, 0, sizeof(char*) * c->nSavedCursors);
// }


static void LoggingRemoveCharacter(Thoth_Editor *t){
	if(t->logging < THOTH_LOGMODE_MODES_INPUTLESS){
		
		t->logIndex = -1;

		if(t->loggingText){
	
			int searchLen = strlen(t->loggingText);
	
			if(searchLen - 1 <= 0){
				free(t->loggingText);
				t->loggingText = NULL;
				return;
			} else {
				t->loggingText = realloc(t->loggingText, searchLen);
				t->loggingText[searchLen-1] = 0;
			}
		}
	}

	if(t->logging == THOTH_LOGMODE_FILEBROWSER){
		if(t->loggingText){
			if(t->loggingText[strlen(t->loggingText)-1] == '/' ||
				t->loggingText[strlen(t->loggingText)-1] == '\\'){
				strcpy(t->fileBrowser.directory, t->loggingText);
				Thoth_FileBrowser_ChangeDirectory(&t->fileBrowser);
			}
		}
	}
}
static void LoggingMoveLines(Thoth_Editor *t, int num){

	if(t->logging == THOTH_LOGMODE_FILEBROWSER || t->logging == THOTH_LOGMODE_SWITCH_FILE){
		
		int nFiles = t->logging == THOTH_LOGMODE_FILEBROWSER ? t->fileBrowser.nFiles : t->nFiles;
		
		if( (t->loggingText == NULL || strlen(t->loggingText) == 0)){
			t->logIndex += num;
			if(t->logIndex < 0) t->logIndex = 0;
			if(t->logIndex > nFiles-1) t->logIndex = nFiles-1;
		}
		
		if(t->loggingText && strlen(t->loggingText) > 0){
			t->logIndex += num;
			if(t->logIndex < 0) t->logIndex = 0;
	
			int nMatching = 0;
			int k;
			for(k = 0; k < nFiles; k++){
				char *name = t->logging == THOTH_LOGMODE_FILEBROWSER ? t->fileBrowser.files[k].name : t->files[k]->name;
				int nameLen = strlen(name);
				int logNameLen = strlen(Thoth_basename(t->loggingText));
				if(logNameLen <= nameLen){
					if(CaseLowerStrnCmp(Thoth_basename(t->loggingText), name, logNameLen))
						nMatching++;

				}
			}
			if(t->logIndex >= nMatching) t->logIndex = nMatching-1;

		}

		return;
	}
}
static void LoggingAddCharacter(Thoth_Editor *t, char c){

	if(t->logging == THOTH_LOGMODE_NUM && !IsDigit(c)) return;


	if(t->logging < THOTH_LOGMODE_MODES_INPUTLESS){

		if(t->loggingText){
			int searchLen = strlen(t->loggingText);
			t->loggingText = realloc(t->loggingText, searchLen+2);
			t->loggingText[searchLen] = c;
			t->loggingText[searchLen+1] = 0;
		}
		else{
			t->logIndex = 0;
			t->loggingText = malloc(2);
			t->loggingText[0] = c;
			t->loggingText[1] = 0;
		}
	}

	if(t->logging == THOTH_LOGMODE_FILEBROWSER){
		if(t->loggingText){
			if(c == '/' || c == '\\'){
				strcpy(t->fileBrowser.directory, t->loggingText);
				Thoth_FileBrowser_ChangeDirectory(&t->fileBrowser);
			}
		}
	}
}

static void LoggingPaste(Thoth_Editor *t){
#ifndef SDL_COMPILE
#ifdef LINUX_COMPILE
	X11_Paste(&t->clipboard);
#endif
#endif
	if(t->clipboard){
		
		int k;
		for(k = 0; k < strlen(t->clipboard); k++){
			if(t->clipboard[k] == '\n') break;
			LoggingAddCharacter(t, t->clipboard[k]);
		}
	}
}

static void AddCharacters(Thoth_Editor *t, Thoth_EditorCmd *c){
	
	if(t->file->text == NULL) return;

	LoadCursors(t, c);

	// RefreshEditorCommand(c);

	int k;
	char *keys = &c->keys[c->num];
	c->num = strlen(c->keys);

	// make sure autocomplete only starts after a token, if canceled.
	if(t->autoCompleteSearchLen > 0 || (t->cursors[0].pos > 0 &&
		IsToken(t->file->text[t->cursors[0].pos-1]))){
		for(k = 0; k < strlen(keys); k++){
			if(!IsToken(keys[k])){
				t->autoCompleteSearchLen++;
			} else {
				t->autoCompleteSearchLen = 0;
			}
		}        
	}

	if(keys[0] == '}' && t->nCursors == 1){
		int into = t->cursors[0].pos - GetCharsIntoLine(t->file->text, t->cursors[0].pos);
		int tabs = 0;
		int k;
		for(k = into; k < t->cursors[0].pos; k++){
			if(t->file->text[k] != '\t') break;
			 tabs++;
		}
		if(k == t->cursors[0].pos && tabs > 0) {
			int index = 0;
			RemoveStrFromText(t,&index,1);
			t->cursors[0].savedText = malloc(2);
			t->cursors[0].savedText[0] = '\t';
			t->cursors[0].savedText[1] = 0;
		}
	}

	for(k = 0; k < t->nCursors; k++){
		EraseAllSelectedText(t, &k, c);
	}
	for(k = 0; k < t->nCursors; k++){
		AddStrToText(t, &k, keys);
		t->cursors[k].addedLen += strlen(keys);
	}


	SaveCursors(t, c);

	for(k = 0; k < t->nCursors; k++)
		memset(&t->cursors[k].selection, 0, sizeof(Thoth_EditorSelection));

	AutoComplete(t);


}
static void ExpandAddCharacters(Thoth_Editor *t, Thoth_EditorCmd *c){
	
	if(t->file->text == NULL) return;

	LoadCursors(t, c);

	// RefreshEditorCommand(c);

	int k;
	char *keys = &c->keys[c->num];
	c->num = strlen(c->keys);


	// make sure autocomplete only starts after a token, if canceled.
	if(t->autoCompleteSearchLen > 0 || (t->cursors[0].pos > 0 &&
		IsToken(t->file->text[t->cursors[0].pos-1]))){
		for(k = 0; k < strlen(keys); k++){
			if(!IsToken(keys[k])){
				t->autoCompleteSearchLen++;
			} else {
				t->autoCompleteSearchLen = 0;
			}
		}        
	}

	for(k = 0; k < t->nCursors; k++){
		AddStrToText(t, &k, keys);
		t->cursors[k].addedLen += strlen(keys);
	}


	SaveCursors(t, c);

	for(k = 0; k < t->nCursors; k++)
		memset(&t->cursors[k].selection, 0, sizeof(Thoth_EditorSelection));

	AutoComplete(t);


}

static void Undo(Thoth_Editor *t, Thoth_EditorCmd *c){

	UndoCommands(t, c->num);
}

static void Redo(Thoth_Editor *t, Thoth_EditorCmd *c){

	RedoCommands(t, c->num);
}

static void FreeCommand(Thoth_EditorCmd *c){

	if(c->keys) free(c->keys);

	if(c->savedCursors){

		int k;
		for(k = 0; k < c->nSavedCursors; k++){
			if(c->savedCursors[k].savedText) free(c->savedCursors[k].savedText);
		}
		free(c->savedCursors);
	}
	if(c->hiddenCursors){

		int k;
		for(k = 0; k < c->nHiddenCursors; k++){
			if(c->hiddenCursors[k].savedText) free(c->hiddenCursors[k].savedText);
		}
		free(c->hiddenCursors);
	}
	
	// if(c->savedTexts){

	//     int k;
	//     for(k = 0; k < c->nSavedCursors; k++)
	//         free(c->savedTexts[k]);

	//     free(c->savedTexts);
	// }

	// if(c->addedLens) free(c->addedLens);

	free(c);
}

static Thoth_EditorCmd *CopyCommand(Thoth_EditorCmd *c){

	Thoth_EditorCmd *ret = CreateCommand(c->name,(const unsigned int *)c->keyBinding, c->keys, c->num, c->scroll, c->Execute, c->Undo);

	ret->savedCursors = (Thoth_EditorCur *)malloc(sizeof(Thoth_EditorCur) * c->nSavedCursors);
	ret->nSavedCursors = c->nSavedCursors;

	int k;
	for(k = 0; k < c->nSavedCursors; k++){

		memcpy(&ret->savedCursors[k], &c->savedCursors[k], sizeof(Thoth_EditorCur));

		if(c->savedCursors[k].savedText){
			int len = strlen(c->savedCursors[k].savedText);
			ret->savedCursors[k].savedText = malloc(len+1);
			ret->savedCursors[k].savedText[len] = 0;
			memcpy(ret->savedCursors[k].savedText, c->savedCursors[k].savedText, len);
		}
	}

	return ret;
}

static Thoth_EditorCmd *CreateCommand(const char *name, const unsigned int binding[], const char *keys, int n, int scroll,
	void (*E)(Thoth_Editor *, Thoth_EditorCmd *), void (*U)(Thoth_Editor *, Thoth_EditorCmd *)){

	Thoth_EditorCmd *res = (Thoth_EditorCmd *)malloc(sizeof(Thoth_EditorCmd));
	memset(res, 0, sizeof(Thoth_EditorCmd));

	strcpy(res->name, name);
	res->scroll = scroll;
	res->num = n;

	if(binding){

		int len = 0;
		while(binding[len] != 0) len++;
		res->keyBinding[len] = 0;
		memcpy(res->keyBinding, binding, len * sizeof(unsigned int));
	}

	if(keys){
		res->keys = (char *)malloc(strlen(keys)+1);
		res->keys[strlen(keys)] = 0;
		memcpy(res->keys, keys, strlen(keys));
	}

	res->Undo = U;
	res->Execute = E;

	return res;

}

static void UndoCommands(Thoth_Editor *t, int num){
	t->lastCmd = NULL;
	if(t->file->historyPos == 0 || t->file->historyPos - num < 0)
		return;

	Thoth_EditorCmd *cmd;

	int k;
	for(k = 0; k < num; k++){

		cmd = t->file->history[(t->file->historyPos-1)-k];
		
		if(cmd->Undo){
			
			cmd->Undo(t, cmd);
			
			if(cmd->scroll == SCR_CENT)
				UpdateScrollCenter(t);
			else
				UpdateScroll(t);
		}
	}

	t->file->historyPos -= num;
}

static void RedoCommands(Thoth_Editor *t, int num){

	if(t->file->historyPos + num > t->file->sHistory)
		num = t->file->sHistory - t->file->historyPos;

	if(num <= 0) return;
	
	int k;
	for(k = 0; k < num; k++){
		t->file->history[(t->file->historyPos)+k]->Execute(t, t->file->history[(t->file->historyPos)+k]);
		if(t->file->history[(t->file->historyPos)+k]->scroll == SCR_CENT)
			UpdateScrollCenter(t);
		else
			UpdateScroll(t);
	}

	t->file->historyPos += num;

}

static void RemoveExtraCursors(Thoth_Editor *t){
	int k;
	for(k = t->nCursors-2; k >= 0; k--){
		if(t->cursors[k].savedText) free(t->cursors[k].savedText);
		t->cursors[k].savedText = NULL;
	}
	memcpy(&t->cursors[0], &t->cursors[t->nCursors-1], sizeof(Thoth_EditorCur));
	t->cursors = (Thoth_EditorCur *)realloc(t->cursors, sizeof(Thoth_EditorCur));
	t->nCursors = 1;
	UpdateScrollCenter(t);
}

static void ExecuteCommand(Thoth_Editor *t, Thoth_EditorCmd *c){

	if(c->Undo == NULL || t->logging){
		t->lastCmd = NULL;
		c->Execute(t, c);
		fprintf(t->logFile,"NOUNDO or LOGGING| %s, (%s)\n", c->name, c->keys);
		if(c->scroll == SCR_CENT)
			UpdateScrollCenter(t);
		else
			UpdateScroll(t);
		return;
	}


	if(t->file->historyPos <= t->file->sHistory){

		int k;
		for(k = t->file->historyPos; k < t->file->sHistory; k++){
			FreeCommand(t->file->history[k]);
		}

		t->file->sHistory = t->file->historyPos;
	}
	Thoth_EditorFile *f = t->file;
	
	char **lastKeys = NULL;
	int lastLen = 0;
	if(t->lastCmd){
		lastKeys = &(*t->lastCmd)->keys;
		if(*lastKeys) lastLen = strlen(*lastKeys);
	}

	typedef void (*EditFunc)(Thoth_Editor*, Thoth_EditorCmd*);

	EditFunc BufferExpandFuncs[2] = {
		AddCharacters,
		//RemoveCharacters
	};
	int BufferExpandFuncsLen = sizeof(BufferExpandFuncs)/sizeof(EditFunc);

	int k;
	for(k = 0; k < BufferExpandFuncsLen; k++){
		if(BufferExpandFuncs[k] == c->Execute
			&& t->lastCmd && (*t->lastCmd)->Execute == BufferExpandFuncs[k]
			 && ( ( c->keys && !IsToken(c->keys[0]) && 
			 lastKeys &&  lastLen > 0 && !IsToken((*lastKeys)[lastLen-1]))))
			{
			if(c->keys){
				(*t->lastCmd)->num = lastLen;
				(*t->lastCmd)->keys = realloc(*lastKeys, lastLen + strlen(c->keys) + 1);
				strcpy(&((*lastKeys)[lastLen]),c->keys);
						
				// (*t->lastCmd)->Execute(t,*t->lastCmd);
				ExpandAddCharacters(t, *t->lastCmd);
				fprintf(t->logFile,"EXPAND ADD CHARACTERS | (%s)\n", c->keys);
				(*t->lastCmd)->num = lastLen + strlen(c->keys);
			}
			break;
		}
	}
	
	if(k == BufferExpandFuncsLen){
		f->history = (Thoth_EditorCmd **)realloc(f->history, 
			++f->sHistory * sizeof(Thoth_EditorCmd *));
		
		ClearAutoComplete(t);
		
		t->lastCmd = &f->history[f->sHistory-1];
		*t->lastCmd = CopyCommand(c);
		(*t->lastCmd)->Execute(t,*t->lastCmd);
		fprintf(t->logFile,"COMMAND %s  | (%s) %i\n", c->name, c->keys, c->num);

		if(c->keys && IsToken(c->keys[0])){
			t->lastCmd = NULL;
		}
		f->historyPos++;
	}

	
	if(c->scroll == SCR_CENT)
		UpdateScrollCenter(t);
	else
		UpdateScroll(t);
	
}

static void AddCommand(Thoth_Editor *t, Thoth_EditorCmd *c){
	t->commands = (Thoth_EditorCmd **)realloc(t->commands, ++t->nCommands * sizeof(Thoth_EditorCmd *));
	t->commands[t->nCommands-1] = c;
}

static int AddFile(Thoth_Editor *t, Thoth_EditorFile *f){

	if(strlen(f->path) > 0){
		int k;
		for(k = 0; k < t->nFiles; k++){
			if(strlen(t->files[k]->path) > 0 && strcmp(t->files[k]->path, f->path) == 0)
				return k;

		}
	}

	t->files = (Thoth_EditorFile **)realloc(t->files, ++t->nFiles * sizeof(Thoth_EditorFile *));
	t->files[t->nFiles-1] = f;
	return -1;
}

static void FreeFile(Thoth_EditorFile *f){
	if(f->text) free(f->text);
	int k;
	for(k = 0; k < f->sHistory; k++)
		FreeCommand(f->history[k]);

#ifndef SDL_COMPILE
#ifdef LINUX_COMPILE
	if(f->img.pixels) X11_DestroyImage(&f->img);	
#endif
#endif
	if(f->history) free(f->history);
	free(f);
}

static Thoth_EditorFile *CreateTextEditorFile(char *path){
	Thoth_EditorFile *ret = (Thoth_EditorFile *)malloc(sizeof(Thoth_EditorFile));
	memset(ret, 0, sizeof(Thoth_EditorFile));
	if(path != NULL){
		strcpy(ret->path, path);
		int k = strlen(path);
		for(; k >= 0; k--){
#ifdef LINUX_COMPILE
			if(path[k] == '/'){
#elif WINDOWS_API_COMPILE
			if(path[k] == '\\'){
#else
			if(path[k] == '/'){
#endif
				k++;
				break;
			}
		}
		if(k < 0) k++;
		strcpy(ret->name, &path[k]);

	}
	return ret;
}

void Thoth_Editor_LoadFile(Thoth_Editor *t, char *pathRel){

	if(t->file && t->cursors)
		t->file->cursorPos = t->cursors[0].pos;

	if(pathRel == NULL){
		t->file = CreateTextEditorFile(NULL);
		t->file->text = malloc(1);
		t->file->text[0] = 0;
		strcpy(t->file->name, "new file");
		AddFile(t, t->file);
		goto endfile;
	}


	char path[MAX_PATH_LEN] = {0};
#ifdef WINDOWS_COMPILE
	GetFullPathName(pathRel, MAX_PATH_LEN, path, NULL);
#endif
#ifdef LINUX_COMPILE
	char *tmp = realpath(pathRel, NULL);
	if(tmp){
		strcpy(path, tmp);
		free(tmp);
	}

#endif

	Thoth_EditorFile *file = CreateTextEditorFile(path);


	int exists = -1;
	if((exists = AddFile(t, file)) >= 0){
		FreeFile(file);
		t->file = t->files[exists];
		// check to reload?
		goto endfile;
	} else {
		t->file = file;
	}


	t->file->text = NULL;
	FILE *fp = fopen(path, "r");

	if(!fp){
		t->file->text = malloc(1);
		t->file->text[0] = 0;
		goto endfile;
	}

	int ext = strlen(path);
	for(; ext > 0; --ext){
		if(path[ext] == '.') break;
	}
#ifndef SDL_COMPILE
#ifdef LINUX_COMPILE
	if(strcmp(&path[ext], ".png")==0){
		StartLogging(t, THOTH_LOGMODE_IMAGE);
		X11_LoadPNG(fp, &t->file->img);
		return;
	} else if(strcmp(&path[ext], ".jpg") == 0){
		StartLogging(t, THOTH_LOGMODE_IMAGE);
		X11_LoadJPEG(fp, &t->file->img);
		return;
	}
#endif
#endif
	int m;
	for(m = strlen(path); m > 0; m--){
#ifdef WINDOWS_COMPILE
		if(path[m] == '\\') break;
#endif
#ifdef LINUX_COMPILE
		if(path[m] == '/') break;
#endif
	}

	strncpy(t->fileBrowser.directory, path, m);
	t->fileBrowser.directory[m] = 0;
	Thoth_FileBrowser_ChangeDirectory(&t->fileBrowser);
	
	fseek(fp, 0, SEEK_END);

	int len = ftell(fp);

	rewind(fp);

	// 1 mb
	if(len > (1 << 20) * 1) len = (1 << 20) * 1;  
	//not enough checking. but itll save it from opening images on accident and crashing.

	t->file->text = (char *)malloc(len + 1);
	fread(t->file->text, sizeof(unsigned char), len, fp);
	t->file->text[len] = '\0';
	int k;
	for(k = 0; k < len-1; k++){
		if(t->file->text[k] == '\r' ){
			for( m = k; m < len-1; m++){
				t->file->text[m] = t->file->text[m+1]; 
			}
			k--; 
			len--;
		}

	}
	for(k = 0; k < len-1; k++){
		if(t->file->text[k] == '\n' || k == 0){
			k++;
			for( m = k; m < len-1 && m-k < t->cfg->tabs; m++){
				if(t->file->text[m] != ' ') break;
			}
			if(m-k == t->cfg->tabs){
				int x;
				for(x = 0; x < t->cfg->tabs; x++){
					for( m = k; m < len-1; m++){
						t->file->text[m] = t->file->text[m+1];
					}
					len--;
				}
				t->file->text[k] = '\t'; 
			}
		}
	}
	t->file->text[len] = 0;

	t->file->textLen = len;
	fclose(fp);

endfile:
	RefreshFile(t);
}

#ifdef SDL_COMPILE
void Thoth_Editor_Init(Thoth_Editor *t,Thoth_Graphics *graphics, Thoth_Config *cfg){
	memset(t, 0, sizeof(Thoth_Editor));
	t->cfg = cfg;
	t->graphics = graphics;
#else
void Thoth_Editor_Init(Thoth_Editor *t,Thoth_Config *cfg){
	memset(t, 0, sizeof(Thoth_Editor));
	t->cfg = cfg;
#endif
#ifdef SDL_COMPILE

	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_SIDE_NUMBERS, THOTH_COLOR_WHITE, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_NORMAL, THOTH_COLOR_WHITE, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_KEYWORD, THOTH_COLOR_CYAN, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_COMMENT, THOTH_COLOR_GREY, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_TOKEN, THOTH_COLOR_GREEN, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_NUM, THOTH_COLOR_RED, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_FUNCTION, THOTH_COLOR_YELLOW, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_STRING, THOTH_COLOR_MAGENTA, THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_SELECTED, THOTH_COLOR_BLACK ,THOTH_COLOR_CYAN);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_SELECTED_DIRECTORY, THOTH_COLOR_RED ,THOTH_COLOR_CYAN);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_UNSELECTED_DIRECTORY, THOTH_COLOR_RED ,THOTH_COLOR_WHITE);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_AUTO_COMPLETE, THOTH_COLOR_BLACK, THOTH_COLOR_WHITE);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_LOG_UNSELECTED, THOTH_COLOR_BLACK, THOTH_COLOR_WHITE);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_CURSOR, THOTH_COLOR_BLACK ,THOTH_COLOR_MAGENTA);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_FIND, THOTH_COLOR_BLACK ,THOTH_COLOR_WHITE);
	Thoth_Graphics_init_pair(t->graphics,THOTH_COLOR_LINE_NUM, THOTH_COLOR_GREY ,THOTH_COLOR_BLACK);

	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_BLACK, THOTH_COLOR_BLACK ,THOTH_COLOR_WHITE);
	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_WHITE, THOTH_COLOR_WHITE ,THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_CYAN, THOTH_COLOR_CYAN ,THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_RED, THOTH_COLOR_RED ,THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_YELLOW, THOTH_COLOR_YELLOW ,THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_BLUE, THOTH_COLOR_BLUE ,THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_GREEN, THOTH_COLOR_GREEN ,THOTH_COLOR_BLACK);
	Thoth_Graphics_init_pair(t->graphics,THOTH_TE_COLOR_MAGENTA, THOTH_COLOR_MAGENTA ,THOTH_COLOR_BLACK);

#else
#ifdef LINUX_COMPILE
	initscr();
	curs_set(0);
	raw();
	cbreak();
	noecho();
	keypad(stdscr, FALSE);
	start_color();
	use_default_colors();

	init_pair(THOTH_COLOR_NORMAL, -1, -1);
	init_pair(THOTH_COLOR_KEYWORD, COLOR_CYAN, -1);
	init_pair(THOTH_COLOR_COMMENT, COLOR_WHITE, -1);
	init_pair(THOTH_COLOR_TOKEN,COLOR_GREEN, -1);
	init_pair(THOTH_COLOR_NUM, COLOR_RED, -1);
	init_pair(THOTH_COLOR_FUNCTION, COLOR_YELLOW, -1);
	init_pair(THOTH_COLOR_STRING, COLOR_MAGENTA, -1);

	init_pair(THOTH_COLOR_SELECTED, COLOR_BLACK ,COLOR_GREEN);
	init_pair(THOTH_COLOR_SELECTED_DIRECTORY, COLOR_RED ,COLOR_CYAN);
	init_pair(THOTH_COLOR_UNSELECTED_DIRECTORY, COLOR_RED ,COLOR_WHITE);
	init_pair(THOTH_COLOR_AUTO_COMPLETE, COLOR_BLACK, COLOR_WHITE);
	init_pair(THOTH_COLOR_LOG_UNSELECTED, COLOR_BLACK, COLOR_WHITE);
	init_pair(THOTH_COLOR_CURSOR,COLOR_BLACK ,COLOR_MAGENTA);
	init_pair(THOTH_COLOR_FIND, COLOR_BLACK ,COLOR_WHITE);
	init_pair(THOTH_COLOR_LINE_NUM, COLOR_WHITE ,-1);
	init_pair(THOTH_COLOR_LINENUM_CURSOR, COLOR_BLACK ,COLOR_GREEN);
	init_pair(THOTH_TE_COLOR_BLACK, COLOR_BLACK ,-1);
	init_pair(THOTH_TE_COLOR_WHITE, -1 ,-1);
	init_pair(THOTH_TE_COLOR_CYAN, COLOR_CYAN ,-1);
	init_pair(THOTH_TE_COLOR_RED, COLOR_RED ,-1);
	init_pair(THOTH_TE_COLOR_YELLOW, COLOR_YELLOW ,-1);
	init_pair(THOTH_TE_COLOR_BLUE, THOTH_COLOR_BLUE ,-1);
	init_pair(THOTH_TE_COLOR_GREEN, COLOR_GREEN ,-1);
	init_pair(THOTH_TE_COLOR_MAGENTA, COLOR_MAGENTA ,-1);

	bkgd(COLOR_PAIR(THOTH_COLOR_NORMAL));	
	clear();
	timeout(50);
#endif
#endif

	t->logFile = fopen(THOTH_LOGCOMPILEFILE, "w");
	AddCommand(t, CreateCommand("RemoveExtraCursors",(unsigned int[]){t->cfg->keybinds[THOTH_RemoveExtraCursors] , 0}, "", -1, SCR_NORM, RemoveExtraCursorsCommand, UndoRemoveExtraCursorsCommand));
	AddCommand(t, CreateCommand("MoveLinesText_UP",(unsigned int[]){t->cfg->keybinds[THOTH_MoveLinesText_UP] , 0}, "", -1, SCR_NORM, MoveLinesText, UndoMoveLinesText));
	AddCommand(t, CreateCommand("MoveLinesText_DOWN",(unsigned int[]){t->cfg->keybinds[THOTH_MoveLinesText_DOWN] , 0}, "", 1, SCR_NORM, MoveLinesText, UndoMoveLinesText));

	AddCommand(t, CreateCommand("OpenFileBrowser",(unsigned int[]){t->cfg->keybinds[THOTH_OpenFileBrowser]  , 0}, "", 0, SCR_NORM, OpenFileBrowser, NULL));
	AddCommand(t, CreateCommand("OpenFileZim",(unsigned int[]){t->cfg->keybinds[THOTH_OpenFileZim]  , 0}, "", 0, SCR_NORM, OpenFileZim, NULL));
	AddCommand(t, CreateCommand("Help",(unsigned int[]){t->cfg->keybinds[THOTH_Help]  , 0}, "", 0, SCR_NORM, HelpZim, NULL));
	AddCommand(t, CreateCommand("NewFile",(unsigned int[]){t->cfg->keybinds[THOTH_NewFile]  , 0}, "", 0, SCR_NORM, NewFile, NULL));
	AddCommand(t, CreateCommand("CloseFile",(unsigned int[]){t->cfg->keybinds[THOTH_CloseFile]  , 0}, "", 0, SCR_NORM, CloseFile, NULL));
	AddCommand(t, CreateCommand("SwitchFile",(unsigned int[]){t->cfg->keybinds[THOTH_SwitchFile] , 0}, "", 0, SCR_NORM, SwitchFile, NULL));
	AddCommand(t, CreateCommand("SaveFile",(unsigned int[]){t->cfg->keybinds[THOTH_SaveFile]  , 0}, "", 0, SCR_NORM, SaveFile, NULL));
	AddCommand(t, CreateCommand("SaveAsFile",(unsigned int[]){t->cfg->keybinds[THOTH_SaveAsFile]  , 0}, "", 0, SCR_NORM, SaveAsFile, NULL));

	AddCommand(t, CreateCommand("Comment",(unsigned int[]){t->cfg->keybinds[THOTH_Comment]  , 0}, "", 0, SCR_NORM, Comment, UndoComment));
	AddCommand(t, CreateCommand("ToggleCommentMulti",(unsigned int[]){t->cfg->keybinds[THOTH_ToggleCommentMulti]  , 0}, "", 0, SCR_NORM, ToggleCommentMulti, ToggleCommentMulti));

	AddCommand(t, CreateCommand("MoveBrackets",(unsigned int[]){t->cfg->keybinds[THOTH_MoveBrackets] , 0}, "", 0, SCR_NORM, MoveBrackets, NULL));
	AddCommand(t, CreateCommand("SelectBrackets",(unsigned int[]){t->cfg->keybinds[THOTH_SelectBrackets]  , 0}, "", 0, SCR_NORM, SelectBrackets, NULL));

	AddCommand(t, CreateCommand("GotoLine",(unsigned int[]){t->cfg->keybinds[THOTH_GotoLine]  , 0}, "", 0, SCR_CENT, GotoLine, NULL));
	AddCommand(t, CreateCommand("FindTextInsensitive",(unsigned int[]){t->cfg->keybinds[THOTH_FindTextInsensitive]  , 0}, "", 0, SCR_CENT, FindTextInsensitive, NULL));
	AddCommand(t, CreateCommand("FindTextZim",(unsigned int[]){t->cfg->keybinds[THOTH_FindTextZim]  , 0}, "", 0, SCR_CENT, FindTextZim, NULL));
	AddCommand(t, CreateCommand("EventCtrlEnter",(unsigned int[]){t->cfg->keybinds[THOTH_EventCtrlEnter]  , 0}, "", 0, SCR_CENT, EventCtrlEnter, NULL));

	AddCommand(t, CreateCommand("SelectNextWord",(unsigned int[]){t->cfg->keybinds[THOTH_SelectNextWord]  , 0}, "", 0, SCR_CENT, SelectNextWord, NULL));
	AddCommand(t, CreateCommand("AddCursorCommand_UP",(unsigned int[]){t->cfg->keybinds[THOTH_AddCursorCommand_UP]  , 0}, "", -1, SCR_NORM, AddCursorCommand, NULL));
	AddCommand(t, CreateCommand("AddCursorCommand_DOWN",(unsigned int[]){t->cfg->keybinds[THOTH_AddCursorCommand_DOWN]  , 0}, "", 1, SCR_NORM, AddCursorCommand, NULL));

	AddCommand(t, CreateCommand("ExpandSelectionLines",(unsigned int[]){t->cfg->keybinds[THOTH_ExpandSelectionLines]  , 0}, "", 1, SCR_NORM, ExpandSelectionLines, NULL));
	AddCommand(t, CreateCommand("DeleteLine",(unsigned int[]){t->cfg->keybinds[THOTH_DeleteLine] , 0}, "", 1, SCR_NORM, DeleteLine, UndoDeleteLine));

	AddCommand(t, CreateCommand("MoveByChars_BACK",(unsigned int[]){t->cfg->keybinds[THOTH_MoveByChars_BACK]  , 0}, "", -1, SCR_NORM, MoveByChars, NULL));
	AddCommand(t, CreateCommand("MoveByChars_FORWARD",(unsigned int[]){t->cfg->keybinds[THOTH_MoveByChars_FORWARD]  , 0}, "", 1, SCR_NORM, MoveByChars, NULL));
	AddCommand(t, CreateCommand("MoveLines_UP",(unsigned int[]){t->cfg->keybinds[THOTH_MoveLines_UP]  , 0}, "", -1, SCR_NORM, MoveLines, NULL));
	AddCommand(t, CreateCommand("MoveLines_DOWN",(unsigned int[]){t->cfg->keybinds[THOTH_MoveLines_DOWN] , 0}, "", 1, SCR_NORM, MoveLines, NULL));

	AddCommand(t, CreateCommand("MoveByWords_BACK",(unsigned int[]){t->cfg->keybinds[THOTH_MoveByWords_BACK] , 0}, "", -1, SCR_NORM, MoveByWords, NULL));
	AddCommand(t, CreateCommand("MoveByWords_FORWARD",(unsigned int[]){t->cfg->keybinds[THOTH_MoveByWords_FORWARD]  , 0}, "", 1, SCR_NORM, MoveByWords, NULL));

	AddCommand(t, CreateCommand("IndentLine_FORWARD",(unsigned int[]){t->cfg->keybinds[THOTH_IndentLine_FORWARD]  , 0}, "", 1, SCR_NORM, IndentLine, UndoIndentLine));
	AddCommand(t, CreateCommand("IndentLine_BACK",(unsigned int[]){t->cfg->keybinds[THOTH_IndentLine_BACK]  , 0}, "", -1, SCR_NORM, IndentLine, UndoIndentLine));

	AddCommand(t, CreateCommand("ExpandSelectionWords_BACK",(unsigned int[]){t->cfg->keybinds[THOTH_ExpandSelectionWords_BACK]  , 0}, "", -1, SCR_NORM, ExpandSelectionWords, NULL));
	AddCommand(t, CreateCommand("ExpandSelectionWords_FORWARD",(unsigned int[]){t->cfg->keybinds[THOTH_ExpandSelectionWords_FORWARD]  , 0}, "", 1, SCR_NORM, ExpandSelectionWords, NULL));

	AddCommand(t, CreateCommand("ScrollScreen_UP",(unsigned int[]){t->cfg->keybinds[THOTH_ScrollScreen_UP] , 0}, "", -1, SCR_CENT, ScrollScreen, NULL));
	AddCommand(t, CreateCommand("ScrollScreen_DOWN",(unsigned int[]){t->cfg->keybinds[THOTH_ScrollScreen_DOWN]  , 0}, "", 1, SCR_CENT, ScrollScreen, NULL));
	AddCommand(t, CreateCommand("SelectAll",(unsigned int[]){t->cfg->keybinds[THOTH_SelectAll]  , 0}, "", 0, SCR_NORM, SelectAll, NULL));
	
	AddCommand(t, CreateCommand("MoveByChars_BACK",(unsigned int[]){THOTH_ARROW_LEFT  , 0}, "", -1, SCR_NORM, MoveByChars, NULL));
	AddCommand(t, CreateCommand("MoveByChars_FORWARD",(unsigned int[]){THOTH_ARROW_RIGHT  , 0}, "", 1, SCR_NORM, MoveByChars, NULL));
	AddCommand(t, CreateCommand("MoveLines_UP",(unsigned int[]){THOTH_ARROW_UP  , 0}, "", -1, SCR_NORM, MoveLines, NULL));
	AddCommand(t, CreateCommand("MoveLines_DOWN",(unsigned int[]){THOTH_ARROW_DOWN  , 0}, "", 1, SCR_NORM, MoveLines, NULL));

	AddCommand(t, CreateCommand("Undo",(unsigned int[]){t->cfg->keybinds[THOTH_Undo] , 0}, "", 1, SCR_CENT, Undo, NULL));
	AddCommand(t, CreateCommand("Redo",(unsigned int[]){t->cfg->keybinds[THOTH_Redo]  , 0}, "", 1, SCR_CENT, Redo, NULL));
	AddCommand(t, CreateCommand("Cut",(unsigned int[]){t->cfg->keybinds[THOTH_Cut]  , 0}, "", 1, SCR_CENT, Cut, UndoCut));
	AddCommand(t, CreateCommand("Copy",(unsigned int[]){t->cfg->keybinds[THOTH_Copy]  , 0}, "", 1, SCR_CENT, Copy, NULL));
	AddCommand(t, CreateCommand("Paste",(unsigned int[]){t->cfg->keybinds[THOTH_Paste] , 0}, "", 1, SCR_CENT, Paste, UndoPaste));

	InitCursors(t);
	Thoth_FileBrowser_Init(&t->fileBrowser);

	FILE *fp = fopen(THOTH_LOGFILE, "r");
	if(fp){
		fseek(fp, 0, SEEK_END);
		int len = ftell(fp);
		rewind(fp);
		if(len > sizeof(int)){
			int nFiles;
			fread(&nFiles, sizeof(int), 1, fp);
			len -= sizeof(int);
			int k;
			for(k = 0; k < nFiles; k++){
				if(len < sizeof(int)) break;
				len -= sizeof(int);
				int pathLen;
				char path[512];
				fread(&pathLen, sizeof(int), 1, fp);
				if(len < pathLen) break;
				if(pathLen > 512) break;
				len -= pathLen;
				fread(path,1,pathLen,fp);
				path[pathLen] = 0;
				Thoth_Editor_LoadFile(t, path);
				if(len < sizeof(int)) break;
				len -= sizeof(int);
				fread(&t->file->scroll, sizeof(int), 1, fp);
				if(len < sizeof(int)) break;
				len -= sizeof(int);
				fread(&t->cursors[0].pos, sizeof(int), 1, fp);
				t->file->cursorPos = t->cursors[0].pos; //loadfile updates t->file            
			}
			if(len > sizeof(int)){
				int directoryLen;
				fread(&directoryLen, sizeof(int), 1, fp);
				if(len >= directoryLen && directoryLen < 512){
					len -= directoryLen;
					fread(t->fileBrowser.directory,1,directoryLen,fp);
					t->fileBrowser.directory[directoryLen] = 0;
					Thoth_FileBrowser_ChangeDirectory(&t->fileBrowser);
				}
			}
		}
		fclose(fp);
	}
}
static int CursorPos(Thoth_Editor *t, int x, int y){
	RemoveExtraCursors(t);
	ClearAutoComplete(t);
	UpdateScrollCenter(t);

	if(x < t->logX) x = t->logX;
	if(x < t->logY) x = t->logY;
	if(y > t->linesY - t->logY) y = t->linesY - t->logY;
	if(x > t->colsX - t->logX) x = t->colsX - t->logX;

	x -= t->logX;
	y -= t->logY;
	if(x < 0 || y < 0) return 0;
	t->file->textLen = strlen(t->file->text);

	int lastScroll = t->file->scroll;

	if(y < 3){
		// 3 - y move by 3 at line 0 move by 1 at line 1.
		t->file->scroll = t->file->scroll-(3-y) >= 0 ? t->file->scroll-(3-y) : 0;
	} else {

		int yOver = (y+3) - ((t->linesY-1) - t->logY);

		if(yOver >= 1){
			int k;
			int maxScroll = 0;
			for(k = 0; k < t->file->textLen; k++){
				if(t->file->text[k] == '\n'){
					maxScroll++;
				}
			}

			t->file->scroll = t->file->scroll+yOver <= maxScroll ? t->file->scroll+yOver : maxScroll;
		}
	}

	y += lastScroll;

	int k = 0;
	if(y > 0){
		for(k = 0; k < t->file->textLen; k++){
			if(t->file->text[k] == '\n'){
				y--;
				if(y == 0) { k++; break; } 
			}
		}
	}
	if(x > 0){

		int lx;
		for(lx = k; k < t->file->textLen; lx++){
			if(t->file->text[lx] == '\n') break;
			if(t->file->text[lx] == '\t' ) x-=3;
		}

		lx -= k;

		if(x > lx){
			 x = lx;
		}
	}


	if(k + x < t->file->textLen){
		return k < 0 ? 0 : k+x;
	} else {
		return t->file->textLen;
	}


	return 0;
}

void Text_Editor_Scroll(Thoth_Editor *t, int y){
	ClearAutoComplete(t);
	RemoveExtraCursors(t);
	t->cursors[0].pos = CursorPos(t, 0, -y);
	UpdateScrollCenter(t);
	
}

void Thoth_Editor_SetCursorPosDoubleClick(Thoth_Editor *t, int x, int y){
	
	t->cursors[0].pos = CursorPos(t,x,y);

	int start = 0;
	GetWordStartEnd(t->file->text, t->cursors[0].pos, &start, &t->cursors[0].pos);

	t->selectNextWordTerminator = 1;

	t->cursors[0].selection.startCursorPos = start;
	t->cursors[0].selection.len = t->cursors[0].pos - start;
}

int Thoth_Editor_SetCursorPosSelection(Thoth_Editor *t, int x, int y){

	if(t->selectNextWordTerminator == 1) return 0; //doubleclick

	int pos = CursorPos(t,x,y);

	int mouseSelectionLen = t->mouseSelection - pos;
	
	if(mouseSelectionLen == 0 && t->cursors[0].pos == pos) return 0;

	if(mouseSelectionLen < 0){

		t->cursors[0].selection.startCursorPos = t->mouseSelection;
		t->cursors[0].selection.len = -mouseSelectionLen;

	} else {
		t->cursors[0].selection.startCursorPos = pos;
		t->cursors[0].selection.len = mouseSelectionLen;

	}
	
	t->cursors[0].pos = pos;
	return 1;
}

void Thoth_Editor_SetCursorPos(Thoth_Editor *t, int x, int y){
	RemoveSelections(t);
	t->cursors[0].pos = CursorPos(t,x,y);
	t->cursors[0].selection.startCursorPos = t->cursors[0].pos;
	t->mouseSelection = t->cursors[0].pos;
	t->cursors[0].selection.len = 0;
}


#ifndef SDL_COMPILE
#ifdef LINUX_COMPILE
int Thoth_mvprintw(WINDOW* hdcMem, int x, int y, char *str, int len){
	int tabtospace = 0, k, m = 0;
	for(k = 0; k < len; k++) if(str[k] == '\t') tabtospace++;
	char *buffer = (char*)malloc(len+1+(tabtospace*3));
	memset(buffer,0,len+1+(tabtospace*3));
	for(k = 0; k < len; k++){
		if(str[k] == '\t') { sprintf(&buffer[m],"    "); m+= 4; continue;}
		buffer[m] = str[k];
		m++;
	}
	mvprintw(y,x,"%s",buffer);
	free(buffer);
	return tabtospace*3 + len;
}
void Thoth_attron(WINDOW* hdcMem, int color){
	attron(COLOR_PAIR(color));
}

void Thoth_clrtoeol(WINDOW* hdcMem){
	wclrtoeol(hdcMem);
}
#endif
#endif
#ifdef WINDOWS_API_COMPILE
int Thoth_mvprintw(HDC hdcMem,int x, int y, char *str, int len){
	int tabtospace = 0, k, m = 0;
	for(k = 0; k < len; k++) if(str[k] == '\t') tabtospace++;
	char *buffer = (char*)malloc(len+1+(tabtospace*3));
	memset(buffer,0,len+1+(tabtospace*3));
	for(k = 0; k < len; k++){
		if(str[k] == '\t') { sprintf(&buffer[m],"    "); m+= 4; continue;}
		buffer[m] = str[k];
		m++;
	}

    SelectObject(hdcMem, Config_GetFont());
	TextOut(hdcMem, x*Config_GetWidth(), y*Config_GetHeight(),buffer, strlen(buffer));


	free(buffer);
	return tabtospace*3 + len;
}
void move(int x, int y){
}
void Thoth_clrtoeol(HDC hdcMem){
}
void Thoth_attron(HDC hdcMem, int color){
	  SetTextColor(hdcMem, (COLORREF){Config_GetColor(color, 0)});
	  SetBkColor(hdcMem, (COLORREF){Config_GetColor(color, 1)});
}
#endif

#ifdef SDL_COMPILE


int Thoth_mvprintw(Thoth_Graphics* graphics, int x, int y, char *str, int len){
	int tabtospace = 0, k, m = 0;
	for(k = 0; k < len; k++) if(str[k] == '\t') tabtospace++;
	char *buffer = (char*)malloc(len+1+(tabtospace*3));
	memset(buffer,0,len+1+(tabtospace*3));
	for(k = 0; k < len; k++){
		if(str[k] == '\t') { sprintf(&buffer[m],"    "); m+= 4; continue;}
		buffer[m] = str[k];
		m++;
	}
	Thoth_Graphics_mvprintw(graphics,x,y,buffer,m);
	free(buffer);
	return tabtospace*3 + len;
}
void Thoth_attron(Thoth_Graphics* graphics, int color){
	Thoth_Graphics_attron(graphics,color);
}

void Thoth_clrtoeol(Thoth_Graphics* graphics){
	//wclrtoeol(hdcMem);
}

void wmove(Thoth_Graphics *graphics,int  x, int y){
}
#endif

#ifdef SDL_COMPILE

void Thoth_Editor_Draw(Thoth_Editor *t, Thoth_Graphics *hdcMem){
	t->linesY = Thoth_Graphics_TextCollumns(t->graphics);
	t->colsX = Thoth_Graphics_TextRows(t->graphics);
#else

#ifdef WINDOWS_API_COMPILE

void Thoth_Editor_Draw(Thoth_Editor *t,HWND hwnd){

	PAINTSTRUCT ps;

	HDC hdcScreen = GetDC(NULL);
	HDC hdcScreenDC = CreateCompatibleDC(hdcScreen);
	HDC hdc = BeginPaint(hwnd, &ps);
	HDC hdcMem = CreateCompatibleDC(hdc);

	RECT cliRect;
	GetClientRect(hwnd, &cliRect);
	HBRUSH winBgColorBrush = CreateSolidBrush((COLORREF){Config_GetColor(THOTH_COLOR_NORMAL,1)});
	HBITMAP hbmMem = CreateCompatibleBitmap(ps.hdc,cliRect.right - cliRect.left, cliRect.bottom-cliRect.top );
	HBITMAP hbmOld = SelectObject(hdcMem, hbmMem);
	FillRect(hdcMem, &cliRect, winBgColorBrush);



	t->linesY = (cliRect.bottom - cliRect.top) / Config_GetHeight();
	t->colsX = (cliRect.right - cliRect.left) / Config_GetWidth();
	Thoth_attron(hdcMem, THOTH_COLOR_NORMAL);


#elif LINUX_COMPILE
void Thoth_Editor_Draw(Thoth_Editor *t){

	WINDOW* hdcMem = stdscr;
	t->linesY = LINES;
	t->colsX = COLS;
	Thoth_attron(hdcMem, THOTH_COLOR_NORMAL);



	if(t->file->img.pixels){
		X11_DrawImage(&t->file->img,0, 0, t->colsX, t->linesY);
		bkgd(COLOR_PAIR(THOTH_COLOR_NORMAL));	
		wclear(stdscr);
		wrefresh(stdscr);
		return;
	} else {
		X11_DrawImage(NULL,0,0,0,0);
	}

#endif

#endif

	t->logY = 0;
	t->logX = 5;
	if(t->logging) t->logY = 1;

	int k = 0;
	int y = 0;
	int x = 0;

	// logs

	if(t->logging && t->logging != THOTH_LOGMODE_CONSOLE){

		Thoth_attron(hdcMem,(THOTH_COLOR_FIND));
		char buffer[128] = "ERR\0";
		if(t->logging == THOTH_LOGMODE_NUM){ sprintf(buffer, "g: "); }        
		else if(t->logging == THOTH_LOGMODE_TEXT){ sprintf(buffer, "F: "); }        
		else if(t->logging == THOTH_LOGMODE_TEXT_INSENSITIVE){ sprintf(buffer, "f: "); }        
		else if(t->logging == THOTH_LOGMODE_OPEN){ sprintf(buffer, "o: "); }        
		else if(t->logging == THOTH_LOGMODE_HELP){ sprintf(buffer, "default bindings: "); }        
		else if(t->logging == THOTH_LOGMODE_SAVE){ sprintf(buffer, "w: "); }        
		else if(t->logging == THOTH_LOGMODE_SWITCH_FILE){ sprintf(buffer, "p: "); }        
		else if(t->logging == THOTH_LOGMODE_FILEBROWSER){ sprintf(buffer, "O: "); }        
		else if(t->logging == THOTH_LOGMODE_ALERT){ sprintf(buffer, "A: "); }        
		Thoth_mvprintw(hdcMem, 0, 0, buffer, strlen(buffer));
		Thoth_clrtoeol(hdcMem);
	
		if(t->loggingText && strlen(t->loggingText) > 0){
			Thoth_mvprintw(hdcMem, strlen(buffer), 0, t->loggingText, strlen(t->loggingText));
			Thoth_clrtoeol(hdcMem);
		}

		if(t->logging == THOTH_LOGMODE_HELP){
				char *help = "ctrl+a (select all)\n"
					"ctrl+- (zoom out)\n"
					"ctrl+= (zoom in)\n"
					"ctrl+q (quit)\n"
					"escape (closes find/goto/console, removes extra cursors/selections)\n"
					"ctrl+b (compile (runs \"make\"))\n"
					"ctrl+y (redo)\n"
					"ctrl+z (undo)\n"
					"ctrl+x (cut)\n"
					"ctrl+c (copy)\n"
					"ctrl+v (paste)\n"
					"arrow keys (movement)\n"
					"ctrl+h (move left) ctrl+l (move right) ctrl+j (move up) ctrl+k (move down)\n"
					"shift+arrow up/down (scroll screen up/down)\n"
					"ctrl+[ (indent backward)\n"
					"ctrl+] (indent forward)\n"
					"ctrl+alt+h (move by words left) ctrl+alt+l (move by words right)\n"
					"ctrl+shift+l (expand selection by a line)\n"
					"ctrl+shift+k (delete line)\n"
					"ctrl+arrow up (add cursor up)\n"
					"ctrl+arrow down (add cursor down)\n"
					"ctrl+d (select word under cursor if no selection. continued pressing selects the next occurance of word or selection)\n"
					"ctrl+g (goto line)\n"
					"ctrl+f (search) (enter to search forward, ctrl+enter to search backward)\n"
					"ctrl+F (case senstive search)\n"
					"ctrl+m (move brackets) (moves cursor between the { }, ( ), [ ], of the current scope) (either to the end, or to the beginning if its at the end)\n"
					"ctrl+shift+j (select brackets) (selects everything between the brackets)\n"
					"ctrl+/ (toggle comment)\n"
					"ctrl+shift+/ (toggle multi comment)\n"
					"ctrl+shift+arrow up/down (move line up/down) (moves the entire line the cursors on, or every line in the selection by a line)\n"
					"ctrl+o (open file)\n"
					"ctrl+shift+o (file browser)\n"
					"ctrl+s (save file) (ctrl+o to change directory then cancel and save)\n"
					"ctrl+shift+s Save As file\n"
					"ctrl+n New file\n"
					"ctrl+p Switch file, (lists open files)\n"
					"ctrl+w Close file\n";
			int k;
			int last = 0;
			for(k = 0; k < strlen(help); k++){
				if(help[k] == '\n'){
						char *tab = "    ";
						Thoth_attron(hdcMem,(THOTH_COLOR_NORMAL));
						Thoth_mvprintw(hdcMem, 0, t->logY, tab, strlen(tab));

						Thoth_mvprintw(hdcMem, 4, t->logY, &help[last], k-last);
						Thoth_clrtoeol(hdcMem);

						last = k+1;
						t->logY++;
				}
			}
		
		}else if(t->logging == THOTH_LOGMODE_SWITCH_FILE || t->logging == THOTH_LOGMODE_FILEBROWSER){

			t->logY = 1;

			int nFiles = t->logging == THOTH_LOGMODE_FILEBROWSER ? t->fileBrowser.nFiles : t->nFiles;
			
			k = 0;
			if(nFiles > t->linesY-(t->logY+1)){
				k = t->logIndex-(t->linesY-(t->logY+1));
				if(k < 0) k = 0;
			}

			int index = k;
			for(; k < nFiles; k++){
				char *name = t->logging == THOTH_LOGMODE_FILEBROWSER ? t->fileBrowser.files[k].name : t->files[k]->name;
				int nameLen = strlen(name);
				char *logName = t->loggingText;
				if(THOTH_LOGMODE_FILEBROWSER && t->loggingText){
					logName = Thoth_basename(t->loggingText);
				}
				int logNameLen = logName ? strlen(logName) : 0;

				char *tab = "    ";
				Thoth_attron(hdcMem,(THOTH_COLOR_NORMAL));
				Thoth_mvprintw(hdcMem, 0, t->logY, tab, strlen(tab));

				if(logNameLen <= nameLen){
					if(logNameLen == 0 || CaseLowerStrnCmp(logName, name, logNameLen)){
						if(index == t->logIndex){
							if(t->logging == THOTH_LOGMODE_FILEBROWSER && t->fileBrowser.files[k].dir)
								Thoth_attron(hdcMem,(THOTH_COLOR_SELECTED_DIRECTORY));
							else
								Thoth_attron(hdcMem,(THOTH_COLOR_SELECTED));
						} else {
							if(t->logging == THOTH_LOGMODE_FILEBROWSER && t->fileBrowser.files[k].dir)
								Thoth_attron(hdcMem,(THOTH_COLOR_UNSELECTED_DIRECTORY));
							else
								Thoth_attron(hdcMem,(THOTH_COLOR_LOG_UNSELECTED));
						}
						index++;
						Thoth_mvprintw(hdcMem, 4, t->logY++, name, strlen(name));
						Thoth_clrtoeol(hdcMem);
					}
				}
			}
		}
	}

	Thoth_attron(hdcMem,(THOTH_COLOR_NORMAL));
	if(t->logging == THOTH_LOGMODE_CONSOLE && t->loggingText){
		int logLen = strlen(t->loggingText);
#ifndef SDL_COMPILE
#ifdef LINUX_COMPILE
		return;

#endif
#endif
#ifdef WINDOWS_COMPILE
		// FILE *fp = fopen(THOTH_LOGCOMPILEFILE, "r");

		// if(t->loggingText) free(t->loggingText);

		// if(!fp) return;
		// fseek(fp, 0, SEEK_END);
		// logLen = ftell(fp);
		// rewind(fp);
		// t->loggingText = malloc(logLen+1);
		// fread(t->loggingText, 1, logLen, fp);
		// t->loggingText[logLen] = 0;
		// fclose(fp);
#endif
	}

	// wrefresh(stdscr);
	// end logs
	if(!t->file) return;
	char *text = t->file->text;
	if(!text) return;
	
	t->file->textLen = strlen(text);

	int ctOffset = 0;
	x = 0;
	y = 0;
	// cant modulus x with width, \n might be farther out.

	k = 0;

	int scrollPos = 0;
	int scrollPosMax = 0;

	if(t->file->scroll > 0){
		for(k = 0; k < t->file->textLen; k++){
			if(t->file->text[k] == '\n'){
				y++;
				if(y == t->file->scroll) { k++; break; }
			}
		}
	}
	scrollPos = k;
	ctOffset = k;
	for(; k < t->file->textLen; k++){
		if(text[k] == '\n'){
			y++;
			if(y == t->file->scroll+t->linesY-t->logY) { k++; break; }
		}
	}
	scrollPosMax = k;

	y = 0;

	int renderTo = scrollPosMax, renderStart = scrollPos;

	for(k = scrollPos; k < renderStart; k++){
		if(text[k] == '\n'){
			y++;
		}
	}

	ctOffset = k;

	renderTo++; // include NULL term token

	// begin render files text


	for(; k < renderTo; ){

		int comment = 0;
		int string = 0;

		char c = text[k];

		char token = IsToken(c);
		if(!token){

		   if((k - ctOffset) == 1 && IsDigit(text[k-1])){

				if(text[k] == 'x')
				   for(++k; k < renderTo && IsHexadecimal(text[k]); k++);
			   else 
				   for(; k < renderTo && IsDigit(text[k]); k++);

			   Thoth_attron(hdcMem,(THOTH_COLOR_NUM));
			   Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], k - ctOffset);
			   x += k - ctOffset;
			   ctOffset = k;

			   continue;
		   }

		   k++;
		   // add to temp str

		} else {
			if(k - ctOffset > 0){

				if((k - ctOffset) == 1 && IsDigit(text[k-1])){
					Thoth_attron(hdcMem,(THOTH_COLOR_NUM));
					x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], 1);
					ctOffset = k;
					goto addedStr;
				}

				for(int m = 0; m < (int)(sizeof(keywords)/sizeof(char *)); m++){
					if(strlen(keywords[m]) == (k - ctOffset) && 
						memcmp(&text[ctOffset], keywords[m], (k - ctOffset)) == 0) {
						
						Thoth_attron(hdcMem,(THOTH_COLOR_KEYWORD));
						x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], k - ctOffset);

						ctOffset = k;
						goto addedStr;

					}
				}
			
				if(c == '('){
					// function def example(), k - ctOffset, ctOffset stops at beginning of non tokens, unless a digit or a keyword
					// so that we can change colors at the token after the def

					Thoth_attron(hdcMem,(THOTH_COLOR_FUNCTION));
					x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], k - ctOffset); 
					Thoth_attron(hdcMem,(THOTH_COLOR_FUNCTION));
					x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[k], 1);
					k++;
					ctOffset = k;
					continue;
				}

				Thoth_attron(hdcMem,(THOTH_COLOR_NORMAL));
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], k - ctOffset);

				ctOffset = k;
			}

			addedStr:

			if(c =='\n'){
		
				wmove(hdcMem, t->logY+y,t->logX+x);
				Thoth_clrtoeol(hdcMem);
				y++;
				x = 0;
				ctOffset = ++k;
				continue;
			}

			if(c =='\t'){
				char *buf = "\t";
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, buf, 1);
				ctOffset = ++k;
				continue;
			}

			if(c ==' '){
				char *buf = " ";
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, buf, 1);
				ctOffset = ++k;
				continue;
			}

			if(c == '/' && text[k+1] == '/') comment = 1;
			else if(c == '/' && text[k+1] == '*') comment = 2;
			else if(c == '"') string = 1;
			else if(c == '\'') string = 2;


			if(c == ')' || c == '('){
				Thoth_attron(hdcMem,(THOTH_COLOR_FUNCTION));
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], 1);
				ctOffset = ++k;
				continue;
			}
			
			if(c != ' ' && c != '(' && c != ')' && token && !comment && !string){
				Thoth_attron(hdcMem,(THOTH_COLOR_TOKEN));
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], 1);
				ctOffset = ++k;
				continue;
			}
			

			// if(!comment && !string) k++; 

			if(comment){


				k += 2;
				Thoth_attron(hdcMem,(THOTH_COLOR_COMMENT));
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], k - ctOffset);
				ctOffset = k;

				if(comment == 1){
					for (; k < renderTo; k++){
						if(text[k] == '\n'){ break; }
					}


				} else { /* comment */


					for(;k < (renderTo-1) && !(text[k] == '*' && text[k+1] == '/'); k++){
						if(text[k] == '\n'){
							Thoth_attron(hdcMem,(THOTH_COLOR_COMMENT));
							x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], k - ctOffset );
							Thoth_clrtoeol(hdcMem);
							ctOffset = k+1;
							x = 0;
							y++;
						}
					}
					if( text[k] == '*' && text[k+1] == '/') k+=2;
				}

				Thoth_attron(hdcMem,(THOTH_COLOR_COMMENT));
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[ctOffset], k - ctOffset);
				if(text[k] == '\n'){
					wmove(hdcMem, t->logY+y,t->logX+x);
					Thoth_clrtoeol(hdcMem);
					y++;
					x = 0;
					k++;
				}
				ctOffset = k;
				comment = 0;
				continue;
			}


			if(string){


				int escaped = 0;

				while(k < renderTo){

					k++;
					if(k == renderTo) break;


					if(text[k] == '\n') { break; }
					if(text[k] == '"' && string == 1 && !escaped) { break; }
					if(text[k] == '\'' && string == 2 && !escaped) { break; }


					if(text[k] == '\\' && !escaped)
						escaped = 1;
					else
						escaped = 0;

				}
				if(text[k] != '\n')
					k++;
				
				if(k == renderTo) break;
				if(k >= renderTo-1) k--;

				Thoth_attron(hdcMem,(THOTH_COLOR_STRING));
				x += Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y,&text[ctOffset], k - ctOffset);
								
				ctOffset = k;
				string = 0;

				continue;
			}

			x++;
			ctOffset = ++k;
		}
	}
	Thoth_clrtoeol(hdcMem);		
	for(; y < t->linesY; y++){
		wmove(hdcMem, t->logY+y+1,0);
		Thoth_clrtoeol(hdcMem);
	}
// draw line numbers
#ifdef LINUX_COMPILE
	Thoth_attron(hdcMem,(THOTH_COLOR_LINE_NUM));
#else
		Thoth_attron(hdcMem,(THOTH_COLOR_LINE_NUM));
#endif
	char buffer[10];

	for(y = t->logY, k = 0; y < t->linesY; y++, k++){
		sprintf(buffer, "%.4i ", t->file->scroll+k);
		Thoth_mvprintw(hdcMem, 0, t->logY+k, buffer, strlen(buffer));
	}

	int cur;
	for(cur = 0; cur < t->nCursors; cur++){
		Thoth_EditorCur *c = &t->cursors[cur];
		
		Thoth_EditorSelection *selection = &c->selection;

		if(selection->len > 0){
			int renderStart = selection->startCursorPos;
			int renderTo = selection->startCursorPos + selection->len;

			if(renderTo < scrollPos) continue;
			if(renderStart > scrollPosMax) continue;

			Thoth_attron(hdcMem,(THOTH_COLOR_SELECTED));

			x = 0; 
			y = 0;
			for(k = scrollPos; k < renderTo; k++){
				if(text[k] == '\n'){
					y++;
					x = 0;
					continue;
				} else if(text[k] == '\t'){
					if(k >= renderStart){
							char *buf = "    ";
							Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, buf, 4);
						}
					x += 4;
					continue;
				}

				if(k >= renderStart && x < t->colsX && y < t->linesY){
					Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[k], 1);
				}
				x++;
			}
		}
		// render cursor

		if(scrollPos > c->pos) continue;

		k = scrollPos;
		y = 0;
		x = 0;

		for(; k < c->pos && k < scrollPosMax; k++){
			if(text[k] == '\n'){
				x = 0;
				y++;
				continue;
			} else if(text[k] == '\t'){
				x+=4;
				continue;
			}
			x++;
		}

		Thoth_attron(hdcMem,(THOTH_COLOR_CURSOR));

		if((y >= t->linesY) ||
			x >= t->colsX) continue;

		if(text[c->pos] == '\n' || text[c->pos] == '\t' || text[c->pos] == '\0'){
			char *space = " ";
			Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y,space,1);
		}
		else{
			Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y, &text[c->pos], 1);
		}
#ifdef LINUX_COMPILE
		Thoth_attron(hdcMem,(THOTH_COLOR_LINENUM_CURSOR));		
#else
		Thoth_attron(hdcMem,(THOTH_COLOR_SELECTED));		
#endif
		sprintf(buffer, "%.4i", t->file->scroll+y);
		Thoth_mvprintw(hdcMem, 0, t->logY+y, buffer, strlen(buffer));

	}
#ifdef SDL_COMPILE
	if(t->autoCompleteLen)
		Thoth_Graphics_RenderNCurses(t->graphics);
#endif
	int j;
	k = 0;
	y = 0;

	for(j = 0; j < t->autoCompleteLen; j++){
		if(j == t->autoCompleteIndex)
			Thoth_attron(hdcMem,(THOTH_COLOR_SELECTED));
		else 
			Thoth_attron(hdcMem,(THOTH_COLOR_AUTO_COMPLETE));

		y = 0;
		x = 0;
		for(k = scrollPos; k < t->cursors[t->nCursors-1].pos; k++){

			if(text[k] == '\n'){
				x = 0;
				y++;
				continue;
			} else if(text[k] == '\t'){
				x+=4;
				continue;
			}
			x++;
			
			if(y < 0 || y+j+1 >= t->linesY) break;
			if(x >= t->colsX) continue;
		}

		if(k == t->cursors[t->nCursors-1].pos){

			char buffer[THOTH_MAX_AUTO_COMPLETE_STRLEN];
			memset(buffer, ' ', THOTH_MAX_AUTO_COMPLETE_STRLEN);
			memcpy(buffer, &text[t->autoComplete[j].offset],t->autoComplete[j].len);
			Thoth_mvprintw(hdcMem, t->logX+x, t->logY+y+j+1, buffer, THOTH_MAX_AUTO_COMPLETE_STRLEN);
		}
	}

#ifdef SDL_COMPILE
	Thoth_Graphics_RenderNCurses(t->graphics);

#else

#ifdef WINDOWS_API_COMPILE
	  BitBlt(ps.hdc, cliRect.left, cliRect.top, cliRect.right-cliRect.left, cliRect.bottom - cliRect.top, hdcMem, 0, 0, SRCCOPY);
	  SelectObject(hdcMem, hbmOld);


	  DeleteObject(hbmMem);
	  DeleteDC(hdcMem);
	  EndPaint(hwnd, &ps);
#elif LINUX_COMPILE
	wrefresh(stdscr);
#endif
#endif
}

void Thoth_Editor_Event(Thoth_Editor *t, unsigned int key){


	if(key >> 8 == THOTH_ENTER_KEY >> 8){ // enter
		EventEnter(t, key);
		return;
	}


	if(t->logging && key == 27){ // escape
		RemoveSelections(t);
		EndLogging(t);
		RemoveExtraCursors(t);
		t->lastCmd = NULL;
		t->autoCompleteIndex = 0;
		UpdateScrollCenter(t);
		return;
	}

	if((key>>8) || key == 27){// escape

		if(t->logging){

			int k;
			for(k = 0; k < t->nCommands; k++){

				if(t->commands[k]->Execute == MoveLines && 
					t->commands[k]->keyBinding[0] == key){
		
					LoggingMoveLines(t, t->commands[k]->num);
					return;
				}
				if(t->commands[k]->Execute == CloseFile && 
					t->commands[k]->keyBinding[0] == key){

					if(t->file->unsaved == 1){
						t->file->unsaved = 0;
						CloseFile(t,t->commands[k]);
						EndLogging(t);
						return;
					}

				}    
			}
		}

		//ctrl/shift/alt or arrowkeys

		if(key == ((( unsigned int)'q') | THOTH_CTRL_KEY)){
			t->quit = 1;
			return;
		}
		if(t->logging && key == t->cfg->keybinds[THOTH_Paste]){
			LoggingPaste(t);
			return;
		}

		if(key == ((( unsigned int)'b') | THOTH_CTRL_KEY) && t->logging != THOTH_LOGMODE_CONSOLE){
	
			if(strlen(t->file->path) > 0){
				FILE *fp = fopen(t->file->path, "wb");
				fwrite(t->file->text,1,strlen(t->file->text),fp);
				fclose(fp);
			}

			if(t->loggingText) free(t->loggingText);
			char *buffer = t->fileBrowser.directory;
			t->loggingText = malloc(strlen(buffer)+1);
			memcpy(t->loggingText, buffer, strlen(buffer));
			t->loggingText[strlen(buffer)] = 0;
			
			StartLogging(t, THOTH_LOGMODE_CONSOLE);

#ifdef LINUX_COMPILE
	
			chdir(t->fileBrowser.directory);
			// char *logpath = THOTH_LOGCOMPILEFILE;
		    char cmdbuffer[512]; 
			printf("\033[H\033[2J");
		    sprintf(cmdbuffer, "%s",t->cfg->makecmd);
#ifndef SDL_COMPILE
			endwin();
#endif
		    if(t->loggingText) free(t->loggingText);
		    t->loggingText = NULL;

		    FILE *fp = popen(cmdbuffer, "r");
		    int len = 0;
			  while (fgets(cmdbuffer, 512, fp) != NULL) {
			      printf("%s", cmdbuffer);

			      int bufferLen = strlen(cmdbuffer);
			      t->loggingText = realloc(t->loggingText, len+bufferLen+1);
			      memcpy(&t->loggingText[len], cmdbuffer, bufferLen);
			      len += bufferLen;
					t->loggingText[len] = 0;

			  }
#endif
#ifdef WINDOWS_API_COMPILE
		
			chdir(t->fileBrowser.directory);
			// char *logpath = THOTH_LOGCOMPILEFILE;
		    char cmdbuffer[512]; 
		    sprintf(cmdbuffer, "cmd.exe /c %s",t->cfg->makecmd);

		    if(t->loggingText) free(t->loggingText);
		    t->loggingText = NULL;

		    FILE *fp = popen(cmdbuffer, "r");
		    int len = 0;
			  while (fgets(cmdbuffer, 512, fp) != NULL) {
			      printf("%s", cmdbuffer);

			      int bufferLen = strlen(cmdbuffer);
			      t->loggingText = realloc(t->loggingText, len+bufferLen+1);
			      memcpy(&t->loggingText[len], cmdbuffer, bufferLen);
			      len += bufferLen;
					t->loggingText[len] = 0;

			  }
		    pclose(fp); // Use _pclose on Windows

	// windows broken			
			StartLogging(t, THOTH_LOGMODE_CONSOLE);
#endif
			return;
		}
		if(key == ((( unsigned int)'=') | THOTH_CTRL_KEY)){
			return;
		}
		if(key == ((( unsigned int)'-') | THOTH_CTRL_KEY)){
			return;
		}


		int k;
		for(k = 0; k < t->nCommands; k++){

			if(t->commands[k]->keyBinding[0] == key){

				ExecuteCommand(t,t->commands[k]);
				break;
			}
		}
		return;
	}

	if(t->logging){
		if(key == 127){ // backspace
			LoggingRemoveCharacter(t);
			return;
		}
		if(key >= 32 && key <= 126){
			LoggingAddCharacter(t, key);
			return;
		}
	}

	if(key == 9){ // tab
		if(t->logging) return;
		ClearAutoComplete(t);
		Thoth_EditorCmd *command = CreateCommand("AddCharacters",(const unsigned int[]){0}, "\t", 0,SCR_CENT, AddCharacters, UndoAddCharacters);
		ExecuteCommand(t,command);
		FreeCommand(command);
		return;
	}

	if(key == 127){ // backspace

		Thoth_EditorCmd *command = CreateCommand("RemoveCharacters",(const unsigned int[]){0}, 0, 1, SCR_CENT, RemoveCharacters, UndoRemoveCharacters);
		ExecuteCommand(t, command);
		FreeCommand(command);
		return;
	}

	if(key >= 32 && key <= 126){

		Thoth_EditorCmd *command = CreateCommand("AddCharacters",(const unsigned int[]){0}, (const char[]){(char)key, 0}, 0, SCR_CENT, AddCharacters, UndoAddCharacters);
		ExecuteCommand(t,command);
		FreeCommand(command);
		return;
	}

}


static void UnsavedFileOnExit(Thoth_Editor *t, Thoth_EditorFile *file){
	
	AlertLog(t, "Unsaved changes? ctrl+w to ignore unsaved,"
		" ctrl+s to save, ctrl+S to save as. `escape` to close this message.\0");

	t->file = file;
	RefreshFile(t);
	t->quit = 0;
}

int Thoth_Editor_Destroy(Thoth_Editor *t){
	
	FILE *fp = fopen(THOTH_LOGFILE, "wb");
	int nFiles = 0;
	int k;

	if(fp){
		for(k = 0; k < t->nFiles; k++){
			int len = strlen(t->files[k]->path);
			if(len > 0) nFiles++;

		}
		fwrite(&nFiles,sizeof(int),1,fp);
	}

	// write file last so it opens first

	t->file->cursorPos = t->cursors[0].pos;

	int len = strlen(t->file->path);
	if(len > 0){
		for(k = 0; k < t->nFiles; k++){
			if(t->files[k] == t->file) { t->files[k] = t->files[t->nFiles-1]; break; }
		}
		t->files[t->nFiles-1] = t->file;
	}    
	for(k = 0; k < t->nFiles; k++){
		int len = strlen(t->files[k]->path);
		if(len > 0){
			if(t->files[k]->unsaved == 1){
				UnsavedFileOnExit(t, t->files[k]);
				if(fp) fclose(fp);
				return 0;
			}
			if(fp){
				fwrite(&len,sizeof(int),1,fp);
				fwrite(t->files[k]->path,1,len,fp);
				fwrite(&t->files[k]->scroll,sizeof(int),1,fp);
				fwrite(&t->files[k]->cursorPos,sizeof(int),1,fp);
			}
		} else if(strlen(t->files[k]->text) > 0){
			UnsavedFileOnExit(t, t->files[k]);
			if(fp) fclose(fp);
			return 0;

		}

		if(t->nFiles > 1 && t->file == t->files[k]){
			t->file = t->file == t->files[0] ? t->files[1] : t->files[0];
		}

		FreeFile(t->files[k]);

		// pop stack
		int j;
		for(j = k; j < t->nFiles-1; j++)
			t->files[j] = t->files[j+1];

		k--; // stack[k] is now the stack[k+1] so dont let for loop inc k

		t->files = (Thoth_EditorFile **)realloc(t->files,sizeof(Thoth_EditorFile*) * t->nFiles--);

	}

	// if(fp){
	// 	int m; 
	// 	for(m = strlen(t->file->path); m > 0; m--){
	// 		if(t->file->path[m] == '/') break;
	// 	}

	// 	int len = m;//strlen(t->fileBrowser.directory);
	// 	if(len > 0){
	// 		fwrite(&len,sizeof(int),1,fp);
	// 		// fwrite(t->fileBrowser.directory,1,len,fp);
;
	// 	}
	// 	fclose(fp);
	// }

	for(k = 0; k < t->nCommands; k++)
		FreeCommand(t->commands[k]);

	FreeCursors(t);
	Thoth_FileBrowser_Free(&t->fileBrowser);
	fclose(t->logFile);
	return 1;
}