buffermaker

#!/bin/bash
buffermaker_version="0.12-WIP -3 opt_debug_parallel todo:opt_debug_theme2"
## Buffermaker
# Pure bash tui framework (wip)
shopt -s lastpipe              # For syntax highlighting
shopt -s extglob               # Ensure advanced pattern matching is available
shopt -s checkwinsize && (:;:) # Enable and then trigger a terminal size refresh
# submodules
source bxcommon
source bxinput
source bxformat
source bxplatform
# variables
[ -z "${DEFIFS}" ] && declare -r DEFIFS="$IFS"
declare -A highlight faces faces_raw options charmap hooks resources
declare -A keys_global
declare -a k_hex buffers_l modes=('keys_global')
declare -n buffer bf_s bf_e bf_d
declare -i ismenu comment current_count
declare reset readin

default_faces=(
	reset '\e[m'
	default "$(:weight normal)"
	border-highlight "$(:mode inverse)"
	border-shadow "$(:mode inverse :foreground gray)"
	menu "$(:background yellow :foreground black)"
	menu-divider "$(:underline t)"
	menu-highlight "$(:weight bold :underline t)"
	menu-enabled "$(:background yellow :foreground black)"
	menu-selected "$(:background light-yellow :foreground black :weight bold)"
	checkbox-disabled "$(:foreground light-gray)"
	checkbox-enabled "$(:foreground yellow :weight bold)"
	action "$(:foreground light-blue)"
	argument "$(:foreground light-magenta)"
	button "$(:mode inverse :underline t)"
	link "$(:underline t :foreground light-blue)"
	link-highlight "$(:weight bold :underline t :foreground light-blue)"
	title "$(:weight bold)"
	alt "$(:slant italic)"
	highlight "\e[4m$(:weight bold)"
	accent "$(:foreground yellow)"
	background-highlight "$(:background black)"
	dim "$(:weight dim)"
	divider "$(:foreground gray)"
	name "$(:foreground magenta)"
	hint "$(:foreground light-yellow)"
	hint-highlight "$(:underline t :foreground light-yellow :weight bold)"
	line-number "$(:foreground gray)"
	line-number-empty "$(:weight dim :foreground gray)"
	line-number-current-line "$(:weight bold :foreground light-red)"
	tab-face "$(:weight dim :foreground gray)"
	region "$(:weight bold :background gray)"
	minibuffer-prompt "$(:weight normal)"
	#
	TODO "$(:background magenta)"
	NOTE "$(:background gray)"
	# common colors for format stuff
	black      '\e[30m' gray          '\e[90m'
	red        '\e[31m' light-red     '\e[91m'
	green      '\e[32m' light-green   '\e[92m'
	yellow     '\e[33m' light-yellow  '\e[93m'
	blue       '\e[34m' light-blue    '\e[94m'
	magenta    '\e[35m' light-magenta '\e[95m'
	cyan       '\e[36m' light-cyan    '\e[96m'
	light-gray '\e[37m' white         '\e[97m'

	bg-black      '\e[40m' bg-gray          '\e[100m'
	bg-red        '\e[41m' bg-light-red     '\e[101m'
	bg-green      '\e[42m' bg-light-green   '\e[102m'
	bg-yellow     '\e[43m' bg-light-yellow  '\e[103m'
	bg-blue       '\e[44m' bg-light-blue    '\e[104m'
	bg-magenta    '\e[45m' bg-light-magenta '\e[105m'
	bg-cyan       '\e[46m' bg-light-cyan    '\e[106m'
	bg-light-gray '\e[47m' bg-white         '\e[107m'
)
resources=(
	[&]='&'
	[line]='─'
	[bold-line]='━'
	[column]='│'
	[3right]='├'
	[3left]='┤'
	[3bottom]='┬'
	[3top]='┴'
	
	[1right]='╶'
	[1left]='╴'
	[1bottom]='╷'
	[1top]='╵'

	[block-full]='█'
	[block-dark]='▓'
	[block-medium]='▒'
	[block-light]='░'
	[block-none]=' '
	
	[crux]='╳'
	[cross]='┼'
	[bold-column]='┃'
	[angle-down-right]='┌'
	[bold-angle-down-right]='┏'
	[angle-down-left]='┐'
	[bold-angle-down-left]='┓'
	[angle-up-right]='└'
	[bold-angle-up-right]='┗'
	[angle-up-left]='┘'
	[bold-angle-up-left]='┛'
	[double-line]='═'
	[double-column]='║'
	[double-angle-down-right]='╔'
	[double-angle-down-left]='╗'
	[double-angle-up-right]='╚'
	[double-angle-up-left]='╝'
	[item]='*'
	[item-number]='.'
	[tab]='    '
	[checkbox-disabled]='[ ]'
	[checkbox-enabled]='[x]'
	[bracket-open]='['
	[bracket-close]=']'
	[dot]='.'
	
	[dashed-line]='┄'
	[bold-dashed-line]='┅'
	[dashed-column]='┆'
	[bold-dashed-column]='┇'
	
	[dotted-line]='┈'
	[bold-dotted-line]='┉'
	[dotted-column]='┊'
	[bold-dotted-column]='┋'

	[integral-open]='⌠'
	[integral-close]='⌡'
	
	[buffermaker]="[BufferMaker ${buffermaker_version}]"
	
	[underscore]='_'
	
	[lt]='<'
	[gt]='>'
	[amp]='&'
	[quot]='"'
	[apos]=\'
	[cent]='¢'
	[pound]='£'
	[yen]='¥'
	[euro]='€'
	[copy]='©'
	[reg]='®'
	[tm]='™'	
)

