#ifndef WORLD_H
#define WORLD_H

/*************************************************************************/
/*  world.h                                                              */
/*************************************************************************/
/*                         This file is part of:                         */
/*                          PANDEMONIUM ENGINE                           */
/*             https://github.com/Relintai/pandemonium_engine            */
/*************************************************************************/
/* Copyright (c) 2022-present Péter Magyar.                              */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
/*                                                                       */
/* 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 "core/containers/vector.h"
#include "core/object/reference.h"

#include "node.h"

class Camera;
class World3D;
class World2D;

class World : public Node {
	GDCLASS(World, Node);

public:
	Camera *get_camera() const;

	Ref<World2D> get_world_2d() const;
	void set_world_2d(const Ref<World2D> &p_world_2d);

	Ref<World3D> get_world_3d() const;
	void set_world_3d(const Ref<World3D> &p_world);

	bool is_using_own_world_3d() const;
	void set_use_own_world_3d(const bool p_use_own_world_3d);

	bool get_override_in_parent_viewport();
	void set_override_in_parent_viewport(const bool value);

	//If a World has an override these are overridden
	Ref<World2D> find_world_2d() const;
	Ref<World3D> find_world_3d() const;
	Ref<World2D> find_world_2d_no_override() const;
	Ref<World3D> find_world_3d_no_override() const;

	World *get_override_world();
	World *get_override_world_or_this();
	void set_override_world(World *p_world);
	void set_override_world_bind(Node *p_world);

	// If a world has an override the override defers these to the overridden
	// As these are called by the child Nodes of the overriding world

	// Viewport root
	// -- World w1
	// ---- PanelContainer pc

	// w1 is set as override for the root.
	// pc's CanvasItem will use the canvas in w1, and will likely call gui_reset_canvas_sort_index() in w1 at least some point.
	// What we want, is to defer this call to the root viewport, as that is the class that is able to deal with it.
	// This is what makes overrides transparent to nodes like the Camera, as they can just use the world that they are a child of
	// and overrides can be handled for them in the background.

	virtual void gui_reset_canvas_sort_index();
	virtual int gui_get_canvas_sort_index();

	virtual void enable_canvas_transform_override(bool p_enable);
	virtual bool is_canvas_transform_override_enbled() const;

	virtual void set_canvas_transform_override(const Transform2D &p_transform);
	virtual Transform2D get_canvas_transform_override() const;

	virtual void set_canvas_transform(const Transform2D &p_transform);
	virtual Transform2D get_canvas_transform() const;

	virtual void set_global_canvas_transform(const Transform2D &p_transform);
	virtual Transform2D get_global_canvas_transform() const;

	virtual Transform2D get_final_transform() const;

	virtual Rect2 get_visible_rect() const;

	virtual RID get_viewport_rid() const;

	Vector2 get_camera_coords(const Vector2 &p_viewport_coords) const;
	Vector2 get_camera_rect_size() const;

	void update_worlds();

	void _world_3d_register_camera(Camera *p_camera);
	void _world_3d_remove_camera(Camera *p_camera);
	void _world_3d_register_camera_no_override(Camera *p_camera);
	void _world_3d_remove_camera_no_override(Camera *p_camera);
	void _world_3d_register_camera_as_override(Camera *p_camera);
	void _world_3d_remove_camera_as_override(Camera *p_camera);
	void _clear_override_cameras();
	void _add_override_cameras(World *p_from);

	World();
	~World();

	//friend class Camera;
	void _camera_transform_changed_notify();
	virtual void _camera_set(Camera *p_camera);
	bool _camera_add(Camera *p_camera); //true if first
	void _camera_remove(Camera *p_camera);
	void _camera_make_next_current(Camera *p_exclude);

	virtual void _update_listener();
	virtual void _update_listener_2d();

protected:
	virtual void _own_world_3d_changed();
	virtual void _on_set_use_own_world_3d(bool p_use_own_world_3d);
	virtual void _on_set_world_3d(const Ref<World3D> &p_old_world);
	virtual void _on_set_world_2d(const Ref<World2D> &p_old_world_2d);

	virtual void _on_before_world_override_changed();
	virtual void _on_after_world_override_changed();

	void _propagate_enter_world(Node *p_node);
	void _propagate_exit_world(Node *p_node);

	void _notification(int p_what);

	static void _bind_methods();

	Ref<World2D> world_2d;
	Ref<World3D> world_3d;
	Ref<World3D> own_world_3d;

	World *_parent_world;

	bool _override_in_parent_viewport;
	World *_override_world;
	World *_overriding_world;

	Camera *camera;
	RBSet<Camera *> cameras;
	Camera *_own_active_camera;
	Vector<Camera *> _override_cameras;

	//override canvas layers vec remove /add on override set, and unset

	Size2 size;
};

#endif