#include "scene/node.h"
#include "compat/misc.h"
#include "threads.h"
#include "main/references.h"
#include "main/logging.h"
#include "render/driver.h"
#include "obj/object.h"
#include "empire.h"
#include "physics/physics_world.h"
#include "aabbox.h"
#include "memory/AllocOnlyPool.h"

#include <map>
#include <set>

extern double frameTime_s;
extern unsigned frameNumber;
Colorf fallbackNodeColor;
Object* fallbackNodeObject;

//Produce a vaguely unique value per node, consistent per node
void shader_unique(float* values,unsigned short,void*) {
	if(auto* node = scene::renderingNode)
		values[0] = (float)(((node - (scene::Node*)0) >> 4) & 0xff) / 255.f;
	else
		values[0] = 0.5f;
}

void shader_node_color(float* colors,unsigned short,void*) {
	if(auto* node = scene::renderingNode)
		*(Colorf*)colors = node->color;
	else
		*(Colorf*)colors = fallbackNodeColor;
}

void shader_node_distance(float* distance,unsigned short,void*) {
	if(auto* node = scene::renderingNode)
		*distance = (float)node->sortDistance;
	else
		*distance = 0.f;
}

void shader_node_scale(float* scale,unsigned short,void*) {
	if(auto* node = scene::renderingNode)
		*scale = (float)node->abs_scale;
	else
		*scale = 1.f;
}

void shader_node_selected(float* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		Object* obj = node->obj;
		if(obj && obj->getFlag(objSelected))
			*(float*)value = 1.f;
		else
			*(float*)value = 0.f;
	}
	else
		*(float*)value = 0.f;
}

void shader_obj_velocity(float* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		Object* obj = node->obj;
		if(obj)
			*(float*)value = (obj->velocity + obj->acceleration * (frameTime_s - obj->lastTick)).getLength();
		else
			*(float*)value = 0.f;
	}
	else if(fallbackNodeObject) {
		*(float*)value = (fallbackNodeObject->velocity + fallbackNodeObject->acceleration * (frameTime_s - fallbackNodeObject->lastTick)).getLength();
	}
	else
		*(float*)value = 0.f;
}

void shader_obj_position(float* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		Object* obj = node->obj;
		if(obj) {
			value[0] = obj->position.x;
			value[1] = obj->position.y;
			value[2] = obj->position.z;
		}
		else {
			value[0] = 0.f;
			value[1] = 0.f;
			value[2] = 0.f;
		}
	}
	else if(fallbackNodeObject) {
		value[0] = fallbackNodeObject->position.x;
		value[1] = fallbackNodeObject->position.y;
		value[2] = fallbackNodeObject->position.z;
	}
	else {
		value[0] = 0.f;
		value[1] = 0.f;
		value[2] = 0.f;
	}
}

void shader_obj_rotation(float* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		Object* obj = node->obj;
		if(obj) {
			value[0] = obj->rotation.xyz.x;
			value[1] = obj->rotation.xyz.y;
			value[2] = obj->rotation.xyz.z;
			value[3] = obj->rotation.w;
		}
		else {
			value[0] = 0.f;
			value[1] = 0.f;
			value[2] = 0.f;
			value[3] = 1.f;
		}
	}
	else if(fallbackNodeObject) {
		value[0] = fallbackNodeObject->rotation.xyz.x;
		value[1] = fallbackNodeObject->rotation.xyz.y;
		value[2] = fallbackNodeObject->rotation.xyz.z;
		value[3] = fallbackNodeObject->rotation.w;
	}
	else {
		value[0] = 0.f;
		value[1] = 0.f;
		value[2] = 0.f;
		value[3] = 1.f;
	}
}

void shader_node_position(float* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		value[0] = node->abs_position.x;
		value[1] = node->abs_position.y;
		value[2] = node->abs_position.z;
	}
	else if(fallbackNodeObject) {
		value[0] = fallbackNodeObject->position.x;
		value[1] = fallbackNodeObject->position.y;
		value[2] = fallbackNodeObject->position.z;
	}
	else {
		value[0] = 0.f;
		value[1] = 0.f;
		value[2] = 0.f;
	}
}