# specific common face sets, to be loaded when needed
filetype_faces=(
	dir "$(:weight bold :foreground blue :underline t)"
	exec "$(:weight bold :foreground green)"
	symlink "$(:weight bold :foreground cyan)"
	unreadable "$(:foreground gray)"
	char "$(:weight bold :background black :foreground yellow)"
	socket "$(:weight bold :foreground magenta)"
	image "$(:weight bold :foreground magenta)"
	video "$(:weight bold :foreground light-magenta)"
	audio "$(:foreground cyan)"
	archive "$(:weight bold :foreground )"
	text "$(:weight bold :foreground light-magenta)"
)

function load-default-config {
	options=(
		[mouse]=0
		[todonote]=0
		[line-number-mode]=0
		[empty-line-char]=''
		[tty-linuxfb]=1 # enable truecolor support for framebuffer
		[full-redraw]=0
		[esc-to-meta]=0
		
		[linux-foreground]='bbbbbb' [linux-background]='000000'
		[linux-red]='bb2040'        [linux-light-red]='ff4066'
		[linux-green]='008040'      [linux-light-green]='30aa60'
		[linux-blue]='0050b0'       [linux-light-blue]='3060ee'
		[linux-black]='262626'      [linux-light-black]='393939' 
		[linux-yellow]='b58900'     [linux-light-yellow]='d5a920'
		[linux-magenta]='a33682'    [linux-light-magenta]='c356a2'
		[linux-cyan]='00a198'       [linux-light-cyan]='20c1b8'
		[linux-white]='8a8a8a'      [linux-light-white]='eee8d5'
	)
	
	add-mode empty; {
		mode-options; {
			:: else :
			:: disable-global 1
		}
	}	

	add-mode menu
		:: '[up]' menu.up
		:: "$(kbd k)" menu.up
		:: 'C-p' menu.up
		:: '[down]' menu.down
		:: "$(kbd j)" menu.down
		:: 'C-n' menu.down
		:: 'RET' menu.select
		mode-options
			:: else menu.exit
			:: disable-global 1

	add-mode basic
		:: '[left]' format-left
#		:: '[wheel-up]' format-up
		:: '[up]' format-up
		:: '[right]' format-right
#		:: '[wheel-down]' format-down
		:: '[down]' format-down
		:: '[next]' scroll-down #pgdown
		:: '[prior]' scroll-up #pgup
		:: "$(kbd n)" scroll-left
		:: "$(kbd m)" scroll-right
		:: RET link-enter
		:: C-c die
		mode-options
			:: else :

	## Faces
	#		Defined in escape codes
	#		Helper functions:
	#			:weight
	#				normal
	#				bold
	#			:slant
	#				normal
	#				italic
	#           :underline
	#               t (enables)
	#               nil (do nothing)
	#			:background & :foreground
	#				either hex. colour, colour name, or c<index> for 256 indexed colours
	#		See extensions/gruvboxdark for another example
	load-theme default_faces
	#dired:load-mode
}

## syntaxy sugar sugary syntax
function @ifs { IFS="$DEFIFS"; }

function ::
case "$_last_add" in
	add-menu) local-set-menu "$@";;
	global-set) global-set-key "$@";;
	set-options) define-option "$@";;
	add-mode) local-set-key "$@";;
	mode-options) local-set-mode-option "$@";;
	set-buffer) local-set-buffer-data "$@"
esac

## focus set magic # function
function focus {
	_last_add="$1"
}



## local-set-buffer-data
# set bf_d[] array of currently \"focused\" buffer
function local-set-buffer-data {
	while [ -n "$2" ]; do
		bf_d["$1"]="$2"
		shift 2
	done
}

## clear-screen clears screen
function clear-screen { printf '\033c'; }
## global-set Brings into \"focus\" global mode
function global-set { last_add=global-set; }
## define-option Defines options[] buffer
function define-option { options["$1"]="$2"; }
## set-options Brings into \"focus\" options setting
function set-options { _last_add=set-options; }

