/*************************************************************************/
/*  scene_replication_state.cpp                                          */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#include "scene_replication_state.h"

#include "scene/scene_string_names.h"

#include "multiplayer_spawner.h"
#include "multiplayer_synchronizer.h"

SceneReplicationState::TrackedNode &SceneReplicationState::_track(const ObjectID &p_id) {
	if (!tracked_nodes.has(p_id)) {
		tracked_nodes[p_id] = TrackedNode(p_id);
		Node *node = Object::cast_to<Node>(ObjectDB::get_instance(p_id));
		node->connect(SceneStringNames::get_singleton()->tree_exited, callable_mp(this, &SceneReplicationState::_untrack).bind(p_id), Node::CONNECT_ONESHOT);
	}
	return tracked_nodes[p_id];
}

void SceneReplicationState::_untrack(const ObjectID &p_id) {
	if (tracked_nodes.has(p_id)) {
		uint32_t net_id = tracked_nodes[p_id].net_id;
		uint32_t peer = tracked_nodes[p_id].remote_peer;
		tracked_nodes.erase(p_id);
		// If it was spawned by a remote, remove it from the received nodes.
		if (peer && peers_info.has(peer)) {
			peers_info[peer].recv_nodes.erase(net_id);
		}
		// If we spawned or synced it, we need to remove it from any peer it was sent to.
		if (net_id || peer == 0) {
			for (KeyValue<int, PeerInfo> &E : peers_info) {
				E.value.sync_nodes.erase(p_id);
				E.value.spawn_nodes.erase(p_id);
			}
		}
	}
}

const HashMap<uint32_t, ObjectID> SceneReplicationState::peer_get_remotes(int p_peer) const {
	return peers_info.has(p_peer) ? peers_info[p_peer].recv_nodes : HashMap<uint32_t, ObjectID>();
}

bool SceneReplicationState::update_last_node_sync(const ObjectID &p_id, uint16_t p_time) {
	TrackedNode *tnode = tracked_nodes.getptr(p_id);
	ERR_FAIL_COND_V(!tnode, false);
	if (p_time <= tnode->last_sync && tnode->last_sync - p_time < 32767) {
		return false;
	}
	tnode->last_sync = p_time;
	return true;
}

bool SceneReplicationState::update_sync_time(const ObjectID &p_id, uint64_t p_msec) {
	TrackedNode *tnode = tracked_nodes.getptr(p_id);
	ERR_FAIL_COND_V(!tnode, false);
	MultiplayerSynchronizer *sync = get_synchronizer(p_id);
	if (!sync) {
		return false;
	}
	if (tnode->last_sync_msec == p_msec) {
		return true;
	}
	if (p_msec >= tnode->last_sync_msec + sync->get_replication_interval_msec()) {
		tnode->last_sync_msec = p_msec;
		return true;
	}
	return false;
}

uint32_t SceneReplicationState::get_net_id(const ObjectID &p_id) const {
	const TrackedNode *tnode = tracked_nodes.getptr(p_id);
	ERR_FAIL_COND_V(!tnode, 0);
	return tnode->net_id;
}

void SceneReplicationState::set_net_id(const ObjectID &p_id, uint32_t p_net_id) {
	TrackedNode *tnode = tracked_nodes.getptr(p_id);
	ERR_FAIL_COND(!tnode);
	tnode->net_id = p_net_id;
}

uint32_t SceneReplicationState::ensure_net_id(const ObjectID &p_id) {
	TrackedNode *tnode = tracked_nodes.getptr(p_id);
	ERR_FAIL_COND_V(!tnode, 0);
	if (tnode->net_id == 0) {
		tnode->net_id = ++last_net_id;
	}
	return tnode->net_id;
}

void SceneReplicationState::on_peer_change(int p_peer, bool p_connected) {
	if (p_connected) {
		peers_info[p_peer] = PeerInfo();
		known_peers.insert(p_peer);
	} else {
		peers_info.erase(p_peer);
		known_peers.erase(p_peer);
	}
}

void SceneReplicationState::reset() {
	peers_info.clear();
	known_peers.clear();
	// Tracked nodes are cleared on deletion, here we only reset the ids so they can be later re-assigned.
	for (KeyValue<ObjectID, TrackedNode> &E : tracked_nodes) {
		TrackedNode &tobj = E.value;
		tobj.net_id = 0;
		tobj.remote_peer = 0;
		tobj.last_sync = 0;
	}
}

Error SceneReplicationState::config_add_spawn(Node *p_node, MultiplayerSpawner *p_spawner) {
	const ObjectID oid = p_node->get_instance_id();
	TrackedNode &tobj = _track(oid);
	ERR_FAIL_COND_V(tobj.spawner != ObjectID(), ERR_ALREADY_IN_USE);
	tobj.spawner = p_spawner->get_instance_id();
	spawned_nodes.insert(oid);
	return OK;
}

Error SceneReplicationState::config_del_spawn(Node *p_node, MultiplayerSpawner *p_spawner) {
	const ObjectID oid = p_node->get_instance_id();
	ERR_FAIL_COND_V(!is_tracked(oid), ERR_INVALID_PARAMETER);
	TrackedNode &tobj = _track(oid);
	ERR_FAIL_COND_V(tobj.spawner != p_spawner->get_instance_id(), ERR_INVALID_PARAMETER);
	tobj.spawner = ObjectID();
	spawned_nodes.erase(oid);
	for (KeyValue<int, PeerInfo> &E : peers_info) {
		E.value.spawn_nodes.erase(oid);
	}
	return OK;
}

