//billboards, projections, and progress bar

#include "MapItemSingleton.hpp"
#include <string_view>

//#include <numbers>

#include <godot_cpp/variant/utility_functions.hpp>

#include <openvic-simulation/map/ProvinceInstance.hpp>

#include "openvic-extension/singletons/GameSingleton.hpp"
#include "openvic-extension/utility/ClassBindings.hpp"
#include "openvic-extension/utility/Utilities.hpp"
#include "godot_cpp/variant/packed_vector2_array.hpp"
#include "godot_cpp/variant/typed_array.hpp"
#include "godot_cpp/variant/vector2.hpp"
#include "openvic-simulation/interface/GFXObject.hpp"
#include "openvic-simulation/utility/Logger.hpp"

using namespace godot;
using namespace OpenVic;

void MapItemSingleton::_bind_methods() {
	/*OV_BIND_METHOD(MapItemSingleton::get_units);
	OV_BIND_METHOD(MapItemSingleton::get_cultural_gun_model, { "culture" });
	OV_BIND_METHOD(MapItemSingleton::get_cultural_helmet_model, { "culture" });
	OV_BIND_METHOD(MapItemSingleton::get_flag_model, { "floating" });
	OV_BIND_METHOD(MapItemSingleton::get_buildings);*/
	//OV_BIND_METHOD(MapItemSingleton::get_billboard, {"name"});
	OV_BIND_METHOD(MapItemSingleton::get_billboards);
	OV_BIND_METHOD(MapItemSingleton::get_province_positions);

}

MapItemSingleton* MapItemSingleton::get_singleton() {
	return singleton;
}

MapItemSingleton::MapItemSingleton() {
	ERR_FAIL_COND(singleton != nullptr);
	singleton = this;
}

MapItemSingleton::~MapItemSingleton() {
	ERR_FAIL_COND(singleton != this);
	singleton = nullptr;
}

// Get the billboard object from the loaded objects

GFX::Billboard const* MapItemSingleton::get_billboard(std::string_view name, bool error_on_fail) const {
	GameSingleton const* game_singleton = GameSingleton::get_singleton();
	ERR_FAIL_NULL_V(game_singleton, nullptr);

	GFX::Billboard const* billboard =
		game_singleton->get_definition_manager().get_ui_manager().get_cast_object_by_identifier<GFX::Billboard>(name);

	if (error_on_fail) {
		//ERR_FAIL_NULL_V_MSG(billboard, nullptr, vformat("Failed to find billboard \"%s\"", Utilities::std_to_godot_string(name)));
		ERR_FAIL_NULL_V_MSG(billboard, nullptr, "Failed to find billboard inner");
	}

	return billboard;
}

// repackage the billboard object into a godot dictionnary for the Billboard manager to work with
bool MapItemSingleton::add_billboard_dict(std::string_view name, TypedArray<Dictionary>& billboard_dict_array) {

	static const StringName name_key = "name";
	static const StringName texture_key = "texture";
	static const StringName scale_key = "scale";
	static const StringName noOfFrames_key = "noFrames";
	//TODO: might need font, font_size, and offset keys in the future


	GFX::Billboard const* billboard = get_billboard(name,false);
	/*ERR_FAIL_NULL_V_MSG(
		billboard, false, vformat(
			"Failed to find \"%s\" billboard", Utilities::std_to_godot_string(name)
		)
	);*/
	ERR_FAIL_NULL_V_MSG(
		billboard, false, "Failed to find billboard"
	);

	Dictionary dict;

	dict[name_key] = Utilities::std_to_godot_string(billboard->get_name());
	dict[texture_key] = Utilities::std_to_godot_string(billboard->get_texture_file());
	dict[scale_key] = billboard->get_scale().to_float();
	dict[noOfFrames_key] = billboard->get_no_of_frames();

	billboard_dict_array.push_back(dict);

	return true;
}


//get an array of all the billboard dictionnaries
TypedArray<Dictionary> MapItemSingleton::get_billboards(){
	GameSingleton const* game_singleton = GameSingleton::get_singleton();
	ERR_FAIL_NULL_V(game_singleton, {});
	//InstanceManager const* instance_manager = game_singleton->get_instance_manager();
	//ERR_FAIL_NULL_V(instance_manager, {});

	TypedArray<Dictionary> ret;

	std::vector<std::string_view> identifiers = 
		game_singleton->get_definition_manager().get_ui_manager().get_object_identifiers();

	for(auto i : identifiers){
		GFX::Object const* obj = game_singleton->get_definition_manager().get_ui_manager().get_object_by_identifier(i);
		if(obj->is_type<GFX::Billboard>()){
			add_billboard_dict(obj->get_name(),ret);
		}
	}
	
	return ret;
}

PackedVector2Array MapItemSingleton::get_province_positions(){
	GameSingleton const* game_singleton = GameSingleton::get_singleton();
	ERR_FAIL_NULL_V(game_singleton, {});

	/*std::vector<std::string_view> prov_identifiers =
	 game_singleton->get_definition_manager().get_map_definition().
	 get_province_definition_identifiers();
	*/

	PackedVector2Array billboard_pos = PackedVector2Array();

	int prov_count = game_singleton->get_definition_manager().get_map_definition().get_province_definition_count();
	Logger::info("prov_count ", prov_count);
	
	for(int i = 0; i < prov_count; i++){
		ProvinceDefinition const* prov = game_singleton->get_definition_manager().get_map_definition().get_province_definition_by_index(i);
		billboard_pos.push_back(Vector2(prov->get_city_position().x,prov->get_city_position().y));
		if(i % 4){
			Logger::info("prov_x ", prov->get_city_position().x);
		}
	}

	return billboard_pos;
}