void shader_node_rotation(float* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		value[0] = node->abs_rotation.xyz.x;
		value[1] = node->abs_rotation.xyz.y;
		value[2] = node->abs_rotation.xyz.z;
		value[3] = node->abs_rotation.w;
	}
	else if(fallbackNodeObject) {
		value[0] = fallbackNodeObject->rotation.xyz.x;
		value[1] = fallbackNodeObject->rotation.xyz.y;
		value[2] = fallbackNodeObject->rotation.xyz.z;
		value[3] = fallbackNodeObject->rotation.w;
	}
	else {
		value[0] = 0.f;
		value[1] = 0.f;
		value[2] = 0.f;
		value[3] = 1.f;
	}
}

void shader_obj_acceleration(float* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		Object* obj = node->obj;
		if(obj)
			*(float*)value = obj->acceleration.getLength();
		else
			*(float*)value = 0.f;
	}
	else if(fallbackNodeObject) {
		*(float*)value = fallbackNodeObject->acceleration.getLength();
	}
	else
		*(float*)value = 0.f;
}

void shader_emp_flag(int* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		Object* obj = node->obj;
		if(obj) {
			Empire* owner = obj->owner;
			if(owner)
				*(int*)value = (int)owner->flagID;
			else
				*(int*)value = 0;
		}
		else {
			*(int*)value = 0;
		}
	}
	else if(fallbackNodeObject) {
		Empire* owner = fallbackNodeObject->owner;
		if(owner)
			*(int*)value = (int)owner->flagID;
		else
			*(int*)value = 0;
	}
	else
		*(int*)value = 0;
}

void shader_obj_id(int* value,unsigned short,void*) {
	if(auto* node = scene::renderingNode) {
		Object* obj = node->obj;
		if(obj)
			*(int*)value = obj->id;
		else
			*(int*)value = 0;
	}
	else if(fallbackNodeObject) {
		*(int*)value = fallbackNodeObject->id;
	}
	else
		*(int*)value = 0;
}