function menu.add {
	# create new menu function & array
	#eval "function ${1}.open { menu $1; }"
	declare -ag "menu_${1}_0"
	declare -ag "menu_${1}_1"
	declare -ag "menu_${1}_2"

	local -n menu_0="menu_${1}_0"
	local -n menu_1="menu_${1}_1"
	local -n menu_2="menu_${1}_2"

	local -i c=-1
	local type
	
	local -n menu="$1"
	for i in "${menu[@]}"; do
		case "$i" in
			't:'|'text:')
				type=text
				((c++))
				continue;;
			'c:'|'cmd:'|'command:')
				type=command
				continue;;
			'f:'|'face:')
				type=face
				continue	
		esac
		case "$type" in
			'text')
				menu_0[c]+=" $i"
				;;
			'command')
				menu_1[c]+="$i "
				;;
			'face')
				menu_2[c]+="$i"
		esac
	done
	menu.layout "$1"
}
function menu.layout {
	local -n menu_0="menu_${1}_0"
	local -i max=0
	for i in "${menu_0[@]}"; do
		((${#i} > max)) && max="${#i}"
		lax=${i}
	done
	for i in "${!menu_0[@]}"; do
#		menu_0[i]+="a b c"
		for ((l=$((max - ${#menu_0[i]})) + 1; l>0; l--)); do
			menu_0[i]+=' '
		done
	done
}

## add gradient and its faces, hex code only
# syntax example:
# gradient ':background' name 50 ':foreground "#000000"' ff0000 ffff00 00ff00 00ffff 0000ff ff00ff
function gradient {
	local name="$2"
	local -n cugr="$2"
    local steps="$3"
    local before="$1"
    local after="$4"
	shift 4	
    local colors=("$@")
	
    local num_segments=$(( ${#colors[@]} - 1 ))
    local base=$(( (steps - 1) / num_segments ))
    local extra=$(( (steps - 1) % num_segments ))
    local seg_steps
    local idx=0

    for ((s=0; s<num_segments; s++)); do
        seg_steps=$(( base + (s < extra ? 1 : 0) + 1 ))
        local start=${colors[s]}
        local end=${colors[s+1]}

		[ "${start:0:1}" = '#' ] && start="${start:1}"
		[ "${end:0:1}" = '#' ] && end="${end:1}"
		
        local r1=$((16#${start:0:2}))
        local g1=$((16#${start:2:2}))
        local b1=$((16#${start:4:2}))

        local r2=$((16#${end:0:2}))
        local g2=$((16#${end:2:2}))
        local b2=$((16#${end:4:2}))
		
		declare -ag grloadfc
        for ((i=0; i<seg_steps; i++)); do
            if (( s < num_segments-1 && i == seg_steps-1 )); then
                continue
            fi
            local r=$(( r1 + (r2 - r1) * i / (seg_steps - 1) ))
            local g=$(( g1 + (g2 - g1) * i / (seg_steps - 1) ))
            local b=$(( b1 + (b2 - b1) * i / (seg_steps - 1) ))
            cugr+=("${name}_fc${s}${i}")
			grloadfc+=("${name}_fc${s}${i}")
			grloadfc+=("$(eval "${before} \"#$(printf "%02x%02x%02x\n" "$r" "$g" "$b")\" ${after}")")
        done
    done
	load-theme grloadfc
}

## load-theme Loads theme from array
function load-theme {
	local -i t=0
	local k=''
	local -n theme="$1"
	for i in "${theme[@]}"; {
		((t==0)) && {
			k="$i"
			t=1
		} || {
			faces["$k"]="$i"
			printf -v faces_raw["$k"] '%b' "$i"
			t=0
		}
	}
	((t)) && errno=1 die
			 
}

## rest of this garbageware



## switch-mode
# Change current mode of buffer into '$1'
function switch-mode {
	bckmode="${bf_d[mode]}"
	bf_d[mode]="$1"
}

## mode-back
# Restores previous mode
function mode-back {
	bf_d[mode]="$bckmode"
	unset bckmode
}

## read-command
# Works like normal "'read'" but for bottom commanline
function read-command {
	local -i loc
	[ -n "$4" ] && loc="$4" || loc=$((bf_d[size-y] + bf_d[loc-y])) 
	printf '\e[%s;0H' "$loc"
	printf '\e[?25h'
	read -re -p "$1" -i "$3" "$2" || return 1
}

### TODO: make this make sense

function declare-buffer {
	_last_add='set-buffer'
	set-buffer "${1}" # name
	buffers_l+=("$current_buffer")
	last_line=1
	declare -Ag "${current_buffer}_bf_t"
	declare -Ag "${current_buffer}_bf_h"
	declare -Ag "${current_buffer}_bf_d"
	bf_d=(
		# some sane default values
		[line]=0
		[base]=1
		[column]=0
		[modified]=0
		[loc-x]=1
		[loc-y]=1
		[size-x]=$COLUMNS
		[size-y]=$LINES
		[bxrender-function]='syntax1'
	)
	# weird debug
	# bf_h=( [redraw.content begin]=linenum.begin [redraw.content loop-begin]=linenum.loop-begin [redraw.cursor pre-redraw]=linenum.update )
}

## set-buffer
# Switch to buffer \$1 
function set-buffer {
	current_buffer="$1"
	declare -ng buffer="${current_buffer}_buffer" # source
	declare -ng bf_s="${current_buffer}_bf_s" # syntax
	declare -ng bf_e="${current_buffer}_bf_e" # charmap
	declare -ng bf_d="${current_buffer}_bf_d" # data
	declare -ng bf_c="${current_buffer}_bf_c" # commands/objects
	declare -ng bf_h="${current_buffer}_bf_h" # hooks
	declare -ng bf_t="${current_buffer}_bf_t" # tmp cache
}

function switch-buffer {
	set-buffer "$1"
	redraw
}

## add-to-list
# Adds a buffer into currently active buffer list
function add-to-list {
	buffers_l+=("$current_buffer")
}

## clear-buffer
# Empties buffer bf_s bf_e \& bf_d
function clear-buffer {
	buffer=()
	for l in "${bf_s[@]}"; {
		unset "$l"
	}
	bf_s=()
	bf_e=()
	for l in "${bf_c[@]}"; {
		unset "$l"
	}
	bf_c=()
}

## goto Load array into buffer
function goto {
	clear-buffer
	bf_d[line]=1
	bf_d[column]=0
	copy-array "$1" buffer
	redraw
}

function format-build {
	[ "$2" = '{' ] || exit 1
	declare -ng __ext_name="$1"
	declare -g __ext_id=0
	declare -ag __ext_type
	__ext_type[0]='none'
	__ext_type[1]='newline'
	set +e
#	PATHbak="$PATH"
#	PATH=''
#	trap 'eval "+ $BASH_COMMAND"' ERR

	function + {
		case "${__ext_type[-1]}" in
			'newline') __data-new "$1";;
			'oneline') __data-add "$1";;
			*) : ;;
		esac
	}
	function newline, { __data-new ''; }
	function newline {
		for ((i = 0; i < ${1::-1}; i++)); do
			__data-new ''
		done
	}
	
	function line {
		__ext_id=0
		__ext_num='-1'
		__ext_name+=('')
		__ext_type+=('oneline')
	}

	function title { __ext_type+=('title'); }	
	function subtitle { __ext_type+=('subtitle'); }	
	function __data-add {
		if ((__ext_id==0)); then
			__ext_name[-1]+="$*"
			__ext_id=1
		else
			__ext_name[-1]+=" $*"
		fi
	}
	function __data-new {
		__ext_name+=("$*")
	}
	function }, {
		case "${__ext_type[-1]}" in
			'title')
				case "$level" in
					'1') __data-new "<h1> $label </h1>";;
					'2') __data-new "<h2> $label </h2>";;
					'3') __data-new "<h3> $label </h3>";;
					*) __data-new "<h> $label </h>";;
				esac
				level='';;
			'subtitle')
				case "$level" in
					*) __data-new "<subh1> $label </subh1>";;
				esac
				level='';;
		esac	
		unset '__ext_type[-1]'
	}
}

## Dumps current buffer into a file	
function dump-buffer {
	true >"$1" # Set the file to an empty text file
	for ln in "${buffer[@]}"; do # Write in the buffer to the file
		echo "$ln" >>"$1"
	done
}

## die
# Closes Ebashs with exit code \$errno, if errno is empty exit with 0
# If \$nocleanup is 1, do not restore the terminal to sane mode and do not cleanup 
# Else restore to sane mode 
function die {
	((nocleanup)) && exit "${errno:-0}"
	echo -e "\e[?1000;1006;1015l" #disable mouse tracking
	clear-screen # TODO fix the buffer switching
	printf '\e[?25h\e[?7h\e[?1049l' # Reset terminal to sane mode
	global-hook die
	exit "${errno:-0}" # Assume that we are exiting without an error
}

# Sets \$nocleanup to 1 and dies	
function die.force {
	((nocleanup=1)) && die "$@"
}

function move.previous-line.check ((bf_d[line] > 1))
function move.next-line.check ((bf_d[line] < ${#buffer[@]}+bf_d[last-newline]))

# Moves up \$1 lines, if \$ is empty move up 1 line
function move.previous-line {
	for ((i = 0; i < ${1:-1}; i++)); do
		((bf_d[line] > 1)) && ((bf_d[line]--))
		((bf_d[line] < bf_d[base] + 1)) && {
			((bf_d[base]--)) # Push back the top if we need to
			move_base=1 # Send signal to redraw.cursor that the buffer was moved, thus needs to be redraw fully
			((bf_d[base] <= 0)) && bf_d[base]=1 # Don't push back if our base is at 1
		}
		[ -z "$bckrl" ] && bckrl="${bf_d[column]}"	
		(( ${#bf_e[bf_d[line]]} < bf_d[column] )) && bf_d[column]=${#bf_e[bf_d[line]]}
		(( ${#bf_e[bf_d[line]]} > bckrl )) && bf_d[column]=${bckrl}
	done
}

# Moves down \$1 lines, if \$ is empty move down 1 line
function move.next-line {
	for ((i = 0; i < ${1:-1}; i++)); do
		((bf_d[line] < ${#buffer[@]}+bf_d[last-newline])) && ((bf_d[line]++))
		# Move window down if needed
		((bf_d[line] > bf_d[base] + bf_d[size-y] - 3)) && {
			((bf_d[base]++))
			move_base=1
		}
		[ -z "$bckrl" ] && bckrl="${bf_d[column]}"	
		(( ${#bf_e[bf_d[line]]} < bf_d[column] )) && bf_d[column]=${#bf_e[bf_d[line]]}
		(( ${#bf_e[bf_d[line]]} > bckrl )) && bf_d[column]=${bckrl}
	done
}

function previous-line {
	move.previous-line.check || return
	hook pre-move
	move.previous-line "$@"
	hook move
	redraw.cursor
}
function next-line {
	move.next-line.check || return
	hook pre-move
	move.next-line "$@"
	hook move
	redraw.cursor
}
function scroll-down {
	hook pre-move
	move.previous-line $((bf_d[size-y] - 3))
	hook move
	redraw.cursor
}
function scroll-up {
	hook pre-move
	move.next-line $((bf_d[size-y] - 3))
	hook move
	redraw.cursor
}
function scroll-right {
	((bf_d[basecolumn]++))
	redraw
}
function scroll-left {
	((bf_d[basecolumn]<=0)) && { bf_d[basecolumn]=0; return; }
	((bf_d[basecolumn]--))
	redraw
}
function beginning-of-buffer {
	hook pre-move
	bf_d[base]=1
	bf_d[line]=1
	hook move
	redraw
}
function end-of-buffer {
	hook pre-move
	bf_d[base]=$((${#buffer[@]} - bf_d[size-y] + 4))
	bf_d[line]=$((${#buffer[@]}))
	hook move
	redraw
}
function move-beginning-of-line { bf_d[column]=0; redraw; }
function move-end-of-line { bf_d[column]="${#bf_e[${bf_d[line]}]}"; redraw; }

function forward-char {
	for ((i = 0; i < ${1:-1}; i++)); do
		case "${bf_e[${bf_d[line]}]:${bf_d[column]}+1:1}" in
			't') bf_d[column]=$(( bf_d[column]+${#resources[tab]}));;
			*) ((bf_d[column]++));;
		esac
		((bf_d[column] > ${#bf_e[${bf_d[line]}]})) && {
			bf_d[column]=0
			next-line
			return
		}
		bckrl=
	done
	redraw-line.cursor
}

function backward-char {
	for ((i = 0; i < ${1:-1}; i++)); do
		case "${bf_e[${bf_d[line]}]:${bf_d[column]}-1:1}" in
			't') bf_d[column]=$(( bf_d[column]-${#resources[tab]}));;
			*) ((bf_d[column]--));;
		esac
		((bf_d[column] < 0)) && ((bf_d[line]==1)) && {
			bf_d[line]=1
			bf_d[column]=0
		}
		((bf_d[column] < 0)) && {
			bf_d[column]="${#bf_e[${bf_d[line]}-1]}"
			previous-line
			return
		}
		bckrl=
	done
	redraw-line.cursor
}
	
## forward-word
# Moves forward to next word
function forward-word {
	((bf_d[column] == ${#bf_e[bf_d[line]]})) && {
		next-line
		move-beginning-of-line
	}
	while :; do
		((bf_d[column] < ${#bf_e[bf_d[line]]})) && ((bf_d[column]++)) || break
		case "${bf_e[bf_d[line]]:${bf_d[column]}:1}" in
			't'|'s') break
		esac
	done
	redraw
}

## backward-word
# Moves backward to previous word
function backward-word {
	((bf_d[column] == 0)) && {
		previous-line
		move-end-of-line
	}
	while :; do
		((bf_d[column] > 0)) && ((bf_d[column]--)) || break
		case "${bf_e[bf_d[line]]:${bf_d[column]}:1}" in
			't'|'s') break
		esac
	done
	redraw
}


#Move cursor to line number $1 and move the line into middle of visible buffer area.
function to-line {
	bf_d[line]="$1"
	bf_d[base]=$((bf_d[line] - bf_d[size-y] / 2 ))
	redraw
}

function menu.up {
	((menuselection > 0)) && ((menuselection--));
	redraw.menu;
}
function menu.down {
	((menuselection < ${#menu_0[@]} -1)) && ((menuselection++));
	redraw.menu;
}

# Execute selected item in menu
function menu.select
for i in "${!menu_1[@]}"; {
	((i == menuselection)) && ${menu_1[i]}
}

# Closes a menu
function menu.exit {
	unset bf_d[menu_x] bf_d[menu_y]			 
	ismenu=0
	bf_d[mode]="${modebackup}"
	redraw
}

# Opens a menu \$1	
function menu {
	declare -ng menu_0=menu_${1}_0
	declare -ng menu_1=menu_${1}_1
	declare -ng menu_2=menu_${1}_2
	((ismenu == 0 )) && modebackup="${bf_d[mode]}"
	ismenu=1
	declare -ig menuselection=0
	bf_d[mode]='menu'
	redraw
}

# deletes current buffer
function delete-buffer {
	local -a copy
	local i=0
	local index
	for b in "${buffers_l[@]}"
	do
		[[ "$b" != "$current_buffer"  ]] && copy+=("$b")
		[[ "$b" = "$current_buffer"  ]] && index="$i"
		((i++))
	done
	unset buffers_l
	copy-array copy buffers_l
	current_buffer="${buffers_l[index-1]}"
	redraw
}

# Handle changing size of terminal
function change-size-screen {
	bf_d[size-x]="$COLUMNS"
	bf_d[size-y]=$((LINES-1))
	redraw
}

# function scene {
# 	[ "$2" = '{' ] || exit 1
# 	declare -ng scene="sc_${1}"
# 	declare -g sc_i=0
# 	declare -ag sc_s
# 	sc_t[0]='none'
# 	sc_t[1]='newline'
		
# 	function buffer {
# 		scene+=('<buffer>')
# 		scene+=("${1}")
# 		sc_t+=('buffer')
# 		sc_s+=("${1}")
# 	}

# 	function scale: {
# 		scene+=('<scale>')
# 		scene+=('full')
# 	}
	
# 	function }, {
# 		case "${sc_t}" in
# 			'buffer') scene+=('<commit>');;
# 			'buffer') scene+=("${sc_s[-1]}");;
# 		esac
# 		unset 'sc_t[-1]'
# 		unset 'sc_s[-1]'
# 		scene+=('<close>')
# 	}
# }

# function scene.render {
# 	declare -ng scene="sc_${1}"
# 	print-array scene > d
# 	for pk in "${scene[@]}"; do
# 		 case "${__expect}" in
# 			 'bf') set-buffer "$pk"; __expect='';;
# 			 *) :;;
# 		 esac
# 		 case "${pk}" in
# 			 '<buffer>') __expect="bf";;
# 			 '<scale>') __expect="scale";;
# 			 '<close>') __expect="close";;
# 		 esac
# 		 done
#  }
 
## redraw
# Redraw screen
## hooks
# stored in bf_h ass. array
# naming scheme is '<function> <name>', function name is handled automatically when defining a hook via @hook
function @hook {
	local name="${FUNCNAME[1]} $1"
	shift
	[ -n "${bf_h[${name}]}" ] && {
		${bf_h[${name}]} "$@"
		return 0
	}
	return 1
}
# common hooks, without function prefix
function hook {
	local name="$1"
	shift
	[ -n "${bf_h[${name}]}" ] && {
		${bf_h[${name}]} "$@"
		return 0
	}
	return 1
}
# global hooks, shared in every buffer
function global-hook {
	local name="$1"
	shift
	[ -n "${hooks[${name}]}" ] && {
		${hooks[${name}]} "$@"
		return 0
	}
	return 1
}

## insert-word
# Insert \$1 to buffer
function insert-word {
	local -i rlr
	unset ta
	local ta
	ta=${bf_e[${bf_d[line]}]:0:${bf_d[column]}}
	ta=${ta//[^t]}
	ta=${#ta}
	rlr=$((bf_d[column] + ta / 4 - ta))
	buffer[bf_d[line]]="${buffer[${bf_d[line]}]:0:${rlr}}$1${buffer[${bf_d[line]}]:${rlr}}"
	#add at cursor position - amount of tabs * tab size
	make-render-line
	forward-char "${#1}"
	redraw
	bf_d[modified]=1
}


function init-var {
	trap change-size-screen WINCH ALRM # Attach WINCH and ALRM to redraw the screen
	trap die EXIT HUP USR1 # Attach most exit codes to cleanup and exit
	trap 'k_hex=(3 0); keypress' INT ##MOVE: bxinput
	trap die SIGTERM
	reset='\e[0;0m'
	charmap=(
		#[0] is reserved for any unmapped char
		[	]='t' # tab
		[ ]='s' # space
	)
	if ((options[esc-to-meta])); then esc_timeout=123456789 # a very big number ##MOVE: bxinput
	else esc_timeout=0.01; fi ##MOVE: bxinput
	nlchar='\n'
	printf '\e[?1049h'
	((options[mouse])) && echo -ne "\e[?1000;1006;1015h" #enable mouse tracking ##MOVE: bxinput
}
#RENDER
#bxrender_version="v11 internal"

# invalidate redraw cache for entire buffer
function refresh { clear-screen; bf_s=''; redraw; }
function mark-render-area {
	for ((i=${1}; i<${2} ; i++)); {
		unset bf_s[i]
	}
}
#function make-render-area { mark-render-area "$@"; }

## make-render-line
# Syntax highlights single line '$1'
# Defaults to currently selected line if no argument is passed
function make-render-line {
	local -i line=${1:-bf_d[line]}
	local -n linearray="${current_buffer}_syntax${line}"
	bf_s[line]="${current_buffer}_syntax${line}"
	linearray=()
	
	local -i comment=0 skip_next_space=0
	local word=''
	bf_e[line]=''
	for _link in ${bf_c[line]}; do unset "$_link"; done; unset bf_c[line] # clear command buffer
	column=0
	
	bckeIFS="${IFS}"
	IFS=''
	"${bf_d[render-type]:-per-char}"
	IFS="$bckeIFS"
}
function per-line {
	IFS=' '; while read -rs word; do IFS=''; syntax-word; IFS=' '; done  <<< "${buffer[line]}"
}

function per-word {
	IFS=' '
	newline=1
	while read -rs -d' ' word; do
		IFS=''
		syntax-word
		newline=0
		((skip_next_space==1)) && skip_next_space=0 && continue
		bf_e[line]+='s'
	    linearray+=(
			"${faces_raw[reset]}${faces_raw[${facename:-${bf_d[background]:-default}}]} "
		)
		((column++))
		
		IFS=' '
	done  <<< "${buffer[line]} "
}

## make-render-line-loop
# Also creates bf_e charmap for movenment
#     "Tab is 't'"
#     "Space is 's'"
#     "Any unmaped char is '0'"
function per-char {
	while read -rsn1 char; do
		[ "$char" = ' ' ] && {
			syntax-word
			word=''
			((skip_next_space==1)) && skip_next_space=0 && continue
			bf_e[line]+=s
			linearray+=(
				"${faces_raw[reset]}${faces_raw[${facename:-${bf_d[background]:-default}}]} "
			)
			((column++))
			continue
		}
		[ "$char" = '	' ] && {
			syntax-word
			word=''
			printf -v _bxrd__z '%*s' "${#resources[tab]}" ''
			bf_e[line]+="${_bxrd__z// /t}"
			face-no-expand tab-face #"${resources[tab]}"
			((column+=${#resources[tab]}))
			continue
		}
		[ "$char" = '' ] && {
			syntax-word
			word=''
			skip_next_space=0
			face-no-expand "${bf_d[background]:-default}" ''
			newline=1 # tell next syntax-word that this was newline and is on new line
			return
		}
		word+="${char}"
	done  <<< "${buffer[line]}"
}

## syntax-word
# Decides what a word should highlighted as
function syntax-word {
	"${bf_d[syntax]}"
	((bf_d[syntax-exec])) || face "$syntax_face" "$word" # s_ex controls syntax extended
}

## face
# Add highlighted word to multidimensional nonsense "'bf_s'" arry
function face {
	[[ "$2" =~ ${2//?/(.)} ]]
	linearray+=("${faces_raw[reset]}${faces_raw[${1}]}${BASH_REMATCH[@]:1}")
	printf -v _bxrd__z '%*s' "${#2}" ''
    bf_e[line]+="${_bxrd__z// /0}"
}
## face-no-expand
# Add highlighted word to multidimensional nonsense "'bf_s'" arry without adding anything to bf_e[] array
function face-no-expand {
	[[ "$2" =~ ${2//?/(.)} ]]
	linearray+=("${faces_raw[reset]}${faces_raw[${1}]}${BASH_REMATCH[@]:1}")
}

## set-face Sets face for syntax highlighting
function set-face { syntax_face="${1}"; }

# reset buffer rendered caches
function clear-render {
	bf_e=()
	for l in "${bf_s[@]}"; { unset "$l"; }; bf_s=()
	for l in "${bf_c[@]}"; { unset "$l"; }; bf_c=()
}
function syntax-none { set-face "${bf_d[background]:-default}"; }
##############################################################################################REDRAW
# Redraw popup menu
function redraw.menu {
	local -i y=${bf_d[menu_y]:-$((bf_d[line] + bf_d[loc-y] -1))}
	local -i x=${bf_d[menu_x]:-$((bf_d[column] + bf_d[loc-x] -1))}
	printf '\e[?25l' # hide cursor (again)
	printf '\e[%s;0H' $y #$menuloc_y
	for i in "${!menu_0[@]}"; {
		if ((i == menuselection)); then
			printf "\e[%sC%b%s${reset}\n" $x "${faces[menu-selected]}${faces_raw[${menu_2[i]:-menu-selected}]}" "${menu_0[i]}"
		else
			printf "\e[%sC%b%s${reset}\n" $x "${faces[menu-enabled]}${faces_raw[${menu_2[i]:-menu-enabled}]}" "${menu_0[i]}"
		fi
	}
}

function redraw {
	@hook begin && return
	redraw.content; redraw.cursor
}

function linenum.begin {
	# Get length of line-number of lines
	bf_d[length]="${#buffer[@]}"
	((bf_d[length]==0)) &&((bf_d[length]++))
	
	bf_d[number-length]=${#bf_d[length]}
	bf_d[number-space]=1
}
function linenum.loop-begin {
	space=1
	ln="\e[%dG%b%*s"
	lnargs=(
		"${bf_d[loc-x]}"
		"${faces[line-number]}"
		"${bf_d[number-length]}"
		"$i"
	)
	((i == bf_d[line])) && lnargs[1]="${faces[line-number-current-line]}"
}
function linenum.update {
	printf '\e[%s;%sH%b%*s\e[m'\
		   $((last_line + options[menu-line] - bf_d[base] + bf_d[loc-y]))\
		   "${bf_d[loc-x]}"\
		   "${faces[line-number]}"\
		   ${bf_d[number-length]}\
		   $last_line
	printf '\e[%s;%sH%b%*s\e[m'\
		   $y\
		   "${bf_d[loc-x]}"\
		   "${faces[line-number-current-line]}"\
		   ${bf_d[number-length]}\
		   ${bf_d[line]}
}

function set-linenum {
	bf_h[redraw.content begin]=linenum.begin
	bf_h[redraw.content loop-begin]=linenum.loop-begin
	bf_h[redraw.cursor pre-redraw]=linenum.update
}
function unset-linenum {
	bf_h[redraw.content begin]=''
	bf_h[redraw.content loop-begin]=''
	bf_h[redraw.cursor pre-redraw]=''
}



function linenum.begin-roman {
	# Get length of line-number of lines
	bf_d[length]=$((${#buffer[@]}))
	((bf_d[length]==0)) &&((bf_d[length]++))
	
	bf_d[number-length]=$((${#bf_d[length]}+12))
	bf_d[number-space]=1
}
function linenum.loop-begin-roman {
	space=1
	ln="\e[%dG%b%*s"
	req pri; roman "$i"
	lnargs=(
		"${bf_d[loc-x]}"
		"${faces[line-number]}"
		"${bf_d[number-length]}"
		"$pri"
	)
	((i == bf_d[line])) && lnargs[1]="${faces[line-number-current-line]}"
}
function linenum.update-roman {
	local prill; req prill {
		roman "$last_line"
	},
	local pri; req pril {
		roman "${bf_d[line]}"
	},
	printf '\e[%s;%sH%b%*s\e[m'\
		   $((last_line + options[menu-line] - bf_d[base] + bf_d[loc-y]))\
		   "${bf_d[loc-x]}"\
		   "${faces[line-number]}"\
		   ${bf_d[number-length]}\
		   $prill
	printf '\e[%s;%sH%b%*s\e[m'\
		   $y\
		   "${bf_d[loc-x]}"\
		   "${faces[line-number-current-line]}"\
		   ${bf_d[number-length]}\
		   $pri
}

function set-linenum-roman {
	bf_h[redraw.content begin]=linenum.begin-roman
	bf_h[redraw.content loop-begin]=linenum.loop-begin-roman
	bf_h[redraw.cursor pre-redraw]=linenum.update-roman
}

function redraw.content {
	[ -n "${bf_d[redraw-function]}" ] && {
		"${bf_d[redraw-function]}"
		return
	}
	printf '\e[?25l'
	unset buffer[0]

	((bf_d[number-length]=0, bf_d[number-space]=0))
	@hook begin
	
#((bf_d[column] +3 < bf_d[size-x] - bf_d[number-length] - 1)) &&
#bf_d[basecolumn]=0
#((bf_d[column] +3 > bf_d[size-x] - bf_d[number-length] - 1)) &&
#bf_d[basecolumn]=$((bf_d[column] - (bf_d[size-x] + bf_d[loc-x] - bf_d[number-length] - 1) +3))
	printf "\e[%s;%sH" "${bf_d[loc-y]}" "${bf_d[loc-x]}"
	IFS='' #has to be empty in order to bfarray multiarray be printed as words instead of chars

	# Handle line number displaying
	# the resulting line has to be printed in one go to prevent flicker
	# space stores if the position of actuall text should be offset by +1
	# ln stores printf print line
	# args stores printf arguments
	local -i space; local ln; local -a lnargs
	
	# Iterate over shown lines
	local -i max=$((bf_d[size-y]))
	for ((i = bf_d[base]; i - bf_d[base] < max; i++)); do
		
		ln="\e[%dG"
		lnargs=(
			"${bf_d[loc-x]}"
		)
		@hook loop-begin

		# TODO: generic hook into render
		((i > ${#buffer[@]})) &&
			printf '%b\e[%d;%dH%*s'\
				   "${faces[${bf_d[background]:-default}]}"\
				   $((bf_d[loc-y]+i-1))\
				   "${bf_d[loc-x]}"\
				   $((bf_d[size-x] - bf_d[number-length]))\
				   "${bf_d[empty-line]:-}"\
				&& continue
		# If the requested line isn't rendered, render it
		[ -z "${bf_s[base+i]}" ] && "${bf_d[render-function]:-make-render-line}" $((base + i))
#		IFS='¸' # debug method
		local -n linearray="${bf_s[i]}"
		((i - bf_d[base] > max - 2)) && nlchar='' || nlchar='\n' #nlchar='\e[7m---More---\e[m'
		printf "${ln}%b%*s\e[%sG%b%s\e[m%b"\
			   ${lnargs[@]}\
			   "${faces[${bf_d[background]:-default}]}"\
			   $((bf_d[size-x] - bf_d[number-length]))\
			   ''\
			   $((bf_d[loc-x] + bf_d[number-length] + space))\
			   "${faces[${bf_d[background]:-default}]}"\
			   "${linearray[*]:bf_d[basecolumn]:bf_d[size-x] - (bf_d[number-length])}"\
			   "$nlchar"
	done

	@ifs
	# redraw menu if open
	[ "${bf_d[mode]}" = 'menu' ] && redraw.menu
}
## print-buffer-line
function print-buffer-line { # why this errors when stderr is redirected
	IFS=''
	local -n linearray="${bf_s[bf_d[line]]}"
	printf '%s' "${linearray[*]:bf_d[basecolumn]:bf_d[size-x] - (bf_d[number-length])}"
	@ifs
}
# Draw cursor on the line
function redraw-line.cursor {
	# redraw if buffer needs to be moved horizontally
	((bf_d[column] > bf_d[size-x] - bf_d[number-length] - space)) && { redraw; return; }
	((bf_d[basecolumn]==0)) || { redraw; return; }
	printf '\e[%sG\e[?25h' \
		   $((
				bf_d[column] - bf_d[basecolumn] + bf_d[number-length] +
				bf_d[loc-x] + bf_d[number-space]
			)) || redraw
}	
# Draw cursor and if move_base is 1 redraw
function redraw.cursor {
	@hook first && return
	((move_base)) && { move_base=0; redraw; return; }
	local -i y=$((bf_d[line] + options[menu-line] - bf_d[base] + bf_d[loc-y]))
	@hook pre-redraw
	printf '\e[%s;%sH\e[?25h'\
		   $y\
		   $((
				bf_d[column] - bf_d[basecolumn] + bf_d[number-length] +
				bf_d[loc-x] + bf_d[number-space]
			))
	last_line=${bf_d[line]}; @hook post-redraw
}

function cursor.hide { printf '\e[?25l'; }
function cursor.show { printf '\e[?25h'; }


function parallel-render {
	printf '\e[?25l'; unset buffer[0]
	((bf_d[number-length]=0, bf_d[number-space]=0))
	printf "\e[%s;%sH" "${bf_d[loc-y]}" "${bf_d[loc-x]}"
	local -i space; local ln; local -a lnargs
	
	# warcrime renderer
	# Iterate over shown lines
	local -i max=$((bf_d[size-y]))
	for ((i = bf_d[base]; i - bf_d[base] < max; i++)); do
		[ -z "${bf_s[i]}" ] && {
			parallel-draw "$i"
		} &
	done | while IFS='|' read -r i type result; do
		case "$type" in
			s)
				[ -z "${bf_s[i]}" ] && {
					bf_s[i]="${current_buffer}_syntax${i}"
					local -n relinearray="${bf_s[i]}"
					relinearray=()
					local pos=0 len content type

					while [[ $result =~ ^([0-9]+)\| ]]; do
						local sep=${result%%|*}
						len=$sep
						result=${result#*|}
						content=${result:1:len-1}
						relinearray+=("$content")
						result=${result:len}
					done
				}
				;;
			e)
				[ -z "${bf_e[i]}" ] && {
					local pos=0 len content type
					while [[ $result =~ ^([0-9]+)\| ]]; do
						local sep=${result%%|*}
						len=$sep
						result=${result#*|}
						content=${result:1:len-1}
						bf_e[i]+="$content"
						result=${result:len}
					done
				};;
		esac
	done
	
	wait
	IFS=' '
	local -i ric=0
	# finish draw
	# TODO: pararel this

	for ((i = bf_d[base]; i - bf_d[base] < max; i++)); do
		ln="\e[%dG"
		lnargs=(
			"${bf_d[loc-x]}"
		)
		
		# TODO: generic hook into render
		((i > ${#buffer[@]})) && {
			printf '%b\e[%d;%dH%*s'\
				   "${faces[${bf_d[background]:-default}]}"\
				   $((bf_d[loc-y]+i-1))\
				   "${bf_d[loc-x]}"\
				   $((bf_d[size-x] - bf_d[number-length]))\
				   ''\
				&& continue
		}
		IFS=''
		local -n linearray="${bf_s[i]}"
		((i - bf_d[base] > max - 2)) && nlchar='' || nlchar='\n'
		printf "${ln}%b%*s\e[%sG%b%s\e[m%b"\
			   ${lnargs[@]}\
			   "${faces[${bf_d[background]:-default}]}"\
			   $((bf_d[size-x] - bf_d[number-length]))\
			   ''\
			   $((bf_d[loc-x] + bf_d[number-length] + space))\
			   "${faces[${bf_d[background]:-default}]}"\
			   "${linearray[*]:bf_d[basecolumn]:bf_d[size-x] - (bf_d[number-length])}"\
			   "$nlchar"
		IFS=' '
	done
	IFS=' '
}
function parallel-draw {
	targetline="$1"

	((targetline > ${#buffer[@]})) && {
		return # will never have syntax
	}
	
	[ -z "${bf_s[base+targetline]}" ] && {
		local -i rline=$((base + targetline))
		local -n rlinearray="${current_buffer}_syntax${rline}"
		rlinearray=()
		brlinearray=()
		local -i comment=0 skip_next_space=0
		local word=''
		bf_e[rline]=''
		column=0	
		bckeIFS="${IFS}"
		IFS=' '
		newline=1
		while read -rs -d' ' word; do
			IFS=''
			
			case "$word" in
				*'	'*)
				    # reparse word infected with tabs
					newword=''
					bnewword=''
				    while read -rsn1 -d '' char; do
						if [ "$char" = '	' ]; then
							printf -v _bxrd__z '%*s' "${#bnewword}" ''
							brlinearray+=("e${_bxrd__z// /0}")
							bnewword=''
							newword+="¨´ˇ¸"
							printf -v _bxrd__z '%*s' "${#resources[tab]}" ''
							brlinearray+=("e${_bxrd__z// /t}")
						elif [ "$char" = $'\n' ]; then
							:
						else
							newword+="${char}"
							bnewword+="${char}"
						fi
					done <<< "$word"
					word="${newword}"
					syntax_face="${bf_d[background]:-default}"
					;;
				*)
					syntax_face="${bf_d[background]:-default}"
					printf -v _bxrd__z '%*s' "${#word}" ''
					brlinearray+=("e${_bxrd__z// /0}")
					;;
			esac
			
			[[ "$word" =~ ${word//?/(.)} ]]
			tmp=("${faces_raw[reset]}${faces_raw[${syntax_face}]}${BASH_REMATCH[@]:1}")
			for tmpx in "${tmp[@]}"; do
				rlinearray+=("s${tmpx}")
			done
			
			newline=0
			#((skip_next_space==1)) && skip_next_space=0 && continue
			##########	bf_e[rline]+='s'
			rlinearray+=(
				s"${faces_raw[reset]}${faces_raw[${facename:-${bf_d[background]:-default}}]} "
			)
			brlinearray+=('es')
			((column++))
			IFS=' '
		done  <<< "${buffer[rline]} "
		robuffer=''
		for rchar in "${rlinearray[@]}"; do
			robuffer+="${#rchar}|${rchar}"
		done
		for rchar in "${brlinearray[@]}"; do
			brobuffer+="${#rchar}|${rchar}"
		done
		echo "${targetline}|e|${brobuffer}"
		echo "${targetline}|s|${robuffer}"
	}
}

[[ "${BASH_SOURCE[0]}" = "${0}" ]] && {
	load-default-config
	init-var
	about
}