# warning-ignore-all:unused_class_variable
# ############################################################################ #
# Copyright © 2015-2021 inkle Ltd.
# Copyright © 2019-2022 Frédéric Maquin <fred@ephread.com>
# All Rights Reserved
#
# This file is part of inkgd.
# inkgd is licensed under the terms of the MIT license.
# ############################################################################ #

extends InkObject

class_name InkList

# ############################################################################ #

# (Dictionary<InkItem, int>, Array<String>, Array<InkListDefinition>)
func _init_from_csharp(items: Dictionary, origin_names: Array, origins: Array):
	_dictionary = items
	_origin_names = origin_names
	self.origins = origins


# (InkList) -> InkList
func _init_with_ink_list(other_list: InkList):
	_dictionary = other_list._dictionary.duplicate()
	var other_origin_names = other_list.origin_names
	if other_origin_names != null:
		_origin_names = other_list.origin_names.duplicate()

	if other_list.origins != null:
		self.origins = other_list.origins.duplicate()


# (string, Story) -> InkList
func _init_with_origin(single_origin_list_name: String, origin_story: InkStory):
	set_initial_origin_name(single_origin_list_name)

	var def: InkTryGetResult = origin_story.list_definitions.try_list_get_definition(single_origin_list_name)
	if def.exists:
		origins = [def.result]
	else:
		InkUtils.throw_exception(
				"InkList origin could not be found in story when constructing new list: %s" \
				% single_origin_list_name
		)


# (InkListItem, int) -> InkList
func _init_with_single_item(single_item: InkListItem, single_value: int):
	set_item(single_item, single_value)


# (string, Story) -> InkList
static func from_string(my_list_item: String, origin_story: InkStory) -> InkList:
	var list_value: InkListValue = origin_story.list_definitions.find_single_item_list_with_name(my_list_item)
	if list_value:
		return InkList.new_with_ink_list(list_value.value)
	else:
		InkUtils.throw_exception(
				"Could not find the InkListItem from the string '%s' to create an InkList because " +
				"it doesn't exist in the original list definition in ink." % my_list_item
		)
		return null


func add_item(item: InkListItem) -> void:
	if item.origin_name == null:
		add_item(item.item_name)
		return

	for origin in self.origins:
		if origin.name == item.origin_name:
			var int_val: InkTryGetResult = origin.try_get_value_for_item(item)
			if int_val.exists:
				set_item(item, int_val.result)
				return
			else:
				InkUtils.throw_exception(
						"Could not add the item '%s' to this list because it doesn't exist in the " +
						"original list definition in ink." % item._to_string()
				)
				return

	InkUtils.throw_exception(
			"Failed to add item to list because the item was from a new list definition that " +
			"wasn't previously known to this list. Only items from previously known lists can " +
			"be used, so that the int value can be found."
	)


func add_item_by_string(item_name: String) -> void:
	var found_list_def: InkListDefinition = null

	for origin in self.origins:
		if origin.contains_item_with_name(item_name):
			if found_list_def != null:
				InkUtils.throw_exception(
						"Could not add the item " + item_name + " to this list because it could " +
						"come from either " + origin.name + " or " + found_list_def.name
				)
				return
			else:
				found_list_def = origin

	if found_list_def == null:
		InkUtils.throw_exception(
				"Could not add the item " + item_name + " to this list because it isn't known " +
				"to any list definitions previously associated with this list."
		)
		return

	var item = InkListItem.new_with_origin_name(found_list_def.name, item_name)
	var item_val: int = found_list_def.value_for_item(item)
	set_item(item, item_val)


func contains_item_named(item_name: String) -> bool:
	for item_key in keys():
		if item_key.item_name == item_name:
			return true

	return false


# Array<ListDefinition>
var origins = null
var origin_of_max_item: InkListDefinition: get = get_origin_of_max_item
func get_origin_of_max_item() -> InkListDefinition:
	if self.origins == null:
		return null

	var max_origin_name = self.max_item.key.origin_name
	for origin in self.origins:
		if origin.name == max_origin_name:
			return origin

	return null


# Array<String>
var origin_names : get = get_origin_names
func get_origin_names():
	if self.size() > 0:
		if _origin_names == null && self.size() > 0:
			_origin_names = []
		else:
			_origin_names.clear()

		for item_key in keys():
			_origin_names.append(item_key.origin_name)

	return _origin_names


var _origin_names = null # Array<String>
func set_initial_origin_name(initial_origin_name: String) -> void:
	_origin_names = [ initial_origin_name ]


# (Array<String>) -> void
func set_initial_origin_names(initial_origin_names) -> void:
	if initial_origin_names == null:
		_origin_names = null
	else:
		_origin_names = initial_origin_names.duplicate()


