edit.n

import math
import glscene
import diff
import text_chunked
import distfield2d

class EditImpl{
	signal change, cursor

	// single cursor
	class Cursor{
		constructor(cursors){
			this.cursors = cursors
			this.editor = cursors.editor
			this.layer = editor.layer
			start = 0
			end = 0
			max = 0
		}

		get lo() -> end>start?start:end
		get hi() -> end>start?end:start

		set lo(v){
			if(end>start) start = v
			else end = v
		}

		set hi(v){
			if(end>start) end = v
			else start = v
		}

		get span(){
			return abs(end-start)
		}

		hideProperties()

		moveLeft(only_end){
			end = end - 1
			if(end < 0) end = 0
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		moveRight(only_end){
			end = end + 1
			if(end > layer.char_count) end = layer.char_count
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		moveUp(only_end, lines = 1){
			var rect = layer.cursorRect(end)
			//console.log(max, rect.y + .5*rect.h - lines * cursors.text_layer.line_height)
			//cursors.text_layer.debugChunks()
			end = layer.offsetFromPos(max, rect.y + .5*rect.h - lines * layer.line_height)
			if(!only_end) start = end
		}

		moveDown(only_end, lines = 1){
			var rect = layer.cursorRect(end)
			end = layer.offsetFromPos(max, rect.y + .5*rect.h + lines * layer.line_height)
			if(!only_end) start = end
		}

		moveTo(x, y, only_end){
			var off = layer.offsetFromPos(x, y)
			var change = end != off 
			end = off
			if(!only_end) change = start != end || change, start = end
			var r = layer.cursorRect(off)
			max = r.x
		}

		moveLeftWord(only_end){
			var pos = editor.scanLeftWord(end)
			if(pos == end) end --
			else end = pos
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		moveRightWord(only_end){
			var pos = editor.scanRightWord(end)
			if(pos == end) end ++
			else end = pos
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		moveLeftLine(only_end){
			// if we are a tab we scan to the right.
			end = editor.scanLeftLine(end)
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		moveRightLine(only_end){
			end = editor.scanRightLine(end)
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		moveTop(only_end){
			end = 0
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		moveBottom(only_end){
			end = layer.char_count
			if(!only_end) start = end
			max = layer.cursorRect(end).x
		}

		startIsEnd(){
			start = end
		}

		// we need to make a whole bunch of these things.
		deleteRange(from, to){
			editor.addUndoInsert(from, to)
			layer.removeText(from, to)
			cursors.delta -= to - from
			start = end = from

			editor.forkRedo()
			max = layer.cursorRect(end).x
		}

		deleteWord(){
			var my = editor.scanRightWord(hi)
			if(my == lo) return delete()
			deleteRange(lo, my)
		}

		deleteLine(){
			deleteRange(lo, editor.scanRightLine(hi))
		}

		backspaceLine(){
			deleteRange(editor.scanLeftLine(lo), hi)
		}

		backspaceWord(){
			var my = editor.scanLeftWord(lo)
			if(my == hi) return backspace()
			deleteRange(my, hi)
		}

		selectWord(){
			start = editor.scanLeftWord(lo)
			end = editor.scanRightWord(hi)
			max = layer.cursorRect(end).x
		}
		
		selectLine(){
			start = editor.scanLeftLine(lo)
			end = editor.scanRightLine(hi) + 1
			max = layer.cursorRect(end).x
		}

		selectAll(){
			start = 0
			end = layer.char_count
			max = layer.cursorRect(end).x
		}

		delete(){
			if(start != end) return deleteRange(lo, hi)
			// otherwise we have to delete the character upnext
			editor.addUndoInsert(end, end + 1)
			layer.removeText(end, end + 1)
			cursors.delta -= 1
			editor.forkRedo()
			max = cursors.text_layer.cursorRect(end).x
		}

		backspace(){
			if(start != end) return deleteRange(lo, hi)

			start += cursors.delta
			end += cursors.delta

			if(editor.stripNextOnBackspace(lo - 1)){
				hi++
			}

			var t
			if(parse.isNonNewlineWhiteSpace(layer.charCodeAt(lo - 1))){
				while(t = parse.isNonNewlineWhiteSpace(layer.charCodeAt(lo - 1))){
					lo = lo - 1
					if(t == 2) break
				}
			}
			//else if(parse.isNonNewlineWhiteSpace(cursors.text_layer.charCodeAt(lo - 2))){
			//	var my_ch = cursors.text_layer.charCodeAt(lo - 1)
			//	var prev_ch = cursors.text_layer.charCodeAt(lo - 3)

			//	if( !parse.isIdentifierChar(my_ch) && !parse.isIdentifierChar(prev_ch) ){
			//		lo = lo - 2
			//	}
			//}

			if(lo == 0) return
			editor.addUndoInsert(lo -1, hi)
			layer.removeText(lo - 1, hi)
			cursors.delta -= span
			editor.forkRedo()
			start = end = lo - 1
			max = layer.cursorRect(end).x			
		}

		insert(text){
			var cdelta = 0
			if(editor.processInsert){
				[text, cdelta] = editor.processInsert(lo, hi, text)
			}
			start += cursors.delta
			end += cursors.delta
			if(start != end){
				editor.addUndoInsert(lo, hi)
				layer.removeText(lo, hi)
				cursors.delta -= span
			}
			if(text.length){
				var len =  layer.insertText(lo, text)
				cursors.delta += len
				editor.addUndoDelete(lo, lo + len)
			}	
			editor.forkRedo()
			start = end = lo + text.length + cdelta
			max = layer.cursorRect(end).x
		}

		isSelection(){
			return start !== end
		}

		isCursor(){
			return start === end
		}
	}

	// cursor set 
	class Cursors{
		constructor(editor){
			this.editor = editor
			this.layer = editor.layer
			list = [Cursor.new(this)]
			fusing = true
		}

		toArray(inp){
			var out = []
			for(var cursor from list){
				out.push(cursor.start, cursor.end)
			}
			return out
		}

		fromArray(inp){
			list = []
			for(var i = 0; i < inp.length; i+=2){
				var cur = Cursor.new(this)
				list.push(cur)
				cur.start = inp[i]
				cur.end = inp[i+1]
			}
			update()
		}

		fuse(){

			list.sort(function(a,b){ return (a.start<a.end?a.start:a.end) < (b.start<b.end?b.start:b.end)? -1: 1})
			// lets do single pass
			for(var i = 0; i<list.length-1;){
				var cur = list[i]
				var nxt = list[i+1]
				// lets figure out the different overlap cases
				if(cur.hi >= nxt.lo){
					if(cur.hi <= nxt.hi){ // we fuse it [cur<]nxt>
						if(nxt.end < nxt.start){
							cur.end = cur.lo
							cur.start = nxt.hi
						}
						else{
							cur.start = cur.lo
							cur.end = nxt.hi
						}
					}
					// remove the nxt
					list.splice(i+1, 1)
				}
				else i++
			}
		}
		
		markDelta(){
			for(var cursor from list){
				cursor.mark_start = layer.charCodeAt(cursor.start - 1)
				cursor.mark_end = layer.charCodeAt(cursor.end - 1)
			}
		}

		markSeek(pos, delta, mark){
			pos += delta
			var count = layer.char_count
			if(pos < 0) pos = 0
			if(pos >= count) pos = count - 1
			// ignore markers that are volatile
			if(mark != 32 && mark != 9 && mark != 10 && mark != 59){
				pos++
				var start = pos
				var max = abs(delta)
				while(pos > 0 && layer.charCodeAt(pos - 1) != mark){
					if(start-pos>max)break
					pos--
				}
			}
			return pos
		}

		moveDelta(beyond, delta){
			for(var cursor from list){
				if(cursor.start>=beyond)
					cursor.start = markSeek(cursor.start, delta, cursor.mark_start)
				if(cursor.end>=beyond){
					cursor.end = markSeek(cursor.end, delta, cursor.mark_end)
				//	cursor.max = text_layer.cursorRect(cursor.end).x
				}
			}
			update()
		}

		update(){
			if(pending) return
			pending = 1
			setImmediate() do =>{
				pending = 0
				layer.clearMarkers()
				layer.clearCursors()

				// fuse the cursor list
				if(fusing) fuse()
				// draw it into geometry buffers 
				for(var cursor from list){
					if(cursor.start != cursor.end){
						layer.addMarkers(cursor.start, cursor.end)
					}
					layer.addCursor(cursor.end)
				}
			}
		}

		rectSelect(x1, y1, x2, y2, clone){
			if(y2<y1){
				var t = y1
				y1 = y2
				y2 = t
			}
			var new_list = Array.prototype.slice.apply(clone)
			var height = layer.line_height
			var y = y1
			while(1){
				var cur = Cursor.new(this,0)
				new_list.push(cur)
				cur.start = layer.offsetFromPos(x1,y)
				cur.end = layer.offsetFromPos(x2,y)
				//console.log(cur.end, x2)
				if(y >= y2) break
				y += height
				if(y > y2) y = y2
			}
			list = new_list
			update()
		}

		add(){
			var cursor = Cursor.new(this,list.length)
			list.push(cursor)
			return cursor
		}
		// forwards the whole api
		for(var key in Cursor) bind(key){
			if(typeof Cursor[key] == 'function'){
				this[key] = (){
					this.delta = 0
					for(var cursor from list) cursor[key](...)
					this.update()
				}
			}
		}
	}

	addUndoInsert(start, end, stack = undo_stack){
		// merge undo groups if it merges
		var last = stack[stack.length - 1]
		if(last && last.type == 'insert' && 
			last.start == end){
			var group = last.group
			last.group = undo_group
			for(var i = stack.length - 2;i>=0;i--){
				if(stack[i].group == group) stack[i].group = undo_group
			}
		}		
		stack.push({
			group: undo_group
			type: 'insert'
			start: start
			data: layer.serializeTags(start, end)
			cursors: cursors.toArray()
		})
	}

	addUndoDelete(start, end, stack = undo_stack){
		// merge undo objects if it merges
		var last = stack[stack.length - 1]
		if(last && last.type == 'delete' && 
			last.end == start){
			last.end += end - start
			return
		}
		stack.push({
			group: undo_group
			type: 'delete'
			start: start
			end: end
			cursors: cursors.toArray()
		})
	}

	forkRedo(){
		if(undo_stack.length){
			undo_stack[undo_stack.length - 1].redo = redo_stack
		}
		redo_stack = []
	}

	undoRedo(stack1, stack2){
		// aight. lets process em undos
		if(!stack1.length) return
		var last_group = stack1[stack1.length - 1].group
		for(var i = stack1.length - 1;i>=0;i--){
			var item = stack1[i]
			var last_cursor
			if(item.group != last_group) break
			// lets do what it says
			if(item.type == 'insert'){
				addUndoDelete(item.start, item.start + item.data.length, stack2)
				layer.insertText(item.start, item.data)
				last_cursor = item.cursors
			}
			else{
				addUndoInsert(item.start, item.end, stack2)
				layer.removeText(item.start, item.end)
				last_cursor = item.cursors
			}
		}
		stack1.splice(i+1)
		cursors.fromArray(last_cursor)
	}

	// alright we serialize all ze cursors and concat and send over.
	selectionToClipboard(){
		// alright. so. we need to sort the cursors.
		var str = ''
		for(var cursor from cursors.list){
			str += layer.serializeText(cursor.lo, cursor.hi)
		}
		clipboard.value = str
	}

	scanLeftWord(pos){
		while(pos > 0 && parse.isNonNewlineWhiteSpace(charCodeAt(pos - 1))){
			pos --
		}
		while(pos > 0 && parse.isIdentifierChar(charCodeAt(pos - 1))){
			pos --
		}
		return pos
	}

	scanRightWord(pos){
		while(pos < char_count && parse.isNonNewlineWhiteSpace(charCodeAt(pos))){
			pos ++
		}
		while(pos < char_count && parse.isIdentifierChar(charCodeAt(pos))){
			pos ++
		}
		return pos
	}

	scanLeftLine(pos){
		if(charCodeAt(pos) == 9){
			while(pos < char_count && charCodeAt(pos) == 9){
				pos ++
			}
		}
		else{ // if we are a newline 
			if(charCodeAt(pos - 1) == 9){
				while(pos > 0 && charCodeAt(pos - 1) != 10){
					pos --
				}
			}
			else{
				while(pos > 0 && charCodeAt(pos - 1) > 10){
					pos --
				}
			}
		}
		return pos
	}

	scanRightLine(pos){
		while(pos < char_count && charCodeAt(pos) != 10){
			pos ++
		}
		return pos
	}
	
	// change event type	
	enum Change{
		keyPress
		delete
		undoRedo
		clipboard
	}

	var utfmap = {
		accent:1//`
		_accent:'`'
		num1:'¡'
		_num1:'⁄'
		num2:'™'
		_num2:'€'
		num3:'£'
		_num3:'‹'
		num4:'¢'
		_num4:'›'
		num5:'∞'
		_num5:'fi'
		num6:'§'
		_num6:'fl'
		num7:'¶'
		_num7:'‡'
		num8:'•'
		_num8:'°'
		num9:'ª'
		_num9:'·'
		num0:'º'
		_num0:'‚'
		equals:'≠'
		_equalt:'±'
		q:'œ'
		_q:'Œ'
		w:'∑'
		_w:'„'
		e:2//´
		_e:'´'
		r:'®'
		_r:'‰'
		t:'†'
		_t:'ˇ'
		y:'¥'
		u:3//¨
		_u:'¨'
		i:4//ˆ
		_i:'ˆ'
		o:'ø'
		_o:'Ø'
		p:'π'
		_p:'∏'
		openbracket:'“'
		_openbracket:'”'
		closebracket:'‘'
		_closebracket:'’'
		backslash:'«'
		_backslash:'»'
		a:'å'
		_a:'Å'
		s:'ß'
		_s:'Í'
		d:'∂'
		_d:'Î'
		f:'ƒ'
		_f:'Ï'
		g:'©'
		_g:'˝'
		h:'˙'
		_h:'Ó'
		j:'∆'
		_j:'Ô'
		k:'˚'
		_k:''
		l:'¬'
		_l:'Ò'
		semicolon:'…'
		_semicolon:'Ú'
		singlequote:'æ'
		_singlequote:'Æ'
		z:'Ω'
		_z:'¸'
		x:'≈'
		_x:'˛'
		c:'ç'
		_c:'Ç'
		v:'√'
		_v:'◊'
		b:'∫'
		_b:'ı'
		n:5//'˜'
		_n:'˜'
		m:'µ'
		_m:'Â'
		comma:'≤'
		_comma:'¯'
		period:'≥'
		_period:'˘'
		slash:'÷'
		_slash:'¿'
	}
	
	// called after child constructors
	poststructor(){
		cursors = Cursors.new(this, this.layer)
		undo_stack = []
		redo_stack = []
		undo_group = 0

		focus()

		cursors.moveDown(1,0)
	}

	clipPaste(v){
		undo_group++
		cursors.insert(v)
		change = Change.clipboard
	}

	keyPress(v){
		undo_group++
		cursors.insert(v.value)
		change = Change.keyPress		
	}

	keyDown(v){
		clipboard.focus()
		var name = 'key' + v.name[0].toUpperCase() + v.name.slice(1)
		undo_group++

		if(key.leftmeta || key.rightmeta) name += 'Cmd'
		if(key.ctrl) name += 'Ctrl'
		if(key.alt) name += 'Alt'

		if(this[name]) this[name](v)
		else if(key.alt){
			name = v.name
			if(key.shift) name = '_'+name
			var trans = utfmap[name]
			if(typeof trans == 'number'){ // we have to do a 2 step unicode
				console.log('2 step unicode not implemented')
			}
			else if(trans !== undefined){
				cursors.insert(trans)
				change = Change.keyPress
			}
		}
	}

	mouseLeftDown(v){
		//console.log(mouse.clicker)
		if(key.alt){
			var startx = mouse.x
			var starty = mouse.y
			var clone
			if(key.leftmeta || key.rightmeta) clone = cursors.list
			else clone = []

			cursors.rectSelect(startx, starty, startx, starty, clone)
			cursors.fusing = false
			mouseCapture(=>{
				cursors.rectSelect(startx, starty, mouse.x, mouse.y, clone)
			},=>{
				cursors.fusing = true
				cursors.update()
				// we are done. serialize to clipboard
				selectionToClipboard()
			})
		}
		else
		// add a cursor
		if(key.leftmeta || key.rightmeta){
			var cursor = cursors.add()
			// in that case what we need to 
			cursors.fusing = false
			cursor.moveTo(mouse.x, mouse.y)
			// lets make it select the word 

			if(mouse.clicker == 2) cursor.selectWord()
			else if(mouse.clicker == 3){
				cursor.selectLine()
				mouse.resetClicker()
			}

			cursors.update()
			mouseCapture(=>{
				// move
				cursor.moveTo(mouse.x, mouse.y, true)
				cursors.update()
			},=>{
				cursors.fusing = true
				cursors.update()
				selectionToClipboard()
			})
		}
		// normal selection
		else{
			// in that case what we need to 
			cursors.fusing = true
			cursors.moveTo(mouse.x, mouse.y)

			if(mouse.clicker == 2) cursors.selectWord()
			else if(mouse.clicker == 3){
				cursors.selectLine()
				mouse.resetClicker()
			}

			mouseCapture(=>{
				cursors.moveTo(mouse.x, mouse.y, true)
			}, =>{
				selectionToClipboard()
			})
		}
	}

	// alright so. undo. 
	keyZCtrl =
	keyZCmd(){
		undoRedo(undo_stack, redo_stack)
		change = Change.undoRedo
		//doCursor()
	}

	keyYCtrl =
	keyYCmd(){
		undoRedo(redo_stack, undo_stack)
		change = Change.undoRedo
		//doCursor()
	}

	keyACtrl = 
	keyACmd(){
		// select all
		cursors.selectAll()
		selectionToClipboard()
	}

	keyXCtrl = 
	keyXCmd(){
		// cut the crap
		cursors.delete()
	}

	keyBackspace(){
		cursors.backspace()
		change = Change.delete
		doCursor()
	}

	doCursor(){
		cursor = 1
		selectionToClipboard()
	}
	
	// move selection up one line
	keyDownarrowAlt(){

	}

	// move selection down one line
	keyUparrowAlt(){

	}

	keyDelete(){
		cursors.delete()
		doCursor()
	}

	keyDeleteCtrl =
	keyDeleteAlt(){
		cursors.deleteWord()
		doCursor()
	}

	keyBackspaceCtrl = 
	keyBackspaceAlt(){
		cursors.backspaceWord()
		doCursor()
	}

	keyBackspaceCmd(){
		cursors.backspaceLine()
		doCursor()
	}

	keyDeleteCmd(){
		cursors.deleteLine()
		doCursor()
	}

	keyLeftArrowCtrl = 
	keyLeftarrowAlt(){
		cursors.moveLeftWord(key.shift)
		doCursor()
	}
	
	keyRightArrowCtrl = 
	keyRightarrowAlt(){
		cursors.moveRightWord(key.shift)
		doCursor()
	}

	keyLeftarrowCmd(){
		cursors.moveLeftLine(key.shift)
		doCursor()
	}

	keyRightarrowCmd(){
		cursors.moveRightLine(key.shift)
		doCursor()
	}
 
	keyHome = 
	keyUparrowCmd(){
		cursors.moveTop(key.shift)
		doCursor()
	}

	keyEnd = 
	keyDownarrowCmd(){
		cursors.moveBottom(key.shift)
		doCursor()
	}

	keyLeftarrow(){ 
		cursors.moveLeft(key.shift)
		doCursor()
	}

	keyRightarrow(){
		cursors.moveRight(key.shift)
		doCursor()
	}

	keyUparrow(){
		cursors.moveUp(key.shift)
		doCursor()
	}

	keyDownarrow(){
		cursors.moveDown(key.shift)
		doCursor()
	}
}