#!/bin/bash
MANAGER_CFG_FILE="/etc/lliurex-rdesk/manager.cfg"

ROOT_CFG_DIR="/root/.config/rustdesk/"
ROOT_CFG="$ROOT_CFG_DIR/RustDesk2.toml"
SOCKS_PORT=1080
RD_PASSWORD="?????"
RD_IP=""
SSH_CLIENT_IP=""
SSH_SERVER_IP=""
RUNTIME_FILE=""
RD_STATUS="?????"

[ ! -r "$MANAGER_CFG_FILE" ] || . $MANAGER_CFG_FILE

# main function
main(){
	[ "$1" ] || usage
	ACTION="$1"
	shift
	case "$ACTION" in
		enable)
			root_test || die "You must be root to run this program"
			if ! test_rustdesk_installation ; then
				if ! install_rustdesk ; then
					die "Rustkdesk installation failed. Exitting"
				fi
			fi

			CONN_PASS="$(gen_password)"
			enable_connection "$CONN_PASS"
			get_ssh_ip

			echo "Configuration completed"
			echo "Connection is allowed ONLY if remote user opens RustDesk window"
			echo "*****************************"
			echo ">IP: $SSH_SERVER_IP"
			echo ">PASSWORD: $CONN_PASS"
			echo "*****************************"
			echo ""
		        echo "Run locally this COMMAND to connect to remote system:"
			echo ""
			echo "lliurex-rdesk desktop [$SSH_SERVER_IP]"
			echo ""
			echo ""
			;;

		local-console)
			RDESK_CMD="$0"
			a=""
			TIMEOUT="1.5"
			n=0
			show_menu 0
			while [ "$a" != "0" ] ; do
				if [ $n -eq 1 ] ; then
					CHR=" "
					n=0
				else
					CHR="_"
					n=1
				fi

				printf "\r$CHR"
				read -t $TIMEOUT a
				printf " \b"
				case "$a" in
					1)
						TMP_FILE="$(mktemp)"
						rc=0
						run_with_sudo $RDESK_CMD enable > "$TMP_FILE" || rc=$?
						cat "$TMP_FILE"
						if [ $rc -eq 0 ] ; then
							RD_PASSWORD="$(parse_value ">PASSWORD" "$TMP_FILE")"
							RD_IP="$(parse_value ">IP" "$TMP_FILE")"
							RD_STATUS="enabled"
						fi
						rm -f "$TMP_FILE"
						pause_menu
						;;

					2) 
						rc=0
						run_with_sudo $RDESK_CMD disable || rc=$?
						if [ $rc -eq 0 ] ; then
							RD_PASSWORD="?????"
							RD_STATUS="disabled"
						fi
						;;

					3)
						loginctl list-sessions
						echo "(To unlock, open a shell and execute command 'sudo loginctl unlock-session {ID})')"
						pause_menu
						;;

					8)
						show_menu
						;;
					9)
						echo "Use 'exit' command to return to RDesk console"
						/bin/bash --rcfile /usr/share/lliurex-rdesk-common/rdesk.bashrc
						# bash --rcfile /tmp/bashrc 
						;;
					0)
						if [ "$RD_STATUS" = "enabled" ] ; then
							b=""
							while [ "$b" != "Y" ] && [ "$b" != "N" ] ; do
								echo "RUSTDESK ACCESS is enabled"
								echo "Disable configuration before exiting? (Y/N)"
								read b
							done
							[ "$b" = "N" ] || run_with_sudo $RDESK_CMD disable
						fi
						echo "Program terminated. Now is safe to use [CTRL] C if required to return to SO"
						exit 0
						;;
				esac
				if [ "$a" ] ; then
					# refresh
					a=""
					show_menu
				fi
			done
			;;

		disable)
			root_test || die "You must be root to run this program"
			disable_connection
			;;

		remote-console)
	        	REMOTE_USER=""
		        REMOTE_IP=""
			if [ "$1" ] && echo "$1" |grep -q '@' ; then
		        	REMOTE_USER="${1%@*}"
			        REMOTE_IP="${1#*@}"
			fi
			if [ -z "$REMOTE_USER" ] || [ -z "$REMOTE_IP" ] ; then
				die "You must specify remote USER@IP_ADDRESS"
			fi
			RUSTDESK_PID="$(runtime_read 'REMOTE_CONSOLE')"
			if process_check "$RUSTDESK_PID" ; then
			       die "Remote-console already running"
			fi
			runtime_close
			runtime_write "REMOTE_CONSOLE" "$$"
			runtime_write "RD_IP" "$REMOTE_IP"
			launch_socks_tunnel "$REMOTE_USER" "$REMOTE_IP" "local-console"
			runtime_close
			;;

		create-tunnel)
			root_test || die "You must be root to run this program"
	        	REMOTE_USER=""
		        REMOTE_IP=""
			if [ "$1" ] && echo "$1" |grep -q '@' ; then
		        	REMOTE_USER="${1%@*}"
			        REMOTE_IP="${1#*@}"
			fi
			if [ -z "$REMOTE_USER" ] || [ -z "$REMOTE_IP" ] ; then
				die "You must specify remote USER@IP_ADDRESS"
			fi
			TUN_IP="$(gen_net_ip)"
			echo "***********************************"
			echo "Access remote host with command:"
			echo ""
			echo "$0 connect $TUN_IP"
			echo ""
			echo "***********************************"
			launch_tunnel  "$REMOTE_USER" "$REMOTE_IP" "$TUN_IP"
			;;

		desktop)
			if [ "$1" ] ; then
				REMOTE_IP="$1"
			else
				REMOTE_IP="$(runtime_read "RD_IP")"
			fi
			[ "$REMOTE_IP" ] || die "Unable to determine remote IP_ADDRESS, please specify in command line"
			if root_test ; then
				die "You must run this progran as NON root user"
			fi
			launch_rustdesk "$REMOTE_IP"
			;;
		socks-enable)
			root_test || die "You must be root to run this program"
			socks_enable "$@"
			;;
		socks-disable)
			root_test || die "You must be root to run this program"
			socks_disable "$@"
			;;
		info)
			show_host_info
			;;
		popup)
			if runtime_exists "POPUP" ; then
				return 0
			fi

			SHOW_POPUP="Y"
			runtime_write "POPUP" "ACTIVE"
			while  [ "$SHOW_POPUP" ] ; do
				notify-send -w -a lliurex-rdesk -t 0 "$(show_host_info)"
				if check_rustdesk_window ; then
		                        SHOW_POPUP="Y"
				else
		                        SHOW_POPUP=""
				fi
			done
			runtime_delete "POPUP"
			;;
		allow-access)
			RUSTDESK_PID="$(runtime_read ALLOW_ACCESS)"
			if process_check "$RUSTDESK_PID" ; then
			       die "Allow-access already running"
			fi
			reset_share_settings
			runtime_close
			$0 popup &
			runtime_write "ALLOW_ACCESS" "$$"
		        rustdesk
			runtime_close
			;;
		reset-share-settings)
			reset_share_settings
			;;
		*)
			usage
			;;
	esac
	exit 0

}