# TODO: Make inspectable
var max_item: InkKeyValuePair: # InkKeyValuePair<InkListItem, int>
	get:
		var _max_item: InkKeyValuePair = InkKeyValuePair.new_with_key_value(InkListItem.null_item, 0)
		for k in keys():
			if (_max_item.key.is_null || get_item(k) > _max_item.value):
				_max_item = InkKeyValuePair.new_with_key_value(k, get_item(k))

		return _max_item


# TODO: Make inspectable
var min_item: InkKeyValuePair: # InkKeyValuePair<InkListItem, int>
	get:
		var _min_item: InkKeyValuePair = InkKeyValuePair.new_with_key_value(InkListItem.null_item, 0)
		for k in keys():
			if (_min_item.key.is_null || get_item(k) < _min_item.value):
				_min_item = InkKeyValuePair.new_with_key_value(k, get_item(k))

		return _min_item


# TODO: Make inspectable
var inverse: InkList: get = get_inverse
func get_inverse() -> InkList:
	var list: InkList = InkList.new()
	if self.origins != null:
		for origin in self.origins:
			for serialized_item_key in origin.items:
				if !_dictionary.has(serialized_item_key):
					list._dictionary[serialized_item_key] = origin.items[serialized_item_key]

	return list


# TODO: Make inspectable
var all: InkList: get = get_all
func get_all() -> InkList:
	var list: InkList = InkList.new()
	if self.origins != null:
		for origin in self.origins:
			for serialized_item_key in origin.items:
				list._dictionary[serialized_item_key] = origin.items[serialized_item_key]

	return list


# TODO: Make inspectable
func union(other_list: InkList) -> InkList:
	var union: InkList = InkList.new_with_ink_list(self)
	for key in other_list._dictionary:
		union._dictionary[key] = other_list._dictionary[key]
	return union


# TODO: Make inspectable
func intersection(other_list: InkList) -> InkList:
	var intersection: InkList = InkList.new()
	for key in other_list._dictionary:
		if self._dictionary.has(key):
			intersection._dictionary[key] = other_list._dictionary[key]
	return intersection


func has_intersection(other_list: InkList) -> bool:
	for key in other_list._dictionary:
		if self._dictionary.has(key):
			return true
	return false


# TODO: Make inspectable
func without(list_to_remove: InkList) -> InkList:
	var result = InkList.new_with_ink_list(self)
	for key in list_to_remove._dictionary:
		result._dictionary.erase(key)
	return result


func contains(other_list: InkList) -> bool:
	if other_list._dictionary.is_empty() || self._dictionary.is_empty():
		return false

	for key in other_list._dictionary:
		if !_dictionary.has(key):
			return false

	return true


# In the original source code 'list_item_name' is of type (String | null),
# but the method doesn't need to allow null names.
func contains_item(list_item_name: String) -> bool:
	for key in self._dictionary:
		var list_item = InkListItem.from_serialized_key(key)
		if list_item.item_name == list_item_name:
			return true

	return false


func greater_than(other_list: InkList) -> bool:
	if size() == 0:
		return false
	if other_list.size() == 0:
		return true

	return self.min_item.value > other_list.max_item.value


func greater_than_or_equals(other_list: InkList) -> bool:
	if size() == 0:
		return false
	if other_list.size() == 0:
		return true

	return (
			self.min_item.value >= other_list.min_item.value &&
			self.max_item.value >= other_list.max_item.value
	)


func less_than(other_list: InkList) -> bool:
	if other_list.size() == 0:
		return false
	if size() == 0:
		return true

	return self.max_item.value < other_list.min_item.value


func less_than_or_equals(other_list: InkList) -> bool:
	if other_list.size() == 0:
		return false
	if size() == 0:
		return true

	return (
			self.max_item.value <= other_list.max_item.value &&
			self.min_item.value <= other_list.min_item.value
	)


func max_as_list() -> InkList:
	if size() > 0:
		var _max_item: InkKeyValuePair = self.max_item
		return InkList.new_with_single_item(_max_item.key, _max_item.value)
	else:
		return InkList.new()


func min_as_list() -> InkList:
	if size() > 0:
		var _min_item: InkKeyValuePair = self.min_item
		return InkList.new_with_single_item(_min_item.key, _min_item.value)
	else:
		return InkList.new()


