extends Node

var SCRIPT_client
var SCRIPT_keyboard
var SCRIPT_locationListener
var SCRIPT_minimap
var SCRIPT_victoryListener
var SCRIPT_websocketserver

var ap_server = ""
var ap_user = ""
var ap_pass = ""
var connection_history = []
var show_compass = false
var show_locations = false
var show_minimap = false

var client
var keyboard

var _localdata_file = ""
var _last_new_item = -1
var _batch_locations = false
var _held_locations = []
var _held_location_scouts = []
var _location_scouts = {}
var _item_locks = {}
var _inverse_item_locks = {}
var _held_letters = {}
var _letters_setup = false
var _already_connected = false

const kSHUFFLE_LETTERS_VANILLA = 0
const kSHUFFLE_LETTERS_UNLOCKED = 1
const kSHUFFLE_LETTERS_PROGRESSIVE = 2
const kSHUFFLE_LETTERS_VANILLA_CYAN = 3
const kSHUFFLE_LETTERS_ITEM_CYAN = 4

const kLETTER_BEHAVIOR_VANILLA = 0
const kLETTER_BEHAVIOR_ITEM = 1
const kLETTER_BEHAVIOR_UNLOCKED = 2

const kCYAN_DOOR_BEHAVIOR_H2 = 0
const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
const kCYAN_DOOR_BEHAVIOR_ITEM = 2

const kEndingNameByVictoryValue = {
	0: "GRAY",
	1: "PURPLE",
	2: "MINT",
	3: "BLACK",
	4: "BLUE",
	5: "CYAN",
	6: "RED",
	7: "PLUM",
	8: "ORANGE",
	9: "GOLD",
	10: "YELLOW",
	11: "GREEN",
	12: "WHITE",
}

var apworld_version = [0, 0, 0]
var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
var daedalus_roof_access = false
var enable_gift_maps = []
var keyholder_sanity = false
var port_pairings = {}
var shuffle_control_center_colors = false
var shuffle_doors = false
var shuffle_gallery_paintings = false
var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
var shuffle_symbols = false
var shuffle_worldports = false
var strict_cyan_ending = false
var strict_purple_ending = false
var victory_condition = -1

var color_by_material_path = {}

signal could_not_connect
signal connect_status
signal ap_connected


func _init():
	# Read AP settings from file, if there are any
	if FileAccess.file_exists("user://ap_settings"):
		var file = FileAccess.open("user://ap_settings", FileAccess.READ)
		var data = file.get_var(true)
		file.close()

		if typeof(data) != TYPE_ARRAY:
			global._print("AP settings file is corrupted")
			data = []

		if data.size() > 0:
			ap_server = data[0]

		if data.size() > 1:
			ap_user = data[1]

		if data.size() > 2:
			ap_pass = data[2]

		if data.size() > 3:
			connection_history = data[3]

		if data.size() > 4:
			show_compass = data[4]

		if data.size() > 5:
			show_locations = data[5]

		if data.size() > 6:
			show_minimap = data[6]

	# We need to create a mapping from material paths to the original colors of
	# those materials. We force reload the materials, overwriting any custom
	# textures, and create the mapping. We then reload the textures in case the
	# player had a custom one enabled.
	var directory = DirAccess.open("res://assets/materials")
	for material_name in directory.get_files():
		var material = ResourceLoader.load(
			"res://assets/materials/" + material_name, "", ResourceLoader.CACHE_MODE_REPLACE
		)

		color_by_material_path[material.resource_path] = Color(material.albedo_color)

	settings.load_user_textures()


func _ready():
	client = SCRIPT_client.new()
	client.SCRIPT_websocketserver = SCRIPT_websocketserver

	client.item_received.connect(_process_item)
	client.location_scout_received.connect(_process_location_scout)
	client.text_message_received.connect(_process_text_message)
	client.item_sent_notification.connect(_process_item_sent_notification)
	client.hint_received.connect(_process_hint_received)
	client.accessible_locations_updated.connect(_on_accessible_locations_updated)
	client.checked_locations_updated.connect(_on_checked_locations_updated)
	client.checked_worldports_updated.connect(_on_checked_worldports_updated)
	client.door_latched.connect(_on_door_latched)

	client.could_not_connect.connect(_client_could_not_connect)
	client.connect_status.connect(_client_connect_status)
	client.client_connected.connect(_client_connected)

	add_child(client)

	keyboard = SCRIPT_keyboard.new()
	add_child(keyboard)
	client.keyboard_update_received.connect(keyboard.remote_keyboard_updated)


func saveSettings():
	# Save the AP settings to disk.
	var path = "user://ap_settings"
	var file = FileAccess.open(path, FileAccess.WRITE)

	var data = [
		ap_server,
		ap_user,
		ap_pass,
		connection_history,
		show_compass,
		show_locations,
		show_minimap,
	]
	file.store_var(data, true)
	file.close()