usage(){
        die "Usage" "$(basename "$0") {enable | disable | local-console | info | popup | allow-access | reset-share-settings}" \
            "       $(basename "$0") {socks-enable | socks-disable} [OPTIONS]" \
            "       $(basename "$0") remote-console {USER@REMOTE_IP}" \
            "       $(basename "$0") desktop [REMOTE_IP]" \
            "       $(basename "$0") create-tunnel {USER@REMOTE_IP}"
}

die(){
        TYPE="ERROR"
        if [ "$#" -gt 1 ] ; then
                TYPE="$1"
                shift
        fi
        printf "${TYPE}: " >&2
        while [ "$1" ] ; do
                echo "$1" >&2
                shift
        done
        echo "" >&2

        exit 1
}

pause_menu(){
	echo "Press ENTER key to return to RDesk console menu"
	read b
}


show_menu(){
	clear
	get_ssh_ip
	[ -z "$1" ] || echo -e "LliureX has you...\n"
	cat <<EOF
*******************************************
* LLIUREX RDESK MANAGER CONSOLE
EOF
	if [ "$SSH_CLIENT_IP" ] ; then
		echo "* CONNECTED AS: $USER@$SSH_SERVER_IP"
		echo "*         FROM: $SSH_CLIENT_IP"
	else
		echo "* LOCAL SESION"
	fi
	cat <<EOF
*******************************************

HOST INFO
---------
EOF
	show_host_info
	if which lliurex-version >/dev/null ; then
		echo -e "\nLLIUREX INFO"
		echo  "------------"
		show_lliurex_info
	else
		echo -e "\nSO INFO"
		echo "-------"
		lsb_release -a
	fi

	echo -e "\nRUSTDESK INFO"
	echo  "-------------"
	show_rustdesk_info
	cat <<EOF

********************************
* LLIUREX RDESK MANAGER MENU
********************************
1 Enable access (sudo required)
2 Disable access (sudo required)
3 List current sessions
--------------------------------
8 Refresh info
9 Run local shell
0 Exit
--------------------------------

EOF
}