Error SceneReplicationState::config_add_sync(Node *p_node, MultiplayerSynchronizer *p_sync) {
	const ObjectID oid = p_node->get_instance_id();
	TrackedNode &tobj = _track(oid);
	ERR_FAIL_COND_V(tobj.synchronizer != ObjectID(), ERR_ALREADY_IN_USE);
	tobj.synchronizer = p_sync->get_instance_id();
	synced_nodes.insert(oid);
	return OK;
}

Error SceneReplicationState::config_del_sync(Node *p_node, MultiplayerSynchronizer *p_sync) {
	const ObjectID oid = p_node->get_instance_id();
	ERR_FAIL_COND_V(!is_tracked(oid), ERR_INVALID_PARAMETER);
	TrackedNode &tobj = _track(oid);
	ERR_FAIL_COND_V(tobj.synchronizer != p_sync->get_instance_id(), ERR_INVALID_PARAMETER);
	tobj.synchronizer = ObjectID();
	synced_nodes.erase(oid);
	for (KeyValue<int, PeerInfo> &E : peers_info) {
		E.value.sync_nodes.erase(oid);
	}
	return OK;
}

Error SceneReplicationState::peer_add_sync(int p_peer, const ObjectID &p_id) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), ERR_INVALID_PARAMETER);
	peers_info[p_peer].sync_nodes.insert(p_id);
	return OK;
}

Error SceneReplicationState::peer_del_sync(int p_peer, const ObjectID &p_id) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), ERR_INVALID_PARAMETER);
	peers_info[p_peer].sync_nodes.erase(p_id);
	return OK;
}

const HashSet<ObjectID> SceneReplicationState::get_peer_sync_nodes(int p_peer) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), HashSet<ObjectID>());
	return peers_info[p_peer].sync_nodes;
}

bool SceneReplicationState::is_peer_sync(int p_peer, const ObjectID &p_id) const {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), false);
	return peers_info[p_peer].sync_nodes.has(p_id);
}

Error SceneReplicationState::peer_add_spawn(int p_peer, const ObjectID &p_id) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), ERR_INVALID_PARAMETER);
	peers_info[p_peer].spawn_nodes.insert(p_id);
	return OK;
}

Error SceneReplicationState::peer_del_spawn(int p_peer, const ObjectID &p_id) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), ERR_INVALID_PARAMETER);
	peers_info[p_peer].spawn_nodes.erase(p_id);
	return OK;
}

const HashSet<ObjectID> SceneReplicationState::get_peer_spawn_nodes(int p_peer) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), HashSet<ObjectID>());
	return peers_info[p_peer].spawn_nodes;
}

bool SceneReplicationState::is_peer_spawn(int p_peer, const ObjectID &p_id) const {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), false);
	return peers_info[p_peer].spawn_nodes.has(p_id);
}

Node *SceneReplicationState::peer_get_remote(int p_peer, uint32_t p_net_id) {
	PeerInfo *info = peers_info.getptr(p_peer);
	return info && info->recv_nodes.has(p_net_id) ? Object::cast_to<Node>(ObjectDB::get_instance(info->recv_nodes[p_net_id])) : nullptr;
}

Error SceneReplicationState::peer_add_remote(int p_peer, uint32_t p_net_id, Node *p_node, MultiplayerSpawner *p_spawner) {
	ERR_FAIL_COND_V(!p_node || !p_spawner, ERR_INVALID_PARAMETER);
	ERR_FAIL_COND_V(!peers_info.has(p_peer), ERR_UNAVAILABLE);
	PeerInfo &pinfo = peers_info[p_peer];
	ObjectID oid = p_node->get_instance_id();
	TrackedNode &tobj = _track(oid);
	tobj.spawner = p_spawner->get_instance_id();
	tobj.net_id = p_net_id;
	tobj.remote_peer = p_peer;
	tobj.last_sync = pinfo.last_recv_sync;
	// Also track as a remote.
	ERR_FAIL_COND_V(pinfo.recv_nodes.has(p_net_id), ERR_ALREADY_IN_USE);
	pinfo.recv_nodes[p_net_id] = oid;
	return OK;
}

Error SceneReplicationState::peer_del_remote(int p_peer, uint32_t p_net_id, Node **r_node) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), ERR_UNAUTHORIZED);
	PeerInfo &info = peers_info[p_peer];
	ERR_FAIL_COND_V(!info.recv_nodes.has(p_net_id), ERR_UNAUTHORIZED);
	*r_node = Object::cast_to<Node>(ObjectDB::get_instance(info.recv_nodes[p_net_id]));
	info.recv_nodes.erase(p_net_id);
	return OK;
}

uint16_t SceneReplicationState::peer_sync_next(int p_peer) {
	ERR_FAIL_COND_V(!peers_info.has(p_peer), 0);
	PeerInfo &info = peers_info[p_peer];
	return ++info.last_sent_sync;
}

void SceneReplicationState::peer_sync_recv(int p_peer, uint16_t p_time) {
	ERR_FAIL_COND(!peers_info.has(p_peer));
	peers_info[p_peer].last_recv_sync = p_time;
}