namespace scene {

const char* typeNames[NT_ScriptBase] = {
	"Misc Node",
	"Culling Node",
	"Particle System",
	"Mesh Node",
	"Mesh+Icon Node"
};
extern const char* getScriptNodeName(unsigned id);

#ifdef PROFILE_ANIMATION
volatile double nodeAnimTimes[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
threads::atomic_int nodeAnimCounts[32];

void dumpAnimationProfile() {
	for(unsigned i = 0; i < 32; ++i) {
		int count = nodeAnimCounts[i];
		double total = nodeAnimTimes[i];
		if(count == 0)
			continue;
		nodeAnimTimes[i] = 0;
		nodeAnimCounts[i] = 0;

		const char* name = nullptr;
		if(i < NT_ScriptBase)
			name = typeNames[i];
		else
			name = getScriptNodeName(i - NT_ScriptBase);
		print("%s: %.1lf ms (%.1lf us per)", name, total * 1.0e3, total * 1.0e6 / double(count));
	}
}
#endif

const char* Node::getName() const {
	unsigned typeIndex = (unsigned)getType();
	if(typeIndex < NT_ScriptBase)
		return typeNames[typeIndex];
	else
		return getScriptNodeName(typeIndex - NT_ScriptBase);
}

Node* renderingNode;

threads::Mutex nodeEventLock;
std::vector<NodeEvent*>* pushQueue = new std::vector<NodeEvent*>, *activeQueue = new std::vector<NodeEvent*>;
memory::AllocOnlyRegion<threads::Mutex> nodeEventMemory(2048);

void* NodeEvent::operator new(size_t bytes) {
	return nodeEventMemory.alloc(bytes);
}

void NodeEvent::operator delete(void* p) {
	nodeEventMemory.dealloc((unsigned char*)p);
}

void queueNodeEvent(NodeEvent* evt) {
	nodeEventLock.lock();
	pushQueue->push_back(evt);
	nodeEventLock.release();
}

void clearNodeEvents() {
	nodeEventLock.lock();

	for(auto i = activeQueue->begin(), end = activeQueue->end(); i != end; ++i)
		delete *i;
	for(auto i = pushQueue->begin(), end = pushQueue->end(); i != end; ++i)
		delete *i;
	
	activeQueue->clear();
	pushQueue->clear();

	nodeEventLock.release();
}

void processNodeEvents() {
	if(pushQueue->empty())
		return;

	nodeEventLock.lock();
	std::swap(pushQueue,activeQueue);
	nodeEventLock.release();

	for(auto i = activeQueue->begin(), end = activeQueue->end(); i != end; ++i) {
		NodeEvent* evt = *i;
		evt->process();
		delete evt;
	}

	activeQueue->clear();
}

NodeEvent::NodeEvent(Node* node) : node(node) {
	if(node)
		node->grab();
}

NodeEvent::~NodeEvent() {
	if(node)
		node->drop();
}

void Node::markForDeletion() {
	//TODO: This might be unsafe if the bool is packed alongside another member
	queuedDelete = true;
}

class ReparentNode : public NodeEvent {
	heldPointer<Node> parent;
public:
	ReparentNode(Node* reparent, Node* toParent) : NodeEvent(reparent), parent(toParent) {
	}

	void process() override {
		node->setParent(parent);
		node->rebuildTransformation();
		node->sortDistance = node->abs_position.distanceTo(devices.render->cam_pos);
	}
};

void Node::queueReparent(Node* newParent) {
	if(newParent == 0)
		newParent = devices.scene;
	queueNodeEvent(new ReparentNode(this, newParent));
}

class ReparentToObject : public NodeEvent {
public:
	heldPointer<Object> object;
	ReparentToObject(Node* reparent, Object* obj) : NodeEvent(reparent), object(obj) {
	}

	void process() override {
		//The object can't be destroyed here, so the node should stay valid too
		//TODO: Check that assumption in all cases. (True in practice now because
		//region nodes are never destroyed in game)
		Node* other = object->node;
		if(other) {
			node->setParent(other);
			node->rebuildTransformation();
			node->sortDistance = node->abs_position.distanceTo(devices.render->cam_pos);
		}
	}
};

void Node::hintParentObject(Object* obj, bool checkDistance) {
	if(!obj || !obj->node) {
		//We shouldn't be parented to anything
		if(parent && parent != devices.scene)
			queueReparent(nullptr);
	}
	else {
		//Check that we're completely inside this object
		double maxDist = obj->radius - abs_scale;
		if(!checkDistance || abs_position.distanceToSQ(obj->position) < maxDist * maxDist) {
			//Accessing the random object's node pointer is
			//not technically safe here, but because we're only checking
			//for equality it won't break.
			if(parent != obj->node)
				queueNodeEvent(new ReparentToObject(this, obj));
		}
		else {
			//We're too big to be in this node, leave
			if(parent && parent != devices.scene)
				queueReparent(nullptr);
		}
	}
	if(obj)
		obj->drop();
}

bool Node::getFlag(NodeFlag flag) const {
	return (flags & flag) != 0;
}

void Node::setFlag(NodeFlag flag, bool val) {
	if(val)
		flags |= flag;
	else
		flags &= ~flag;
}

bool Node::isChild(Node* check) {
	foreach(child, children) {
		if(*child == check)
			return true;
	}

	return false;
}

void Node::addChild(Node* child) {
	child->grab();
	children.push_back(child);
	child->setFlag(NF_Dirty, true);
	child->parent = this;
}

void Node::removeChild(Node* check) {
	foreach(child, children) {
		if(*child == check) {
			children.erase(child);
			check->parent = 0;
			check->drop();
			return;
		}
	}
}

void Node::setParent(Node* newParent) {
	if(newParent == parent)
		return;
	Node* oldParent = parent;
	if(newParent)
		newParent->addChild(this);
	if(oldParent)
		oldParent->removeChild(this);
	parent = newParent;
	if(newParent && oldParent)
		animate();
}

void Node::destroyTree() {
	foreach(child, children)
		(*child)->destroyTree();
	children.clear();
	parent = 0;
}

void Node::destroy() {
	if(physics) {
		devices.nodePhysics->unregisterItem(*physics);
		physics = 0;
		drop();
	}

	if(obj) {
		obj->drop();
		obj = 0;
	}

	animator = 0;
	parent = 0;
}

void Node::flagDirty() {
	if(!getFlag(NF_Dirty)) {
		setFlag(NF_Dirty, true);

		foreach(child, children)
			(*child)->flagDirty();
	}
}

bool nodeSort(scene::Node* a, scene::Node* b) {
	return *a < *b;
}

void Node::animate() {
#ifdef PROFILE_ANIMATION
	double start = devices.driver->getAccurateTime();
#endif
	if(animator)
		animator->animate(this);
	
	if(flags & NF_Dirty)
		rebuildTransformation();

	if(flags & NF_AnimOnlyVisible)
		frameVisible = visible && preRender(*devices.render);
	else
		frameVisible = preRender(*devices.render) && visible;
#ifdef PROFILE_ANIMATION
	double end = devices.driver->getAccurateTime();
	double duration = end - start;
	auto type = getType();
	nodeAnimCounts[type]++;
	volatile double& curTime = nodeAnimTimes[type];
	while(true) {
		double prev = curTime;
		double result = prev + duration;
		if(threads::compare_and_swap((long long*)&curTime, *(long long*)&prev, *(long long*)&result) == *(long long*)&prev)
			break;
	}
#endif

	if(frameVisible) {
		foreach(child, children)
			(*child)->animate();
		if(children.size() > 1)
			std::sort(children.begin(), children.end(), nodeSort);
	}
}

void Node::sortChildren() {
	if(children.size() > 1)
		std::sort(children.begin(), children.end(), nodeSort);
}

void Node::rebuildTransformation() {
	setFlag(NF_Dirty, false);

	if(parent && !getFlag(NF_Independent)) {
		if(getFlag(NF_ParentScale)) {
			abs_position = parent->abs_position + (parent->abs_rotation * position) * parent->abs_scale;
			abs_rotation = parent->abs_rotation * rotation;
			abs_scale = parent->abs_scale * scale;
		}
		else {
			abs_position = parent->abs_position + position;
			abs_rotation = rotation;
			abs_scale = scale;
		}
	}
	else {
		abs_position = position;
		abs_rotation = rotation;
		abs_scale = scale;
	}

	if(!getFlag(NF_NoMatrix))
		abs_rotation.toTransform(transformation, abs_position, abs_scale);

	if(physics) {
		auto bbox = AABBoxd::fromCircle(abs_position, abs_scale);
		if(physics->bound != bbox)
			devices.nodePhysics->updateItem(*physics, bbox);
	}
}

Node::Node() : flags(NF_Dirty | NF_Independent), lastUpdate(frameTime_s), sortDistance(0), scale(1), abs_scale(1), distanceCutoff(1.0e8),
	obj(0), physics(0), visible(true), frameVisible(true), queuedDelete(false), remembered(false) {}

Node::~Node() {
	destroy();
}

void Node::setObject(Object* Obj) {
	if(Obj == obj)
		return;
	if(Obj)
		Obj->grab();
	if(obj)
		obj->drop();
	obj = Obj;
}

Object* Node::getObject() {
	if(obj)
		obj->grab();
	return obj;
}

void Node::createPhysics() {
	if(physics || !devices.nodePhysics)
		return;

	rebuildTransformation();
	grab();
	physics = devices.nodePhysics->registerItem(AABBoxd::fromCircle(abs_position, abs_scale), this);
}

bool Node::operator<(const scene::Node& other) const {
	if(frameVisible && other.frameVisible) {
		bool alpha = getFlag(NF_Transparent);
		if(alpha != other.getFlag(NF_Transparent)) {
			if(alpha)
				return false;
			else
				return true;
		}
		else if(alpha) {
			return sortDistance > other.sortDistance;
		}
		else {
			return sortDistance < other.sortDistance;
		}
	}
	else if(frameVisible) {
		return true;
	}
	else {
		return false;
	}
}

void Node::_render(render::RenderDriver& driver) {
	renderingNode = this;
	render(driver);

	if(auto cnt = children.size()) {
		for(decltype(cnt) i = 0; i < cnt;) {
			scene::Node* child = children[i];
			if(!child->queuedDelete) {
				++i;
				if(child->frameVisible)
					child->_render(driver);
			}
			else {
				child->destroy();
				child->drop();

				children[i] = children[cnt-1];
				--cnt;
			}
		}

		if(cnt != children.size())
			children.resize(cnt);
	}
}

};