get_ssh_ip(){
	SSH_CLIENT_IP="$(echo "$SSH_CONNECTION" |cut -f 1 -d ' ')"
	SSH_SERVER_IP="$(echo "$SSH_CONNECTION" |cut -f 3 -d ' ')"
}

get_ip(){
	# get first default route iface name
	GW_IFACE="$(LANG=C ip -4 route list 0/0 |head -1 |cut -d ' ' -f 5)"
	# print IP of GW_IFACE
	LANG=C ip a show dev "$GW_IFACE" |sed -ne "/^\s*inet\s/{s%^\s*inet\s*%%;s%/.*$%%;p}"
}

show_host_info(){
	cat <<EOF
HOST_NAME: $(hostname -f)
HOST_IP_ADDRESS:  $(get_ip)
EOF
}

show_lliurex_info(){
	cat <<EOF
HOST_VERSION: $(lliurex-version)
$(lliurex-version -g --tag-prefix '           ' |sed -e "1s%^\s*%HOST_TAGS: %")
EOF
}

show_rustdesk_info(){
	RD_VERSION="$(LANG=C dpkg -l rustdesk |tail -1 |sed -e "s%\s\+%\t%g" |cut -f 3)"
	RD_WINDOW="Y"
	check_rustdesk_window || RD_WINDOW="N"

cat <<EOF
RUSTDESK_VERSION: $RD_VERSION
RUSTDESK_ACCESS_STATUS: $RD_STATUS
RUSTDESK_PASSWORD: $RD_PASSWORD
RUSTDESK_WINDOW_DETECTED: $RD_WINDOW
EOF
}

reset_share_settings() {
	# clear and forget wayland screen selection choice
	# new aproach to remove settings ONLY for RustDesk
	# for x in $(flatpak permissions | awk '{print $2}'); do flatpak permission-remove screencast $x; done
	# rm -f ~/.local/share/flatpak/db/screencast
	#
	RD_CONFIG="$HOME/.config/rustdesk/RustDesk_local.toml"
	if [ -e "$RD_CONFIG" ] ; then
		RD_TOKEN="$(sed -n -e "/^\[options\]/,/^\[/{s/^wayland-restore-token[[:space:]]*=[[:space:]]*'\([^']*\)'/\1/p}" "$RD_CONFIG")"
		if [ "$RD_TOKEN" ] ; then
			flatpak permission-remove screencast "$RD_TOKEN"
			echo "Removed RustDesk screencast settings"
			return 0
		fi
	fi
	echo "Nothing to do"
	return 0
}

list_rustdesk_procs(){
	ps ax |grep "rustdesk" |grep -v grep
}

check_rustdesk_window(){
	if list_rustdesk_procs |grep -q "rustdesk$" || list_rustdesk_procs |grep -q "connect" ; then
		return 0
	fi
	return 1
}

