@tool
extends EditorPlugin


#------------------------------- SETUP -------------------------------
# Utilities
var Utils = preload("res://addons/godot_super-wakatime/utils.gd").new()
var DecompressorUtils = preload("res://addons/godot_super-wakatime/decompressor.gd").new()

# Hearbeat class
const HeartBeat = preload("res://addons/godot_super-wakatime/heartbeat.gd")
var last_heartbeat = HeartBeat.new()

# Paths, Urls
const PLUGIN_PATH: String = "res://addons/godot_super-wakatime"
const ZIP_PATH: String = "%s/wakatime.zip" % PLUGIN_PATH

const WAKATIME_URL_FMT: String = \
	"https://github.com/wakatime/wakatime-cli/releases/download/v1.54.0/{wakatime_build}.zip"
const DECOMPERSSOR_URL_FMT: String = \
	"https://github.com/ouch-org/ouch/releases/download/0.3.1/{ouch_build}"

# Names for menu
const API_MENU_ITEM: String = "Wakatime API key"
const CONFIG_MENU_ITEM: String = "Wakatime Config File"

# Directories to grab wakatime from
var wakatime_dir = null
var wakatime_cli = null
var decompressor_cli = null

var ApiKeyPrompt: PackedScene = preload("res://addons/godot_super-wakatime/api_key_prompt.tscn")
var Counter: PackedScene = preload("res://addons/godot_super-wakatime/counter.tscn")

# Set platform
var system_platform: String = Utils.set_platform()[0]
var system_architecture: String = Utils.set_platform()[1]

var debug: bool = false
var last_scene_path: String = ''
var last_file_path: String = ''
var last_time: int = 0
var previous_state: String = ''
const LOG_INTERVAL: int = 60000
var scene_mode: bool = false

var key_get_tries: int = 0
var counter_instance: Node
var current_time: String = "0 hrs, 0mins"


# #------------------------------- DIRECT PLUGIN FUNCTIONS -------------------------------
func _ready() -> void:
	setup_plugin()
	set_process(true)
	
func _exit_tree() -> void:
	_disable_plugin()
	set_process(false)
	
	
func _physics_process(delta: float) -> void:
	"""Process plugin changes over time"""
	# Every 1000 frames check for updates
	if Engine.get_physics_frames() % 1000 == 0:
		# Check for scene change
		var scene_root = get_editor_interface().get_edited_scene_root()
		if scene_root:
			var current_scene_path = _get_current_scene()
			
			# If currently used scene is different thatn 1000 frames ago, log activity
			if current_scene_path != last_scene_path:
				last_scene_path = current_scene_path
				handle_activity_scene(current_scene_path, false, true)
				
			else:
				# Check for scene updates
				var current_scene = EditorInterface.get_edited_scene_root()
				if current_scene:
					var state = generate_scene_state(current_scene)
					# If current state is different than the previous one, handle activity
					if state != previous_state:
						previous_state = state
						handle_activity_scene(current_scene_path, true)
					# Otherwise just keep scene the same
					else:
						previous_state = state
		else:
			last_scene_path = '' 
					
func generate_scene_state(node: Node) -> String:
	"""Generate a scene state identifier"""
	var state = str(node.get_instance_id())
	for child in node.get_children():
		state += str(child.get_instance_id())
	return str(state)
	
func _input(event: InputEvent) -> void:
	"""Handle all input events"""
	# Key events
	if event is InputEventKey:
		var file = get_current_file()
		if file:
			handle_activity(ProjectSettings.globalize_path(file.resource_path))
	# Mouse button events
	elif event is InputEventMouse and event.is_pressed():
		var file = _get_current_scene()
		if file != '' and file:
			handle_activity_scene(file)