func saveLocaldata():
	# Save the MW/slot specific settings to disk.
	var dir = DirAccess.open("user://")
	var folder = "archipelago_data"
	if not dir.dir_exists(folder):
		dir.make_dir(folder)

	var file = FileAccess.open(_localdata_file, FileAccess.WRITE)

	var data = [
		_last_new_item,
	]
	file.store_var(data, true)
	file.close()


func connectToServer():
	_last_new_item = -1
	_batch_locations = false
	_held_locations = []
	_held_location_scouts = []
	_location_scouts = {}
	_letters_setup = false
	_held_letters = {}
	_already_connected = false

	client.connectToServer(ap_server, ap_user, ap_pass)


func getSaveFileName():
	return "zzAP_%s_%d" % [client._seed, client._slot]


func disconnect_from_ap():
	_already_connected = false

	var effects = global.get_node("Effects")
	effects.set_connection_lost(false)

	client.disconnect_from_ap()


func get_item_id_for_door(door_id):
	return _item_locks.get(door_id, null)


func _process_item(item, amount):
	var gamedata = global.get_node("Gamedata")

	var item_id = int(item["id"])
	var prog_id = null
	if _inverse_item_locks.has(item_id):
		for lock in _inverse_item_locks.get(item_id):
			if lock[1] != amount:
				continue

			if gamedata.progressive_id_by_ap_id.has(item_id):
				prog_id = lock[0]

			if gamedata.get_door_map_name(lock[0]) != global.map:
				continue

			# TODO: fix doors opening from door groups
			var receivers = gamedata.get_door_receivers(lock[0])
			var scene = get_tree().get_root().get_node_or_null("scene")
			if scene != null:
				for receiver in receivers:
					var rnode = scene.get_node_or_null(receiver)
					if rnode != null:
						rnode.handleTriggered()

	var letter_id = gamedata.letter_id_by_ap_id.get(item_id, null)
	if letter_id != null:
		var letter = gamedata.objects.get_letters()[letter_id]
		if not letter.has_level2() or not letter.get_level2():
			_process_key_item(letter.get_key(), amount)

	if gamedata.symbol_item_ids.has(item_id):
		var player = get_tree().get_root().get_node_or_null("scene/player")
		if player != null:
			player.evaluate_solvability.emit()

	if item_id == gamedata.objects.get_special_ids()["A Job Well Done"]:
		update_job_well_done_sign()

	# Show a message about the item if it's new.
	if int(item["index"]) > _last_new_item:
		_last_new_item = int(item["index"])
		saveLocaldata()

		var full_item_name = item["text"]
		if prog_id != null:
			var door = gamedata.objects.get_doors()[prog_id]
			full_item_name = "%s (%s)" % [full_item_name, door.get_name()]

		var message
		if "sender" in item:
			message = (
				"Received %s from %s"
				% [wrapInItemColorTags(full_item_name, item["flags"]), item["sender"]]
			)
		else:
			message = "Found %s" % wrapInItemColorTags(full_item_name, item["flags"])

		if gamedata.anti_trap_ids.has(item):
			keyboard.block_letter(gamedata.anti_trap_ids[item])

		global._print(message)

		global.get_node("Messages").showMessage(message)


func _process_item_sent_notification(message):
	var sentMsg = (
		"Sent %s to %s"
		% [
			wrapInItemColorTags(message["item_name"], message["item_flags"]),
			message["receiver_name"]
		]
	)
	#if _hinted_locations.has(message["item"]["location"]):
	#	sentMsg += " ([color=#fafad2]Hinted![/color])"
	global.get_node("Messages").showMessage(sentMsg)


func _process_hint_received(message):
	var is_for = ""
	if message["self"] == 0:
		is_for = " for %s" % message["receiver_name"]

	global.get_node("Messages").showMessage(
		(
			"Hint: %s%s is on %s"
			% [
				wrapInItemColorTags(message["item_name"], message["item_flags"]),
				is_for,
				message["location_name"]
			]
		)
	)


func _process_text_message(message):
	var parts = []
	for message_part in message:
		if message_part["type"] == "text":
			parts.append(message_part["text"])
		elif message_part["type"] == "player":
			if message_part["self"] == 1:
				parts.append("[color=#ee00ee]%s[/color]" % message_part["text"])
			else:
				parts.append("[color=#fafad2]%s[/color]" % message_part["text"])
		elif message_part["type"] == "item":
			parts.append(wrapInItemColorTags(message_part["text"], int(message_part["flags"])))
		elif message_part["type"] == "location":
			parts.append("[color=#00ff7f]%s[/color]" % message_part["text"])

	var textclient_node = global.get_node("Textclient")
	if textclient_node != null:
		textclient_node.parse_printjson("".join(parts))


