#include "LocationState.h"

namespace FRG {

void LocationState::save(nlohmann::json& out) const
{
    out["cameraAzimuth"]     = cameraAzimuth;
    out["cameraInclination"] = cameraInclination;

    out["activeNavigationIndex"] = activeNavigationIndex;

    out["targetInteractiveObjectIndex"] = targetInteractiveObjectIndex;
    out["targetInteractNpcIndex"]       = targetInteractNpcIndex;
    out["targetTeleportZoneIndex"]      = targetTeleportZoneIndex;

    out["isDarklands"] = isDarklands;
    out["isNight"]     = isNight;
    out["isDawn"]      = isDawn;

    out["tutorialInteractiveObjectsLocked"] = tutorialInteractiveObjectsLocked;


	// Taxi stuff:
    nlohmann::json taxiJson;

	taxiJson["taxiCar"] = {
		{"positionX", taxiCar.position.x()},
		{"positionY", taxiCar.position.y()},
		{"positionZ", taxiCar.position.z()},
		{"rotation", taxiCar.rotation},
		{"velocity", taxiCar.velocity},
		{"steeringAngle", taxiCar.steeringAngle},
		{"mode", static_cast<int>(taxiCar.mode)},
		{"waypoints", nlohmann::json::array()},
		{"currentWaypoint", taxiCar.currentWaypoint},
		{"waypointReachRadius", taxiCar.waypointReachRadius}
	};

    nlohmann::json taxiWaypoints = nlohmann::json::array();

	for (int i = 0; i < taxiCar.waypoints.size(); ++i) {
		taxiWaypoints.push_back({
			{"x", taxiCar.waypoints[i].x()},
			{"y", taxiCar.waypoints[i].y()},
			{"z", taxiCar.waypoints[i].z()}
			});
	}

    taxiJson["taxiCar"]["waypoints"] = std::move(taxiWaypoints);

    taxiJson["taxiCarInitialState"] = {
		{"positionX", taxiCarInitialState.position.x()},
		{"positionY", taxiCarInitialState.position.y()},
		{"positionZ", taxiCarInitialState.position.z()},
		{"rotation", taxiCarInitialState.rotation},
		{"velocity", taxiCarInitialState.velocity},
		{"steeringAngle", taxiCarInitialState.steeringAngle},
		{"mode", static_cast<int>(taxiCarInitialState.mode)},
		{"waypoints", nlohmann::json::array()},
		{"currentWaypoint", taxiCarInitialState.currentWaypoint},
		{"waypointReachRadius", taxiCarInitialState.waypointReachRadius}
	};

	nlohmann::json taxiInitialWaypoints = nlohmann::json::array();

	for (int i = 0; i < taxiCarInitialState.waypoints.size(); ++i) {
		taxiInitialWaypoints.push_back({
			{"x", taxiCarInitialState.waypoints[i].x()},
			{"y", taxiCarInitialState.waypoints[i].y()},
			{"z", taxiCarInitialState.waypoints[i].z()}
			});
	}

	taxiJson["taxiCarInitialState"]["waypoints"] = std::move(taxiInitialWaypoints);

	nlohmann::json taxiDefaultWaypoints = nlohmann::json::array();

	for (int i = 0; i < taxiCarWaypoints.size(); ++i) {
		taxiDefaultWaypoints.push_back({
			{"x", taxiCarWaypoints[i].x()},
			{"y", taxiCarWaypoints[i].y()},
			{"z", taxiCarWaypoints[i].z()}
			});
	}

	taxiJson["taxiDefaultWaypoints"] = taxiDefaultWaypoints;

	/*	taxiCarTriggerPosition = Eigen::Vector3f(
		taxiJson.value("taxiCarTriggerPositionX", 0.f),
		taxiJson.value("taxiCarTriggerPositionY", 0.f),
		taxiJson.value("taxiCarTriggerPositionZ", 0.f)
	);*/

	taxiJson["taxiCarTriggerPositionX"] = taxiCarTriggerPosition.x();
	taxiJson["taxiCarTriggerPositionY"] = taxiCarTriggerPosition.y();
	taxiJson["taxiCarTriggerPositionZ"] = taxiCarTriggerPosition.z();

	//	{"y", taxiCarTriggerPosition.y()},
	//	{"z", taxiCarTriggerPosition.z()}
	//};

	taxiJson["taxiArrivedCallbackCalled"] = taxiArrivedCallbackCalled;
	
	//questJournal.save(questJson);
    out["taxi"] = std::move(taxiJson);
}

void LocationState::load(const nlohmann::json& in)
{
	//logger() << "LocationState::load step 1" << std::endl;

    cameraAzimuth     = in.value("cameraAzimuth",     cameraAzimuth);
    cameraInclination = in.value("cameraInclination", cameraInclination);

    activeNavigationIndex = in.value("activeNavigationIndex", activeNavigationIndex);

    targetInteractiveObjectIndex = in.value("targetInteractiveObjectIndex", -1);
    targetInteractNpcIndex       = in.value("targetInteractNpcIndex",       -1);
    targetTeleportZoneIndex      = in.value("targetTeleportZoneIndex",      -1);

    isDarklands = in.value("isDarklands", false);
    isNight     = in.value("isNight",     false);
    isDawn      = in.value("isDawn",      false);

    tutorialInteractiveObjectsLocked = in.value("tutorialInteractiveObjectsLocked", false);

	//logger() << "LocationState::load step 2" << std::endl;

	nlohmann::json taxiJson = in["taxi"];

	taxiArrivedCallbackCalled = taxiJson.value("taxiArrivedCallbackCalled", false);

	//----- Taxi State ----
	
	nlohmann::json taxiCarJson = taxiJson["taxiCar"];

	taxiCar.position = Eigen::Vector3f(
		taxiCarJson.value("positionX", 0.f),
		taxiCarJson.value("positionY", 0.f),
		taxiCarJson.value("positionZ", 0.f)
	);

	//logger() << "LocationState::load step 3" << std::endl;

	taxiCar.rotation = taxiCarJson.value("rotation", 0.f);

	taxiCar.velocity = taxiCarJson.value("velocity", 0.f);

	taxiCar.steeringAngle = taxiCarJson.value("steeringAngle", 0.f);

	taxiCar.mode = static_cast<NpcCar::Mode>(taxiCarJson.value("mode", 0));

	//logger() << "LocationState::load step 4" << std::endl;

	taxiCar.waypoints.clear();
	if (taxiCarJson.contains("waypoints") && taxiCarJson["waypoints"].is_array()) {
		for (int i = 0; i < static_cast<int>(taxiCarJson["waypoints"].size()); ++i)
			taxiCar.waypoints.push_back(Eigen::Vector3f(
				taxiCarJson["waypoints"][i].value("x", 0.f),
				taxiCarJson["waypoints"][i].value("y", 0.f),
				taxiCarJson["waypoints"][i].value("z", 0.f)
			));
	}

	//logger() << "LocationState::load step 5" << std::endl;

	taxiCar.currentWaypoint = taxiCarJson.value("currentWaypoint", 0);
	taxiCar.waypointReachRadius = taxiCarJson.value("waypointReachRadius", 3.f);
	taxiCar.wheelAngle = taxiCarJson.value("wheelAngle", 0.f);


	//--------- Taxi initial state -----

	//logger() << "LocationState::load step 6" << std::endl;

	nlohmann::json taxiCarInitialStateJson = taxiJson["taxiCarInitialState"];

	taxiCarInitialState.position = Eigen::Vector3f(
		taxiCarInitialStateJson.value("positionX", 0.f),
		taxiCarInitialStateJson.value("positionY", 0.f),
		taxiCarInitialStateJson.value("positionZ", 0.f)
	);

	taxiCarInitialState.rotation = taxiCarInitialStateJson.value("rotation", 0.f);

	taxiCarInitialState.velocity = taxiCarInitialStateJson.value("velocity", 0.f);

	taxiCarInitialState.steeringAngle = taxiCarInitialStateJson.value("steeringAngle", 0.f);

	taxiCarInitialState.mode = static_cast<NpcCar::Mode>(taxiCarInitialStateJson.value("mode", 0));

	//logger() << "LocationState::load step 7" << std::endl;


	taxiCarInitialState.waypoints.clear();
	if (taxiCarInitialStateJson.contains("waypoints") && taxiCarInitialStateJson["waypoints"].is_array()) {
		for (int i = 0; i < static_cast<int>(taxiCarInitialStateJson["waypoints"].size()); ++i)
			taxiCarInitialState.waypoints.push_back(Eigen::Vector3f(
				taxiCarInitialStateJson["waypoints"][i].value("x", 0.f),
				taxiCarInitialStateJson["waypoints"][i].value("y", 0.f),
				taxiCarInitialStateJson["waypoints"][i].value("z", 0.f)
			));
	}

	//logger() << "LocationState::load step 8" << std::endl;

	taxiCarInitialState.currentWaypoint = taxiCarInitialStateJson.value("currentWaypoint", 0);
	taxiCarInitialState.waypointReachRadius = taxiCarInitialStateJson.value("waypointReachRadius", 3.f);
	taxiCarInitialState.wheelAngle = taxiCarInitialStateJson.value("wheelAngle", 0.f);

	

	taxiCarWaypoints.clear();
	if (taxiJson.contains("taxiDefaultWaypoints") && taxiJson["taxiDefaultWaypoints"].is_array()) {
		for (int i = 0; i < static_cast<int>(taxiJson["taxiDefaultWaypoints"].size()); ++i)
			taxiCarWaypoints.push_back(Eigen::Vector3f(
				taxiJson["taxiDefaultWaypoints"][i].value("x", 0.f),
				taxiJson["taxiDefaultWaypoints"][i].value("y", 0.f),
				taxiJson["taxiDefaultWaypoints"][i].value("z", 0.f)
			));
	}

	//logger() << "LocationState::load step 9" << std::endl;

	taxiCarTriggerPosition = Eigen::Vector3f(
		taxiJson.value("taxiCarTriggerPositionX", 0.f),
		taxiJson.value("taxiCarTriggerPositionY", 0.f),
		taxiJson.value("taxiCarTriggerPositionZ", 0.f)
	);

	//logger() << "LocationState::load step 10" << std::endl;


}

} // namespace FRG