func setup_plugin() -> void:
	"""Setup Wakatime plugin, download dependencies if needed, initialize menu"""
	Utils.plugin_print("Setting up %s" % get_user_agent())
	check_dependencies()
	
	# Grab API key if needed
	var api_key = get_api_key()
	if api_key == null:
		request_api_key()
	await get_tree().process_frame
	
	# Add menu buttons
	add_tool_menu_item(API_MENU_ITEM, request_api_key)
	add_tool_menu_item(CONFIG_MENU_ITEM, open_config)
	
	counter_instance = Counter.instantiate()
	add_control_to_bottom_panel(counter_instance, current_time)
	
	# Connect code editor signals
	var script_editor: ScriptEditor = get_editor_interface().get_script_editor()
	script_editor.call_deferred("connect", "editor_script_changed", Callable(self, 
		"_on_script_changed"))

func _disable_plugin() -> void:
	"""Cleanup after disabling plugin"""
	# Remove items from menu
	remove_tool_menu_item(API_MENU_ITEM)
	remove_tool_menu_item(CONFIG_MENU_ITEM)
	
	remove_control_from_bottom_panel(counter_instance)
	
	# Disconnect script editor tracking
	var script_editor: ScriptEditor = get_editor_interface().get_script_editor()
	if script_editor.is_connected("editor_script_changed", Callable(self, 
		"_on_script_changed")):
		script_editor.disconnect("editor_script_changed", Callable(self, 
			"_on_script_changed"))
		
func _on_script_changed(file) -> void:
	"""Handle changing scripts"""
	if file:
		last_file_path = ProjectSettings.globalize_path(file.resource_path)
	handle_activity(last_file_path)
	
#func _unhandled_key_input(event: InputEvent) -> void:
#	"""Handle key inputs"""
#	var file = get_current_file()
#	handle_activity(file)
	
func _save_external_data() -> void:
	"""Handle saving files"""
	var file = get_current_file()
	if file:
		handle_activity(ProjectSettings.globalize_path(file.resource_path), true)
	
func _get_current_scene():
	"""Get currently used scene"""
	if EditorInterface.get_edited_scene_root():
		var file = EditorInterface.get_edited_scene_root()
		if file:
			return ProjectSettings.globalize_path(file.scene_file_path)
	else:
		var file = get_current_file()
		if file:
			return ProjectSettings.globalize_path(file.resource_path)
			
	return null
	
func _on_scene_modified():
	"""Send heartbeat when scene is modified"""
	var current_scene = get_tree().current_scene
	if current_scene:
		handle_activity_scene(_get_current_scene())
	
func get_current_file():
	"""Get currently used script file"""
	var file = get_editor_interface().get_script_editor().get_current_script()
	if file:
		last_file_path = ProjectSettings.globalize_path(file.resource_path)
	
	return get_editor_interface().get_script_editor().get_current_script()
		
func handle_activity(file, is_write: bool = false) -> void:
	"""Handle user's activity"""
	# If file that has activity in or wakatime cli doesn't exist, return
	if not file or not Utils.wakatime_cli_exists(get_waka_cli()):
		return
	
	# If user is saving file or has changed path, or enough time has passed for a heartbeat - send it
	#var filepath = ProjectSettings.globalize_path(file.resource_path)
	if is_write or file != last_heartbeat.file_path or enough_time_passed():
		send_heartbeat(file, is_write)
		
func handle_activity_scene(file, is_write: bool = false, changed_file: bool = false) -> void:
	"""Handle activity in scenes"""
	if not file or not Utils.wakatime_cli_exists(get_waka_cli()):
		return
		
	if is_write or changed_file or enough_time_passed():
		scene_mode = true
		send_heartbeat(file, is_write)
		