func _process_location_scout(location_id, item_name, player_name, flags, for_self):
	_location_scouts[location_id] = {
		"item": item_name, "player": player_name, "flags": flags, "for_self": for_self
	}

	if for_self and flags & 4 != 0:
		# This is a trap for us, so let's not display it.
		return

	var gamedata = global.get_node("Gamedata")
	var map_id = gamedata.map_id_by_name.get(global.map)

	var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
	if letter_id != null:
		var letter = gamedata.objects.get_letters()[letter_id]
		var room = gamedata.objects.get_rooms()[letter.get_room_id()]
		if room.get_map_id() == map_id:
			var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
				letter.get_path()
			)
			if collectable != null:
				collectable.setScoutedText(item_name)


func _on_accessible_locations_updated():
	var textclient_node = global.get_node("Textclient")
	if textclient_node != null:
		textclient_node.update_locations()


func _on_checked_locations_updated():
	var textclient_node = global.get_node("Textclient")
	if textclient_node != null:
		textclient_node.update_locations(false)


func _on_checked_worldports_updated():
	var textclient_node = global.get_node("Textclient")
	if textclient_node != null:
		textclient_node.update_locations()
		textclient_node.update_worldports()


func _on_door_latched(door_id):
	var gamedata = global.get_node("Gamedata")
	if gamedata.get_door_map_name(door_id) != global.map:
		return

	var receivers = gamedata.get_door_receivers(door_id)
	var scene = get_tree().get_root().get_node_or_null("scene")
	if scene != null:
		for receiver in receivers:
			var rnode = scene.get_node_or_null(receiver)
			if rnode != null:
				rnode.handleTriggered()


func _client_could_not_connect(message):
	could_not_connect.emit(message)

	if global.loaded:
		var effects = global.get_node("Effects")
		effects.set_connection_lost(true)

		var messages = global.get_node("Messages")
		messages.showMessage("Connection to multiworld lost.")


func _client_connect_status(message):
	connect_status.emit(message)


func _client_connected(slot_data):
	var effects = global.get_node("Effects")
	effects.set_connection_lost(false)

	if _already_connected:
		var messages = global.get_node("Messages")
		messages.showMessage("Reconnected to multiworld!")
		return

	_already_connected = true

	var gamedata = global.get_node("Gamedata")

	_localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot]
	_last_new_item = -1

	if FileAccess.file_exists(_localdata_file):
		var ap_file = FileAccess.open(_localdata_file, FileAccess.READ)
		var localdata = []
		if ap_file != null:
			localdata = ap_file.get_var(true)
			ap_file.close()

		if typeof(localdata) != TYPE_ARRAY:
			print("AP localdata file is corrupted")
			localdata = []

		if localdata.size() > 0:
			_last_new_item = localdata[0]

	# Read slot data.
	cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0))
	daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
	enable_gift_maps = slot_data.get("enable_gift_maps", [])
	keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
	shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
	shuffle_doors = bool(slot_data.get("shuffle_doors", false))
	shuffle_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", false))
	shuffle_letters = int(slot_data.get("shuffle_letters", 0))
	shuffle_symbols = bool(slot_data.get("shuffle_symbols", false))
	shuffle_worldports = bool(slot_data.get("shuffle_worldports", false))
	strict_cyan_ending = bool(slot_data.get("strict_cyan_ending", false))
	strict_purple_ending = bool(slot_data.get("strict_purple_ending", false))
	victory_condition = int(slot_data.get("victory_condition", 0))

	if slot_data.has("version"):
		var version_msg = slot_data["version"]
		apworld_version = [int(version_msg[0]), int(version_msg[1]), 0]
		if version_msg.size() > 2:
			apworld_version[2] = int(version_msg[2])

	port_pairings.clear()
	if slot_data.has("port_pairings"):
		var raw_pp = slot_data.get("port_pairings")

		for p1 in raw_pp.keys():
			port_pairings[int(p1)] = int(raw_pp[p1])

	# Set up item locks.
	_item_locks = {}

	if shuffle_doors:
		for door in gamedata.objects.get_doors():
			if (
				door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD
				or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
			):
				_item_locks[door.get_id()] = [door.get_ap_id(), 1]

		for progressive in gamedata.objects.get_progressives():
			for i in range(0, progressive.get_doors().size()):
				var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
				_item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]

		for door_group in gamedata.objects.get_door_groups():
			if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR:
				if shuffle_worldports:
					continue
			elif door_group.get_type() != gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP:
				continue

			for door in door_group.get_doors():
				_item_locks[door] = [door_group.get_ap_id(), 1]

	if shuffle_control_center_colors:
		for door in gamedata.objects.get_doors():
			if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
				_item_locks[door.get_id()] = [door.get_ap_id(), 1]

		for door_group in gamedata.objects.get_door_groups():
			if (
				door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR
				and not shuffle_worldports
			):
				for door in door_group.get_doors():
					_item_locks[door] = [door_group.get_ap_id(), 1]

	if shuffle_gallery_paintings:
		for door in gamedata.objects.get_doors():
			if door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING:
				_item_locks[door.get_id()] = [door.get_ap_id(), 1]

	if cyan_door_behavior == kCYAN_DOOR_BEHAVIOR_ITEM:
		for door_group in gamedata.objects.get_door_groups():
			if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CYAN_DOORS:
				for door in door_group.get_doors():
					if not _item_locks.has(door):
						_item_locks[door] = [door_group.get_ap_id(), 1]

	# Create a reverse item locks map for processing items.
	_inverse_item_locks = {}

	for door_id in _item_locks.keys():
		var lock = _item_locks.get(door_id)

		if not _inverse_item_locks.has(lock[0]):
			_inverse_item_locks[lock[0]] = []

		_inverse_item_locks[lock[0]].append([door_id, lock[1]])

	if shuffle_worldports:
		var textclient = global.get_node("Textclient")
		textclient.setup_worldports()

	ap_connected.emit()


