text: /*************************************************************************/
  /*  jsonrpc.cpp                                                          */
  /*************************************************************************/
  /*                       This file is part of:                           */
  /*                           GODOT ENGINE                                */
  /*                      https://godotengine.org                          */
  /*************************************************************************/
  /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
  /* Copyright (c) 2014-2020 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 "jsonrpc.h"
  #include "core/io/json.h"
  
  JSONRPC::JSONRPC() {
  }
  
  JSONRPC::~JSONRPC() {
  }
  
  void JSONRPC::_bind_methods() {
  	ClassDB::bind_method(D_METHOD("set_scope", "scope", "target"), &JSONRPC::set_scope);
  	ClassDB::bind_method(D_METHOD("process_action", "action", "recurse"), &JSONRPC::process_action, DEFVAL(false));
  	ClassDB::bind_method(D_METHOD("process_string", "action"), &JSONRPC::process_string);
  
  	ClassDB::bind_method(D_METHOD("make_request", "method", "params", "id"), &JSONRPC::make_request);
  	ClassDB::bind_method(D_METHOD("make_response", "result", "id"), &JSONRPC::make_response);
  	ClassDB::bind_method(D_METHOD("make_notification", "method", "params"), &JSONRPC::make_notification);
  	ClassDB::bind_method(D_METHOD("make_response_error", "code", "message", "id"), &JSONRPC::make_response_error, DEFVAL(Variant()));
  
  	BIND_ENUM_CONSTANT(PARSE_ERROR);
  	BIND_ENUM_CONSTANT(INVALID_REQUEST);
  	BIND_ENUM_CONSTANT(METHOD_NOT_FOUND);
  	BIND_ENUM_CONSTANT(INVALID_PARAMS);
  	BIND_ENUM_CONSTANT(INTERNAL_ERROR);
  }
  
  Dictionary JSONRPC::make_response_error(int p_code, const String &p_message, const Variant &p_id) const {
  	Dictionary dict;
  	dict["jsonrpc"] = "2.0";
  
  	Dictionary err;
  	err["code"] = p_code;
  	err["message"] = p_message;
  
  	dict["error"] = err;
  	dict["id"] = p_id;
  
  	return dict;
  }
  
  Dictionary JSONRPC::make_response(const Variant &p_value, const Variant &p_id) {
  	Dictionary dict;
  	dict["jsonrpc"] = "2.0";
  	dict["id"] = p_id;
  	dict["result"] = p_value;
  	return dict;
  }
  
  Dictionary JSONRPC::make_notification(const String &p_method, const Variant &p_params) {
  	Dictionary dict;
  	dict["jsonrpc"] = "2.0";
  	dict["method"] = p_method;
  	dict["params"] = p_params;
  	return dict;
  }
  
  Dictionary JSONRPC::make_request(const String &p_method, const Variant &p_params, const Variant &p_id) {
  	Dictionary dict;
  	dict["jsonrpc"] = "2.0";
  	dict["method"] = p_method;
  	dict["params"] = p_params;
  	dict["id"] = p_id;
  	return dict;
  }
  
  Variant JSONRPC::process_action(const Variant &p_action, bool p_process_arr_elements) {
  	Variant ret;
  	if (p_action.get_type() == Variant::DICTIONARY) {
  		Dictionary dict = p_action;
  		String method = dict.get("method", "");
  		Array args;
  		if (dict.has("params")) {
  			Variant params = dict.get("params", Variant());
  			if (params.get_type() == Variant::ARRAY) {
  				args = params;
  			} else {
  				args.push_back(params);
  			}
  		}
  
  		Object *object = this;
  		if (method_scopes.has(method.get_base_dir())) {
  			object = method_scopes[method.get_base_dir()];
  			method = method.get_file();
  		}
  
  		Variant id;
  		if (dict.has("id")) {
  			id = dict["id"];
  		}
  
  		if (object == NULL || !object->has_method(method)) {
  			ret = make_response_error(JSONRPC::METHOD_NOT_FOUND, "Method not found: " + method, id);
  		} else {
  			Variant call_ret = object->callv(method, args);
  			if (id.get_type() != Variant::NIL) {
  				ret = make_response(call_ret, id);
  			}
  		}
  	} else if (p_action.get_type() == Variant::ARRAY && p_process_arr_elements) {
  		Array arr = p_action;
  		int size = arr.size();
  		if (size) {
  			Array arr_ret;
  			for (int i = 0; i < size; i++) {
  				const Variant &var = arr.get(i);
  				arr_ret.push_back(process_action(var));
  			}
  			ret = arr_ret;
  		} else {
  			ret = make_response_error(JSONRPC::INVALID_REQUEST, "Invalid Request");
  		}
  	} else {
  		ret = make_response_error(JSONRPC::INVALID_REQUEST, "Invalid Request");
  	}
  	return ret;
  }
  
  String JSONRPC::process_string(const String &p_input) {
  
  	if (p_input.empty()) return String();
  
  	Variant ret;
  	Variant input;
  	String err_message;
  	int err_line;
  	if (OK != JSON::parse(p_input, input, err_message, err_line)) {
  		ret = make_response_error(JSONRPC::PARSE_ERROR, "Parse error");
  	} else {
  		ret = process_action(input, true);
  	}
  
  	if (ret.get_type() == Variant::NIL) {
  		return "";
  	}
  	return JSON::print(ret);
  }
  
  void JSONRPC::set_scope(const String &p_scope, Object *p_obj) {
  	method_scopes[p_scope] = p_obj;
  }
  