func send_heartbeat(filepath: String, is_write: bool) -> void:
	"""Send Wakatimde heartbeat for the specified file"""
	# Check Wakatime API key
	var api_key = get_api_key()
	if api_key == null:
		Utils.plugin_print("Failed to get Wakatime API key. Are you sure it's correct?")
		if (key_get_tries < 3):
			request_api_key()
			key_get_tries += 1
		else:
			Utils.plugin_print("If this keep occuring, please create a file: ~/.wakatime.cfg\n
				initialize it with:\n[settings]\napi_key={your_key}")
		return
		
	# Make sure not to trigger additional heartbeats cause of events from scenes
	var file = filepath
	if scene_mode:
		file = last_file_path
		#print("\n-------SCENE MODE--------\n")
		
	# Create heartbeat
	var heartbeat = HeartBeat.new(file, Time.get_unix_time_from_system(), is_write)
	
	# Current text editor
	var text_editor = _find_active_script_editor()
	var cursor_pos = _get_cursor_pos(text_editor)
	
	# Append all informations as Wakatime CLI arguments
	var cmd: Array[Variant] = ["--entity", filepath, "--key", api_key]
	if is_write:
		cmd.append("--write")
	cmd.append_array(["--alternate-project", ProjectSettings.get("application/config/name")])
	cmd.append_array(["--time", str(heartbeat.time)])
	cmd.append_array(["--lineno", str(cursor_pos.line)])
	cmd.append_array(["--cursorpos", str(cursor_pos.column)])
	cmd.append_array(["--plugin", get_user_agent()])
	
	cmd.append_array(["--alternate-language", "Scene"])
	if scene_mode:
		cmd.append_array(["--category", "building"])
	else:
		cmd.append(["--category", "coding"])	
	
	# Send heartbeat using Wakatime CLI
	var cmd_callable = Callable(self, "_handle_heartbeat").bind(cmd)
	
	scene_mode = false
	
	WorkerThreadPool.add_task(cmd_callable)
	last_heartbeat = heartbeat
	
func _find_active_script_editor():
	"""Return currently used script editor"""
	# Get script editor
	var script_editor = get_editor_interface().get_script_editor()
	var current_editor = script_editor.get_current_editor()
	
	# Try to find code editor from it
	if current_editor:
		return _find_code_edit_recursive(script_editor.get_current_editor())
	return null

func _find_code_edit_recursive(node: Node) -> CodeEdit:
	"""Find recursively code editor in a node"""
	# If node is already a code editor, return it
	if node is CodeEdit:
		return node

	# Try to find it in every child of a given node		
	for child in node.get_children():
		var editor = _find_code_edit_recursive(child)
		if editor:
			return editor
	return null
	
func _get_cursor_pos(text_editor) -> Dictionary:
	"""Get cursor editor from the given text editor"""
	if text_editor:
		
		return {
			"line": text_editor.get_caret_line() + 1,
			"column": text_editor.get_caret_column() + 1
		}
		
	return {
		"line": 0,
		"column": 0
	}
	
func _handle_heartbeat(cmd_arguments) -> void:
	"""Handle sending the heartbeat"""
	# Get Wakatime CLI and try to send a heartbeat
	if wakatime_cli == null:
		wakatime_cli = Utils.get_waka_cli()
		
	var output: Array[Variant] = []
	var exit_code: int = OS.execute(wakatime_cli, cmd_arguments, output, true)
	
	update_today_time(wakatime_cli)
		
	# Inform about success or errors if user is in debug
	if debug:
		if exit_code == -1:
			Utils.plugin_print("Failed to send heartbeat: %s" % output)
		else:
			Utils.plugin_print("Heartbeat sent: %s" % output)
			
func enough_time_passed():
	"""Check if enough time has passed for another heartbeat"""
	return Time.get_unix_time_from_system() - last_heartbeat.time >= HeartBeat.FILE_MODIFIED_DELAY
	
func update_today_time(wakatime_cli) -> void:
	"""Update today's time in menu"""
	var output: Array[Variant] = []
	# Get today's time from Wakatime CLI
	var exit_code: int = OS.execute(wakatime_cli, ["--today"], output, true)
	
	# Convert it and combine different categories into
	if exit_code == 0:
		current_time = convert_time(output[0])
	else:
		current_time = "Wakatime"
	#print(current_time)
	call_deferred("_update_panel_label", current_time, output[0])
	
func _update_panel_label(label: String, content: String):
	"""Update bottom panel name that shows time"""
	# If counter exists and it has a label, update both the label and panel's name
	if counter_instance and counter_instance.get_node("HBoxContainer/Label"):
		counter_instance.get_node("HBoxContainer/Label").text = content
		# Workaround to rename panel
		remove_control_from_bottom_panel(counter_instance)
		add_control_to_bottom_panel(counter_instance, label)
		
func convert_time(complex_time: String):
	"""Convert time from complex format into basic one, combine times"""
	return complex_time
	
	"""
	# Split times into categories
	var time_categories = complex_time.split(', ')
	for category in time_categories:
		# Split time into parts, get first and third part (hours and minutes)
		var time_parts = category.split(' ')
		if time_parts.size() >= 3:
			hours += int(time_parts[0])
			minutes += int(time_parts[2])
	
	# Wrap minutes into hours if needed
	while minutes >= 60:
		minutes -= 60
		hours += 1

	return str(hours) + " hrs, " + str(minutes) + " mins"
	"""

#------------------------------- FILE FUNCTIONS -------------------------------
func open_config() -> void:
	"""Open wakatime config file"""
	OS.shell_open(Utils.config_filepath(system_platform, PLUGIN_PATH))
	
func get_waka_dir() -> String:
	"""Search for and return wakatime directory"""
	if wakatime_dir == null:
		wakatime_dir = "%s/.wakatime" % Utils.home_directory(system_platform, PLUGIN_PATH)
	return wakatime_dir
	
func get_waka_cli() -> String:
	"""Get wakatime_cli file"""
	if wakatime_cli == null:
		var build = Utils.get_waka_build(system_platform, system_architecture)
		var ext: String = ".exe" if system_platform == "windows" else ''
		wakatime_cli = "%s/%s%s" % [get_waka_dir(), build, ext]
	return wakatime_cli
	
func check_dependencies() -> void:
	"""Make sure all dependencies exist"""
	if !Utils.wakatime_cli_exists(get_waka_cli()):
		download_wakatime()
		if !DecompressorUtils.lib_exists(decompressor_cli, system_platform, PLUGIN_PATH):
			download_decompressor()
	
func download_wakatime() -> void:
	"""Download wakatime cli"""
	Utils.plugin_print("Downloading Wakatime CLI...")
	var url: String = WAKATIME_URL_FMT.format({"wakatime_build": 
			Utils.get_waka_build(system_platform, system_architecture)})
	
	# Try downloading wakatime
	var http = HTTPRequest.new()
	http.download_file = ZIP_PATH
	http.connect("request_completed", Callable(self, "_wakatime_download_completed"))
	add_child(http)
	
	# Handle errors
	var status = http.request(url)
	if status != OK:
		Utils.plugin_print_err("Failed to start downloading Wakatime [Error: %s]" % status)
		_disable_plugin()
	
func download_decompressor() -> void:
	"""Download ouch decompressor"""
	Utils.plugin_print("Downloading Ouch! decompression library...")
	var url: String = DECOMPERSSOR_URL_FMT.format({"ouch_build": 
			Utils.get_ouch_build(system_platform)})
	if system_platform == "windows":
		url += ".exe"
		
	# Try to download ouch
	var http = HTTPRequest.new()
	http.download_file = DecompressorUtils.decompressor_cli(decompressor_cli, system_platform, PLUGIN_PATH)
	http.connect("request_completed", Callable(self, "_decompressor_download_finished"))
	add_child(http)
	
	# Handle errors
	var status = http.request(url)
	if status != OK:
		_disable_plugin()
		Utils.plugin_print_err("Failed to start downloading Ouch! library [Error: %s]" % status)
		
func _wakatime_download_completed(result, status, headers, body) -> void:
	"""Finish downloading wakatime, handle errors"""
	if result != HTTPRequest.RESULT_SUCCESS:
		Utils.plugin_print_err("Error while downloading Wakatime CLI")
		_disable_plugin()
		return
	
	Utils.plugin_print("Wakatime CLI has been installed succesfully! Located at %s" % ZIP_PATH)
	extract_files(ZIP_PATH, get_waka_dir())
	
func _decompressor_download_finished(result, status, headers, body) -> void:
	"""Handle errors and finishi decompressor download"""
	# Error while downloading
	if result != HTTPRequest.RESULT_SUCCESS:
		Utils.plugin_print_err("Error while downloading Ouch! library")
		_disable_plugin()
		return
	
	# Error while saving
	if !DecompressorUtils.lib_exists(decompressor_cli, system_platform, PLUGIN_PATH):
		Utils.plugin_print_err("Failed to save Ouch! library")
		_disable_plugin()
		return

	# Save decompressor path, give write permissions to it
	var decompressor: String = \
		ProjectSettings.globalize_path(DecompressorUtils.decompressor_cli(decompressor_cli, 
			system_platform, PLUGIN_PATH))
			
	if system_platform == "linux" or system_platform == "darwin":
		OS.execute("chmod", ["+x", decompressor], [], true)
		
	# Extract files, allowing usage of Ouch!
	Utils.plugin_print("Ouch! has been installed succesfully! Located at %s" % \
		DecompressorUtils.decompressor_cli(decompressor_cli, system_platform, PLUGIN_PATH))
	extract_files(ZIP_PATH, get_waka_dir())
	
func extract_files(source: String, destination: String) -> void:
	"""Extract downloaded Wakatime zip"""
	# If decompression library and wakatime zip folder don't exist, return
	if not DecompressorUtils.lib_exists(decompressor_cli, system_platform, 
			PLUGIN_PATH) and not Utils.wakatime_zip_exists(ZIP_PATH):
		return
		
	# Get paths as global
	Utils.plugin_print("Extracting Wakatime...")
	var decompressor: String
	if system_platform == "windows":
		decompressor = ProjectSettings.globalize_path( 
			DecompressorUtils.decompressor_cli(decompressor_cli, system_platform, PLUGIN_PATH))
	else:
		decompressor = ProjectSettings.globalize_path("res://" +
			DecompressorUtils.decompressor_cli(decompressor_cli, system_platform, PLUGIN_PATH))
		
	var src: String = ProjectSettings.globalize_path(source)
	var dest: String = ProjectSettings.globalize_path(destination)
	
	# Execute Ouch! decompression command, catch errors
	var errors: Array[Variant] = []
	var args: Array[String] = ["--yes", "decompress", src, "--dir", dest]
	
	var error: int = OS.execute(decompressor, args, errors, true)
	if error:
		Utils.plugin_print(errors)
		_disable_plugin()
		return
		
	# Results
	if Utils.wakatime_cli_exists(get_waka_cli()):
		Utils.plugin_print("Wakatime CLI installed (path: %s)" % get_waka_cli())
	else:
		Utils.plugin_print_err("Installation of Wakatime failed")
		_disable_plugin()
		
	# Remove leftover files
	clean_files()
	
func clean_files():
	"""Delete files that aren't needed anymore"""
	if Utils.wakatime_zip_exists(ZIP_PATH):
		delete_file(ZIP_PATH)
	if DecompressorUtils.lib_exists(decompressor_cli, system_platform, PLUGIN_PATH):
		delete_file(ZIP_PATH)
		
func delete_file(path: String) -> void:
	"""Delete file at specified path"""
	var dir: DirAccess = DirAccess.open("res://")
	var status: int = dir.remove(path)
	if status != OK:
		Utils.plugin_print_err("Failed to clean unnecesary file at %s" % path)
	else:
		Utils.plugin_print("Clean unncecesary file at %s" % path)

#------------------------------- API KEY FUNCTIONS -------------------------------

func get_api_key():
	"""Get wakatime api key"""
	var result = []
	# Handle errors while getting the key
	var err = OS.execute(get_waka_cli(), ["--config-read", "api_key"], result)
	if err == -1:
		return null
		
	# Trim API key from whitespaces and return it
	var key = result[0].strip_edges()
	if key.is_empty():
		return null
	return key
	
func request_api_key() -> void:
	"""Request Wakatime API key from the user"""
	# Prepare prompt
	var prompt = ApiKeyPrompt.instantiate()
	_set_api_key(prompt, get_api_key())
	_register_api_key_signals(prompt)
	
	# Show prompt and hide it on request
	add_child(prompt)
	prompt.popup_centered()
	await prompt.popup_hide
	prompt.queue_free()
	
func _set_api_key(prompt: PopupPanel, api_key) -> void:
	"""Set API key from prompt"""
	# Safeguard against empty key
	if api_key == null:
		api_key = ''
		
	# Set correct text, to show API key
	var edit_field: Node = prompt.get_node("VBoxContainer/HBoxContainerTop/LineEdit")
	edit_field.text = api_key
	
func _register_api_key_signals(prompt: PopupPanel) -> void:
	"""Connect all signals related to API key popup"""
	# Get all Nodes
	var show_button: Node = prompt.get_node("VBoxContainer/HBoxContainerTop/ShowButton")
	var save_button: Node = prompt.get_node("VBoxContainer/HBoxContainerBottom/SubmitButton")
	
	# Connect them to press events
	show_button.connect("pressed", Callable(self, "_on_toggle_key_text").bind(prompt))
	save_button.connect("pressed", Callable(self, "_on_save_key").bind(prompt))
	prompt.connect("popup_hide", Callable(self, "_on_popup_hide").bind(prompt))
	
func _on_popup_hide(prompt: PopupPanel):
	"""Close the popup window when user wants to hide it"""
	prompt.queue_free()
	
func _on_toggle_key_text(prompt: PopupPanel) -> void:
	"""Handle hiding and showing API key"""
	# Get nodes
	var show_button: Node = prompt.get_node("VBoxContainer/HBoxContainerTop/ShowButton")
	var edit_field: Node = prompt.get_node("VBoxContainer/HBoxContainerTop/LineEdit")
	
	# Set the correct text and hide field if needed
	edit_field.secret = not edit_field.secret
	show_button.text = "Show" if edit_field.secret else "Hide"
	
func _on_save_key(prompt: PopupPanel) -> void:
	"""Handle entering API key"""
	# Get text field node and api key that's entered
	var edit_field: Node = prompt.get_node("VBoxContainer/HBoxContainerTop/LineEdit")
	var api_key  = edit_field.text.strip_edges()
	
	# Try to set api key for wakatime and handle errors
	var err: int = OS.execute(get_waka_cli(), ["--config-write", "api-key=%s" % api_key])
	if err == -1:
		Utils.plugin_print("Failed to save API key")
	prompt.visible = false
	
#------------------------------- PLUGIN INFORMATIONS -------------------------------
	
func get_user_agent() -> String:
	"""Get user agent identifier"""
	var os_name = OS.get_name().to_lower()
	return "godot/%s godot-wakatime/%s" % [
		get_engine_version(), 
		_get_plugin_version()
	]
	
func _get_plugin_name() -> String:
	"""Get name of the plugin"""
	return "Godot_Super-Wakatime"
	
func _get_plugin_version() -> String:
	"""Get plugin version"""
	return "1.0.0"
	
func _get_editor_name() -> String:
	"""Get name of the editor"""
	return "Godot%s" % get_engine_version()
	
func get_engine_version() -> String:
	"""Get verison of currently used engine"""
	return "%s.%s.%s" % [Engine.get_version_info()["major"], Engine.get_version_info()["minor"], 
		Engine.get_version_info()["patch"]]