using Godot;
using System.Collections.Generic;
using System.Text.Json;

public partial class ResourceLoader
{
	private const string LayerPrefabPath = "res://Prefabs/Layer.tscn";
	private const string RobotPrefabPath = "res://Prefabs/Robot/Robot.tscn";
	private const string RobotDisplayPath = "res://Prefabs/Robot/RobotDisplay.tscn";
	private const string ItemDisplayPath = "res://Prefabs/Crafting/ItemDisplay.tscn";
	private const string RecipesPath = "res://Assets/Recipes.json";
	private const string ResearchPath = "res://Assets/Research.json";

	public static PackedScene LoadLayerPrefab()
	{
		return GD.Load<PackedScene>(LayerPrefabPath);
	}

	public static PackedScene LoadRobotPrefab()
	{
		return GD.Load<PackedScene>(RobotPrefabPath);
	}

	public static PackedScene LoadRobotDisplay()
	{
		return GD.Load<PackedScene>(RobotDisplayPath);
	}

	public static PackedScene LoadItemDisplay()
	{
		return GD.Load<PackedScene>(ItemDisplayPath);
	}

	public static Texture2D LoadPath(string path)
	{
		return GD.Load<Texture2D>(path);
	}

	public static Dictionary<string, MeshInstance3D> LoadTiles()
	{
		Dictionary<string, MeshInstance3D> tileMeshes = new Dictionary<string, MeshInstance3D>();
		PackedScene tileCollection = GD.Load<PackedScene>($"res://Assets/Objects/Tiles.glb");
		Node root = tileCollection.Instantiate();
		foreach (MeshInstance3D child in root.GetChildren())
		{
			tileMeshes.Add(child.Name.ToString().ToLower(), child);
		}

		return tileMeshes;
	}

	public static Dictionary<string, MeshInstance3D> LoadDecorations()
	{
		Dictionary<string, MeshInstance3D> decorationMeshes = new Dictionary<string, MeshInstance3D>();
		PackedScene decorationCollection = GD.Load<PackedScene>($"res://Assets/Objects/Decorations.glb");
		Node root = decorationCollection.Instantiate();
		foreach (MeshInstance3D child in root.GetChildren())
		{
			decorationMeshes.Add(child.Name.ToString().ToLower(), child);
		}

		return decorationMeshes;
	}

	public static Dictionary<ProgramNode, PackedScene> LoadDSLNodes()
	{
		Dictionary<ProgramNode, PackedScene> nodes = new Dictionary<ProgramNode, PackedScene>()
		{
			{ new MoveNode(), GD.Load<PackedScene>("res://Prefabs/DSL/MoveNode.tscn") },
			{ new HarvestNode(), GD.Load<PackedScene>("res://Prefabs/DSL/HarvestNode.tscn") },
			{ new CraftNode(), GD.Load<PackedScene>("res://Prefabs/DSL/CraftNode.tscn") },
			{ new ExploreNode(), GD.Load<PackedScene>("res://Prefabs/DSL/ExploreNode.tscn") }
		};
		return nodes;
	}

	public static Dictionary<string, Texture2D> LoadResourceSymbols()
	{
		Dictionary<string, Texture2D> symbols = new Dictionary<string, Texture2D>()
		{
			{ "iron_ore", GD.Load<Texture2D>("res://Assets/Images/Resources/IronSymbol.png") },
			{ "tin_ore", GD.Load<Texture2D>("res://Assets/Images/Resources/TinSymbol.png") },
			{ "copper_ore", GD.Load<Texture2D>("res://Assets/Images/Resources/CopperSymbol.png") },
			{ "mushroom", GD.Load<Texture2D>("res://Assets/Images/Resources/MushroomSymbol.png") },
			{ "spider_silk", GD.Load<Texture2D>("res://Assets/Images/Resources/SpiderSilkSymbol.png") },
			{ "coal", GD.Load<Texture2D>("res://Assets/Images/Resources/CoalSymbol.png") },
			{ "water", GD.Load<Texture2D>("res://Assets/Images/Resources/WaterSymbol.png") },
			{ "stone", GD.Load<Texture2D>("res://Assets/Images/Resources/StoneSymbol.png") },
		};
		return symbols;
	}

	public static Dictionary<string, float[]> LoadResourceWeights()
	{
		Dictionary<string, float[]> weights = new Dictionary<string, float[]>()
		{
			{ "iron_ore", [0.05f,1] },
			{ "tin_ore", [0.3f,0.7f] },
			{ "copper_ore", [0.3f,0.7f] },
			{ "mushroom", [0.3f,0.1f] },
			{ "spider_silk", [0.8f,0.4f] },
			{ "coal", [1,0.3f] },
			{ "water", [0.4f,0.2f] },
			{ "stone", [1,0.5f] },
		};
		return weights;
	}

	public static SortedDictionary<string, ItemData> LoadItems()
	{

		FileAccess file = FileAccess.Open(RecipesPath, FileAccess.ModeFlags.Read);
		string json = file.GetAsText();

		SortedDictionary<string, ItemData> result = new SortedDictionary<string, ItemData>();

		List<ItemData> items = JsonSerializer.Deserialize<List<ItemData>>(json);
		if (items == null) return result;

		foreach (ItemData item in items)
		{
			result.Add(item.Id, item);
		}

		return result;
	}

	public static Dictionary<string, Research> LoadResearch()
	{

		FileAccess file = FileAccess.Open(ResearchPath, FileAccess.ModeFlags.Read);
		string json = file.GetAsText();

		Dictionary<string, Research> result = new Dictionary<string, Research>();

		List<ResearchData> researches = JsonSerializer.Deserialize<List<ResearchData>>(json);
		if (researches == null) return result;

		foreach (ResearchData research in researches)
		{
			result.Add(research.Id, new Research(research));
		}

		return result;
	}
}
