miggor-StreamGraph/classes/deck/node_db.gd

extends Node

const BASE_NODE_PATH := "res://classes/deck/nodes/"
const NODE_INDEX_CACHE_PATH := "user://nodes_index.json"
const FAVORITE_NODES_PATH := "user://favorite_nodes.json"

var favorite_nodes: Array[String]

# Dictionary[node_type, NodeDescriptor]
var nodes: Dictionary = {}


func _init() -> void:
	load_favorites()
	#if load_node_index():
		#return

	var dir := DirAccess.open(BASE_NODE_PATH)
	dir.list_dir_begin()
	var current_file := dir.get_next()
	while current_file != "":
		print(current_file)
		if current_file.ends_with(".gd"):
			var script_path := BASE_NODE_PATH.path_join(current_file)
			var node: DeckNode = load(script_path).new() as DeckNode
			var aliases: String = node.aliases.reduce(
				func(accum, el) -> void:
					accum += el
			, "")
			var descriptor := NodeDescriptor.new(
				script_path,
				node.name,
				node.node_type,
				node.description,
				aliases,
				node.category,
				node.appears_in_search,
				)
			nodes[node.node_type] = descriptor
		current_file = dir.get_next()

	save_node_index()


func instance_node(type: String) -> DeckNode:
	if !nodes.has(type):
		return null

	return load(nodes[type]["script_path"]).new()


func save_node_index() -> void:
	var d := {}
	for node_type in nodes:
		var nd: NodeDescriptor = nodes[node_type] as NodeDescriptor
		d[node_type] = nd.to_dictionary()

	var json := JSON.stringify(d, "\t")
	var f := FileAccess.open(NODE_INDEX_CACHE_PATH, FileAccess.WRITE)
	f.store_string(json)


func load_node_index() -> bool:
	var f := FileAccess.open(NODE_INDEX_CACHE_PATH, FileAccess.READ)
	if f == null:
		print("node index file does not exist")
		return false

	var data: Dictionary = JSON.parse_string(f.get_as_text()) as Dictionary
	if data.is_empty():
		print("node index file exists, but is empty")
		return false

	for node_type in data:
		var nd_dict: Dictionary = data[node_type]
		var nd := NodeDescriptor.from_dictionary(nd_dict)
		nodes[node_type] = nd

	print("node index file exists, loaded")
	return true


func set_node_favorite(node_type: String, favorite: bool) -> void:
	if (favorite && node_type in favorite_nodes) || (!favorite && !(node_type in favorite_nodes)):
		return

	if favorite:
		favorite_nodes.append(node_type)
	else:
		favorite_nodes.erase(node_type)

	var f := FileAccess.open(FAVORITE_NODES_PATH, FileAccess.WRITE)
	f.store_string(JSON.stringify(favorite_nodes, "\t"))


func load_favorites() -> void:
	var f := FileAccess.open(FAVORITE_NODES_PATH, FileAccess.READ)
	if !f:
		return
	var data: Array = JSON.parse_string(f.get_as_text())
	favorite_nodes.clear()
	favorite_nodes.assign(data)


func is_node_favorite(node_type: String) -> bool:
	return node_type in favorite_nodes


class NodeDescriptor:
	var name: String
	var type: String
	var description: String
	var aliases: String
	var category: String
	var appears_in_search: bool

	var script_path: String


	func _init(
			p_script_path: String,
			p_name: String,
			p_type: String,
			p_description: String,
			p_aliases: String,
			p_category: String,
			p_appears_in_search: bool,
		) -> void:
			script_path = p_script_path

			name = p_name
			type = p_type
			description = p_description
			aliases = p_aliases
			category = p_category
			appears_in_search = p_appears_in_search


	func to_dictionary() -> Dictionary:
		var d := {
			"name": name,
			"type": type,
			"description": description,
			"aliases": aliases,
			"script_path": script_path,
			"category": category,
			"appears_in_search": appears_in_search,
		}
		return d


	static func from_dictionary(data: Dictionary) -> NodeDescriptor:
		var nd := NodeDescriptor.new(
			data.get("script_path", ""),
			data.get("name", ""),
			data.get("type", ""),
			data.get("description", ""),
			data.get("aliases", ""),
			data.get("category", ""),
			data.get("appears_in_search", false),
			)

		return nd