func start_batching_locations():
	_batch_locations = true


func send_location(loc_id):
	if client._checked_locations.has(loc_id):
		return

	if _batch_locations:
		_held_locations.append(loc_id)
	else:
		client.sendLocation(loc_id)


func scout_location(loc_id):
	if _location_scouts.has(loc_id):
		return _location_scouts.get(loc_id)

	if _batch_locations:
		_held_location_scouts.append(loc_id)
	else:
		client.scoutLocation(loc_id)

	return null


func stop_batching_locations():
	_batch_locations = false

	if not _held_locations.is_empty():
		client.sendLocations(_held_locations)
		_held_locations.clear()

	if not _held_location_scouts.is_empty():
		client.scoutLocations(_held_location_scouts)
		_held_location_scouts.clear()


func colorForItemType(flags):
	var int_flags = int(flags)
	if int_flags & 1:  # progression
		if int_flags & 2:  # proguseful
			return "#f0d200"
		else:
			return "#bc51e0"
	elif int_flags & 2:  # useful
		return "#2b67ff"
	elif int_flags & 4:  # trap
		return "#d63a22"
	else:  # filler
		return "#14de9e"


func wrapInItemColorTags(text, flags):
	var int_flags = int(flags)
	if int_flags & 1 and int_flags & 2:  # proguseful
		return "[rainbow]%s[/rainbow]" % text
	else:
		return "[color=%s]%s[/color]" % [colorForItemType(flags), text]


func get_letter_behavior(key, level2):
	if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
		return kLETTER_BEHAVIOR_UNLOCKED

	if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
		if level2:
			if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
				return kLETTER_BEHAVIOR_VANILLA
			else:
				return kLETTER_BEHAVIOR_ITEM
		else:
			return kLETTER_BEHAVIOR_UNLOCKED

	if not level2 and ["h", "i", "n", "t"].has(key):
		# This differs from the equivalent function in the apworld. Logically it is
		# the same as UNLOCKED since they are in the starting room, but VANILLA
		# means the player still has to actually pick up the letters.
		return kLETTER_BEHAVIOR_VANILLA

	if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
		return kLETTER_BEHAVIOR_ITEM

	return kLETTER_BEHAVIOR_VANILLA


func setup_keys():
	keyboard.load_seed()

	_letters_setup = true

	for k in _held_letters.keys():
		_process_key_item(k, _held_letters[k])

	_held_letters.clear()


func _process_key_item(key, level):
	if not _letters_setup:
		_held_letters[key] = max(_held_letters.get(key, 0), level)
		return

	if shuffle_letters == kSHUFFLE_LETTERS_ITEM_CYAN:
		level += 1

	keyboard.collect_remote_letter(key, level)


func update_job_well_done_sign():
	if global.map != "daedalus":
		return

	var gamedata = global.get_node("Gamedata")
	var job_item = gamedata.objects.get_special_ids()["A Job Well Done"]
	var jobs_done = client.getItemAmount(job_item)

	var sign2 = get_tree().get_root().get_node_or_null("scene/Meshes/Miscellaneous/sign2")
	var sign3 = get_tree().get_root().get_node_or_null("scene/Meshes/Miscellaneous/sign3")

	if sign2 != null and sign3 != null:
		if jobs_done == 0:
			sign2.text = "what are you doing"
			sign3.text = "?"
		elif jobs_done == 1:
			sign2.text = "a job well done"
			sign3.text = "is its own reward"
		else:
			sign2.text = "%d jobs well done" % jobs_done
			sign3.text = "are their own reward"

		sign2.get_node("MeshInstance3D").mesh.text = sign2.text
		sign3.get_node("MeshInstance3D").mesh.text = sign3.text