parse_value(){
	KEY="$1"
	FILE="$2"
	sed -ne "/^$KEY:/{s%^.*:\s*%%;p}" "$FILE"
}

runtime_close(){
	rm -f "$RUNTIME_FILE"
}
runtime_open(){
	if [ "$RUNTIME_FILE" ] && [ -w "$RUNTIME_FILE" ] ; then
		return 0
	fi
	RUNTIME_DIR="$XDG_RUNTIME_DIR"
	if [ -z "$RUNTIME_DIR" ] || [ ! -w "$RUNTIME_DIR" ] ; then
		RUNTIME_DIR="/dev/shm/$USER"
		mkdir -p "$RUNTIME_DIR"
	fi
	RUNTIME_FILE="$RUNTIME_DIR/lliurex-rdesk"
	touch "$RUNTIME_FILE"
}

runtime_read(){
	runtime_open
	KEY="$1"
	parse_value "$KEY" "$RUNTIME_FILE"
}

runtime_exists(){
	[ "$(runtime_read "$1")" ] || return 1
	return 0
}

runtime_delete(){
	runtime_open
	KEY="$1"
	sed -i -e "/^${KEY}:/d" "$RUNTIME_FILE"
}

runtime_write(){
	runtime_open
	KEY="$1"
	VALUE="$2"
	runtime_delete "$KEY"
	echo "$KEY: $VALUE" >> "$RUNTIME_FILE"
}

process_check(){
	PID="$1"
	[ "$PID" ] || return 1
	[ -d "/proc/$PID" ] || return 1
	return 0
}

run_with_sudo(){
	sudo --preserve-env=SSH_CONNECTION "$@"
}


			
root_test(){
	[ $(id -u) -eq 0 ] || return 1
	return 0
}

test_rustdesk_installation(){
	PKG_NAME="rustdesk"
	dpkg -l "$PKG_NAME" >/dev/null 2>/dev/null || return 1
	return 0
}

install_rustdesk(){
	RUSTDESK_URL="https://github.com/rustdesk/rustdesk/releases/download/1.4.6/rustdesk-1.4.6-x86_64.deb"
	TMP_DIR="$(mktemp -d)"
	DEST_FILE="$TMP_DIR/rustdesk.deb"
	wget -O "$DEST_FILE" "$RUSTDESK_URL"
	rc=1
	echo "$DEST_FILE"
	ls -al "$DEST_FILE"

	if [ -s "$DEST_FILE" ] ; then
              rc=0
	      apt install -y "$DEST_FILE" || rc=$?
	fi
	rm -fr "$TMP_DIR"
	return $rc
}

gen_password(){
	tr -dc A-Za-z0-9 </dev/urandom | head -c 8
	echo ""
}

gen_net_address(){
	echo "10.10.10.1/24"
}

gen_net_ip(){
	gen_net_address |cut -f 1 -d "/"
}

create_net_alias(){
	NET_ADDRESS="$(gen_net_address)"
	ip a add "$NET_ADDRESS" dev lo
}

delete_net_alias(){
	NET_ADDRESS="$(gen_net_address)"
	ip a del "$NET_ADDRESS" dev lo
}

enable_connection(){
	CONN_PASS="$1"
	# configure rustdesk

	# enable lan access
	rustdesk --option direct-server Y

	# disable remote server
	rustdesk --config 'host=localhost'

	# set random password
	RND_PASS="$(gen_password)"
	rustdesk --password "$CONN_PASS"

	# disable connection if rustdesk window is closed
	rustdesk --option allow-only-conn-window-open Y


	# configure network alias
	# create_net_alias
	echo "Configuration enabled"
}



disable_connection(){
	# configure rustdesk

	# disable lan access
	rustdesk --option direct-server N

	# disable remote server
	rustdesk --config 'host=localhost'

	# disable password
	rustdesk --password ''

	# remove network alias
	
	#delete_net_alias
	echo "Configuration disabled"
}