# (Variant, Variant) -> InkList
func list_with_sub_range(min_bound, max_bound) -> InkList:
	if size() == 0:
		return InkList.new()

	var ordered: Array = self.ordered_items

	var min_value: int = 0
	var max_value: int = 9_223_372_036_854_775_807 # MAX_INT

	if min_bound is int:
		min_value = min_bound
	else:
		if min_bound.is_ink_class("InkList") && min_bound.size() > 0:
			min_value = min_bound.min_item.value

	if max_bound is int:
		max_value = max_bound
	else:
		if min_bound.is_ink_class("InkList") && min_bound.size() > 0:
			max_value = max_bound.max_item.value

	var sub_list = InkList.new()
	sub_list.set_initial_origin_names(self.origin_names)

	for item in ordered:
		if item.value >= min_value && item.value <= max_value:
			sub_list.set_item(item.key, item.value)

	return sub_list


func equals(other: InkBase) -> bool:
	var other_raw_list: InkList = other
	# Simple test to make sure the object is of the right type.
	if !(other_raw_list is Object):
		return false
	if !(other_raw_list.is_ink_class("InkList")):
		return false

	if other_raw_list.size() != self.size():
		return false

	for key in keys():
		if (!other_raw_list.has_item(key)):
			return false

	return true


var ordered_items: Array: # Array<InkKeyValuePair<InkListItem, int>>
	get:
		var ordered: Array = []
		for key in keys():
			ordered.append(InkKeyValuePair.new_with_key_value(key, get_item(key)))

		ordered.sort_custom(Callable(KeyValueInkListItemSorter, "sort"))
		return ordered


func _to_string() -> String:
	var ordered: Array = self.ordered_items

	var description: String = ""
	var i: int = 0
	while (i < ordered.size()):
		if i > 0:
			description += ", "

		var item = ordered[i].key
		description += item.item_name
		i += 1

	return description


static func new_with_dictionary(other_dictionary: Dictionary) -> InkList:
	var ink_list: InkList = InkList.new()
	ink_list._init_with_dictionary(other_dictionary)
	return ink_list


static func new_with_ink_list(other_list: InkList) -> InkList:
	var ink_list: InkList = InkList.new()
	ink_list._init_with_ink_list(other_list)
	return ink_list


static func new_with_origin(single_origin_list_name: String, origin_story) -> InkList:
	var ink_list: InkList = InkList.new()
	ink_list._init_with_origin(single_origin_list_name, origin_story)
	return ink_list


static func new_with_single_item(single_item: InkListItem, single_value: int) -> InkList:
	var ink_list: InkList = InkList.new()
	ink_list._init_with_single_item(single_item, single_value)
	return ink_list


class KeyValueInkListItemSorter:
	static func sort(a, b):
		if a.value == b.value:
			return a.key.origin_name.nocasecmp_to(b.key.origin_name) <= 0
		else:
			return a.value <= b.value


# ############################################################################ #
# Originally, this class would inherit Dictionary. This isn't possible in
# GDScript. Instead, this class will encapsulate a dictionary and forward
# needed calls.
# ############################################################################ #

var _dictionary: Dictionary = {}


# Name set_item instead of set to prevent shadowing 'Object.set'.
func set_item(key: InkListItem, value: int) -> void:
	_dictionary[key.serialized()] = value


# Name get_item instead of get to prevent shadowing 'Object.get'.
func get_item(key: InkListItem, default = null):
	return _dictionary.get(key.serialized(), default)


# Name has_item instead of has to prevent shadowing 'Object.get'.
func has_item(key: InkListItem) -> bool:
	return _dictionary.has(key.serialized())


func keys() -> Array:
	var deserialized_keys = []
	for key in _dictionary.keys():
		deserialized_keys.append(InkListItem.from_serialized_key(key))

	return deserialized_keys


func size() -> int:
	return _dictionary.size()


# ############################################################################ #
# Additional methods
# ############################################################################ #

func set_raw(key: String, value: int) -> void:
	if OS.is_debug_build() && !(key is String):
		print("Warning: Expected serialized key in InkList.set_raw().")

	_dictionary[key] = value


func erase_raw(key: String) -> bool:
	if OS.is_debug_build() && !(key is String):
		print("Warning: Expected serialized key in InkList.erase_raw().")

	return _dictionary.erase(key)


func get_raw(key: String, default = null):
	if OS.is_debug_build() && !(key is String):
		print("Warning: Expected serialized key in InkList.get_raw().")

	return _dictionary.get(key, default)


func has_raw(key: String) -> bool:
	if OS.is_debug_build() && !(key is String):
		print("Warning: Expected serialized key in InkList.has_raw().")

	return _dictionary.has(key)


func has_all_raw(keys: Array) -> bool:
	return _dictionary.has_all(keys)


func raw_keys() -> Array:
	return _dictionary.keys()


# ############################################################################ #
# GDScript extra methods
# ############################################################################ #

func is_ink_class(type: String) -> bool:
	return type == "InkList" || super.is_ink_class(type)


func get_ink_class() -> String:
	return "InkList"