launch_rustdesk(){
	REMOTE_IP="$1"
	rustdesk --connect "$REMOTE_IP"
}

tproxy_disable(){
	echo "Removing TPROXY settings"
	ip route del local default dev lo table 100
	ip rule del fwmark 1 lookup 100
}

tproxy_enable(){
	tproxy_disable
	echo "Adding TPROXY settings"
	ip route add local default dev lo table 100
	ip rule add fwmark 1 lookup 100
}

cfg_get_section(){
	SEC_NAME='.*'
	if [ "$1" ] ; then
		SEC_NAME="$1"
	fi
	grep -n  "^\[${SEC_NAME}\]$" "$ROOT_CFG" |cut -f1 -d ':'
}

cfg_sections_from_line(){
	BEGIN_LINE="$1"
	cfg_get_section |while read l; do
		if [ $l -gt $BEGIN_LINE ] ; then
			echo "$l"
		fi
	done
}

cfg_list(){
	ls -1 "$ROOT_CFG_DIR" | grep "^RustDesk2\.toml\.[[:digit:]]\+$" |sort -u
}

cfg_backup(){
	TIME_STAMP="$(date +%s)"
	cp "$ROOT_CFG" "${ROOT_CFG}.${TIME_STAMP}"
	# remove oldest backups
	MAX_BACKUP_FILES=4
	while [ "$(cfg_list |wc -l)" -gt $MAX_BACKUP_FILES ] ; do
		OLDEST_FILE="$(cfg_list |head -1)"
		rm -f "$ROOT_CFG_DIR/$OLDEST_FILE"
	done
}

rustdesk_restart(){
	systemctl daemon-reload
	# restart service
	RUSTDESK_SERVICE="rustdesk"
	systemctl restart "$RUSTDESK_SERVICE"
}

socks_disable(){
	if ! echo "$@" |grep -q "no-backup" ; then
		cfg_backup
	fi

	# TODO: find a better way to configure this settings ...
	FIRST_LINE="$(cfg_get_section "socks")"
	if [ "$FIRST_LINE" ]; then
		LAST_LINE='$'
		# get next section line number
		NEXT_LINE="$(cfg_sections_from_line $FIRST_LINE |head -1)"
		if [ "$NEXT_LINE" ]; then
			LAST_LINE=$(($NEXT_LINE -1))
		fi
		# remove section
		sed -i -e "$FIRST_LINE,${LAST_LINE}D" "$ROOT_CFG"
	fi

	if ! echo "$@" |grep -q "no-restart" ; then
		rustdesk_restart
	fi
}

socks_enable(){
	socks_disable no-restart
	# create new section
	cat <<EOF >> "$ROOT_CFG"

[socks]
proxy = 'socks5://localhost:$SOCKS_PORT'
username = ''
password = ''

EOF
	if ! echo "$@" |grep -q "no-restart" ; then
		rustdesk_restart
	fi
}

launch_tunnel(){
	launch_socks_tunnel "$@"
}

launch_socks_tunnel(){
	REMOTE_USER="$1"
	REMOTE_IP="$2"
	OPTION_CMD="$3"
	CMD_BASE="lliurex-rdesk"
	REMOTE_CMD="$CMD_BASE $OPTION_CMD"
	if [ "$OPTION_CMD" = "enable" ] ; then
		# deprecated
		REMOTE_CMD="sudo --preserve-env=SSH_CONNECTION $CMD_BASE enable"
	fi

	ssh -t -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -D $SOCKS_PORT ${REMOTE_USER}@${REMOTE_IP} "$REMOTE_CMD || echo '$CMD_BASE is NOT INSTALLLED in remote host'"
}

launch_sshuttle_tunnel(){
	REMOTE_USER="$1"
	REMOTE_IP="$2"
        TUN_IP="$3"
	tproxy_enable
	sshuttle -vr ${REMOTE_USER}@${REMOTE_IP} $TUN_IP --method tproxy --ssh-cmd 'ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' || true
	tproxy_disable
}

main "$@"
	

