#include <cassert>
#include "base_data.h"
#include "world_editor.h"
#include "editor_event.h"
#include "building_layout_graph.h"

#define MIN_ROOM_SIZE 16 /* 4 * 4 tiles */

BuildingLayoutGraph::graph_module::graph_module(flecs::world &ecs)
{
	ecs.module<BuildingLayoutGraph::graph_module>();
	ecs.component<WorldEditor::components::buildings_layout_graph>();
	ecs.component<WorldEditor::components::buildings_layout_graph_node>();
	ecs.component<WorldEditor::components::buildings_layout_base>();
	ecs.component<WorldEditor::components::buildings_layout_room>();
	ecs.component<WorldEditor::components::buildings_layout_zone>();
	ecs.component<WorldEditor::components::buildings_layout_unit>();
	ecs.component<WorldEditor::components::buildings_layout_floor>();
	ecs.component<WorldEditor::components::buildings_layout_floor_index>();
	const String &module_name = "::BuildingLayoutGraph::graph_module";

	ecs.system<WorldEditor::components::buildings_layout_floor_index,
		   const WorldEditor::components::buildings_layout_floor>(
		   "FloorIndex")
		.kind(0)
		.write<WorldEditor::components::buildings_layout_floor_index>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_floor_index
				 &index,
			 const WorldEditor::components::buildings_layout_floor
				 &f) {
			flecs::entity e = it.entity(count);
			List<flecs::entity> queue;
			e.children([&queue](flecs::entity ec) {
				if (!ec.has<WorldEditor::components::
						    buildings_layout_floor>())
					queue.push_back(ec);
			});
			while (!queue.empty()) {
				flecs::entity qe = queue.front()->get();
				queue.pop_front();
				if (!qe.has<WorldEditor::components::
						    buildings_layout_floor>()) {
					qe.set<WorldEditor::components::
						       buildings_layout_floor_index>(
						{ index.index });
					print_line(String(qe.path()) +
						   " index set");
					qe.children([&queue](flecs::entity ec) {
						queue.push_back(ec);
					});
				}
			}
			print_line("floor index done");
		});

	ecs.system<WorldEditor::components::buildings_layout_room>("RoomArea")
		.kind(0)
		.without<WorldEditor::components::buildings_layout_area>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_room &f) {
			flecs::entity floor_e = it.entity(count);
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ MIN_ROOM_SIZE });
		});
	ecs.system<WorldEditor::components::buildings_layout_zone>("ZoneArea")
		.kind(0)
		.without<WorldEditor::components::buildings_layout_area>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_zone &f) {
			flecs::entity floor_e = it.entity(count);
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ 0.0f });
		});
	ecs.system<WorldEditor::components::buildings_layout_unit>("UnitArea")
		.kind(0)
		.without<WorldEditor::components::buildings_layout_area>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_unit &f) {
			flecs::entity floor_e = it.entity(count);
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ 0.0f });
		});
	ecs.system<WorldEditor::components::buildings_layout_floor>("FloorArea")
		.kind(0)
		.without<WorldEditor::components::buildings_layout_area>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_floor &f) {
			flecs::entity floor_e = it.entity(count);
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ 0.0f });
		});
	ecs.system<WorldEditor::components::buildings_layout_zone,
		   WorldEditor::components::buildings_layout_area,
		   WorldEditor::components::buildings_layout_floor_index>(
		   "ZoneAreaSum")
		.kind(0)
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_zone &f,
			 WorldEditor::components::buildings_layout_area &area,
			 WorldEditor::components::buildings_layout_floor_index
				 &index) {
			flecs::entity zone_e = it.entity(count);
			flecs::query<
				WorldEditor::components::buildings_layout_room,
				const WorldEditor::components::
					buildings_layout_area,
				const WorldEditor::components::
					buildings_layout_floor_index>
				q = zone_e.world()
					    .query_builder<
						    WorldEditor::components::
							    buildings_layout_room,
						    const WorldEditor::components::
							    buildings_layout_area,
						    const WorldEditor::components::
							    buildings_layout_floor_index>()
					    .with(flecs::ChildOf, zone_e)
					    .build();
			float sum = 0.0f;
			q.each([&sum,
				index](flecs::entity e,
				       WorldEditor::components::
					       buildings_layout_room &r,
				       const WorldEditor::components::
					       buildings_layout_area &rarea,
				       const WorldEditor::components::
					       buildings_layout_floor_index
						       &rindex) {
				if (index.index == rindex.index)
					sum += MAX(rarea.area, MIN_ROOM_SIZE);
			});
			zone_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ sum });
			print_line("area: " + String(zone_e.path()) + ": " +
				   String::num(sum));
		});
	ecs.system<const WorldEditor::components::buildings_layout_unit,
		   WorldEditor::components::buildings_layout_area,
		   WorldEditor::components::buildings_layout_floor_index>(
		   "UnitAreaSum")
		.kind(0)
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_unit &f,
			 WorldEditor::components::buildings_layout_area &area,
			 WorldEditor::components::buildings_layout_floor_index
				 &index) {
			flecs::entity unit_e = it.entity(count);
			flecs::query<
				WorldEditor::components::buildings_layout_zone,
				const WorldEditor::components::
					buildings_layout_area,
				const WorldEditor::components::
					buildings_layout_floor_index>
				q = unit_e.world()
					    .query_builder<
						    WorldEditor::components::
							    buildings_layout_zone,
						    const WorldEditor::components::
							    buildings_layout_area,
						    const WorldEditor::components::
							    buildings_layout_floor_index>()
					    .with(flecs::ChildOf, unit_e)
					    .build();
			float sum = 0.0f;
			q.each([&sum,
				index](flecs::entity e,
				       WorldEditor::components::
					       buildings_layout_zone &r,
				       const WorldEditor::components::
					       buildings_layout_area &rarea,
				       const WorldEditor::components::
					       buildings_layout_floor_index
						       &rindex) {
				if (index.index == rindex.index)
					sum += rarea.area;
			});
			unit_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ sum });
			print_line("area: " + String(unit_e.path()) + ": " +
				   String::num(sum));
		});
	ecs.system<const WorldEditor::components::buildings_layout_floor,
		   WorldEditor::components::buildings_layout_area,
		   WorldEditor::components::buildings_layout_floor_index>(
		   "FloorAreaSum")
		.kind(0)
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_floor
				 &f,
			 WorldEditor::components::buildings_layout_area &area,
			 WorldEditor::components::buildings_layout_floor_index
				 &index) {
			flecs::entity floor_e = it.entity(count);
			flecs::query<const WorldEditor::components::
					     buildings_layout_area,
				     const WorldEditor::components::
					     buildings_layout_floor_index>
				q = floor_e.world()
					    .query_builder<
						    const WorldEditor::components::
							    buildings_layout_area,
						    const WorldEditor::components::
							    buildings_layout_floor_index>()
					    .scope_open()
					    .with<WorldEditor::components::
							  buildings_layout_zone>()
					    .or_()
					    .with<WorldEditor::components::
							  buildings_layout_unit>()
					    .scope_close()
					    .with(flecs::ChildOf, floor_e)
					    .build();
			float sum = 0.0f;
			q.each([&sum,
				index](flecs::entity e,
				       const WorldEditor::components::
					       buildings_layout_area &rarea,
				       const WorldEditor::components::
					       buildings_layout_floor_index
						       &rindex) {
				if (index.index == rindex.index)
					sum += rarea.area;
			});
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ sum });
			print_line("area: " + String(floor_e.path()) + ": " +
				   String::num(sum));
		});
	ecs.system<const WorldEditor::components::buildings_layout_graph,
		   const WorldEditor::components::buildings_layout_floor_index,
		   const WorldEditor::components::buildings_layout_area>(
		   "CreateFloorData")
		.kind(0)
		.write<WorldEditor::components::buildings_layout_floor_data>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_graph
				 &p,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx,
			 const WorldEditor::components::buildings_layout_area
				 &area) {
			flecs::entity e = it.entity(count);
			flecs::query<WorldEditor::components::buildings_layout_area> q =
				e.world()
					.query_builder<
						WorldEditor::components::
							buildings_layout_area>()
					.with<WorldEditor::components::
						      buildings_layout_floor>()
					.with(flecs::ChildOf, e)
					.build();
			float max_area = area.area;
			q.each([&max_area](flecs::entity ec,
					   WorldEditor::components::
						   buildings_layout_area &r) {
				if (max_area < r.area)
					max_area = r.area;
			});
			float grid_size = Math::ceil(
				Math::ceil(Math::sqrt(max_area)) / 4.0f);
			e.set<WorldEditor::components::
				      buildings_layout_floor_data>(
				{ (int)Math::ceil(grid_size) });
			print_line("grid size: " +
				   itos((int)Math::ceil(grid_size)));
		});
	ecs.system<WorldEditor::components::buildings_layout_floor>(
		   "FloorCompleteArea")
		.kind(0)
		.each([module_name](
			      flecs::iter &it, size_t count,
			      WorldEditor::components::buildings_layout_floor
				      &f) {
			flecs::entity floor_e = it.entity(count);
			flecs::world w = floor_e.world();
			std::vector<String> systems = {
				"RoomArea",	"ZoneArea",	  "UnitArea",
				"FloorArea",	"ZoneAreaSum",	  "UnitAreaSum",
				"FloorAreaSum", "CreateFloorData"
			};
			int i;
			for (i = 0; i < (int)systems.size(); i++) {
				w.system(w.lookup((module_name +
						   "::" + systems[i])
							  .ascii()
							  .ptr()))
					.run();
			}
			print_line("floor complete");
		});
#if 0
	ecs.system<WorldEditor::components::buildings_layout_floor>("FloorArea")
		.kind(flecs::OnUpdate)
		.without<WorldEditor::components::buildings_layout_area>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_floor &f) {
			flecs::entity floor_e = it.entity(count);
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ 0.0f });
		});
	ecs.system<WorldEditor::components::buildings_layout_unit>("UnitArea")
		.kind(flecs::OnUpdate)
		.without<WorldEditor::components::buildings_layout_area>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_unit &f) {
			flecs::entity floor_e = it.entity(count);
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ 0.0f });
		});
	ecs.system<WorldEditor::components::buildings_layout_zone>("ZoneArea")
		.kind(flecs::OnUpdate)
		.without<WorldEditor::components::buildings_layout_area>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_zone &f) {
			flecs::entity floor_e = it.entity(count);
			floor_e.set<
				WorldEditor::components::buildings_layout_area>(
				{ 0.0f });
		});
	ecs.system<WorldEditor::components::buildings_layout_area,
		   const WorldEditor::components::buildings_layout_zone,
		   const WorldEditor::components::buildings_layout_floor_index>(
		   "MakeZoneAreas")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_area &area,
			 const WorldEditor::components::buildings_layout_zone &f,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx) {
			flecs::entity zone_e = it.entity(count);
			int index = idx.index;
			float parea = 0.0f;
			zone_e.children([index, &parea](flecs::entity ec) {
				if (ec.has<WorldEditor::components::
						   buildings_layout_room>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_floor_index>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_area>()) {
					if (ec.get<WorldEditor::components::
							   buildings_layout_floor_index>()
						    ->index == index)
						parea +=
							ec.get<WorldEditor::components::
								       buildings_layout_area>()
								->area;
				}
			});
			area.area = parea;
			print_line(String(zone_e.path()) +
				   " area: " + String::num(area.area));
		});
	ecs.system<WorldEditor::components::buildings_layout_area,
		   const WorldEditor::components::buildings_layout_unit,
		   const WorldEditor::components::buildings_layout_floor_index>(
		   "MakeUnitAreas")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_area &area,
			 const WorldEditor::components::buildings_layout_unit &f,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx) {
			flecs::entity zone_e = it.entity(count);
			int index = idx.index;
			float parea = 0.0f;
			zone_e.children([index, &parea](flecs::entity ec) {
				if (ec.has<WorldEditor::components::
						   buildings_layout_zone>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_floor_index>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_area>()) {
					if (ec.get<WorldEditor::components::
							   buildings_layout_floor_index>()
						    ->index == index)
						parea +=
							ec.get<WorldEditor::components::
								       buildings_layout_area>()
								->area;
				}
			});
			area.area = parea;
			print_line(String(zone_e.path()) +
				   " area: " + String::num(area.area));
		});
	ecs.system<WorldEditor::components::buildings_layout_area,
		   const WorldEditor::components::buildings_layout_floor,
		   const WorldEditor::components::buildings_layout_floor_index>(
		   "MakeFloorAreas")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_area>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_area &area,
			 const WorldEditor::components::buildings_layout_floor
				 &f,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx) {
			flecs::entity floor_e = it.entity(count);
			int index = idx.index;
			float parea = 0.0f;
			floor_e.children([index, &parea](flecs::entity ec) {
				if (ec.has<WorldEditor::components::
						   buildings_layout_zone>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_floor_index>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_area>()) {
					if (ec.get<WorldEditor::components::
							   buildings_layout_floor_index>()
						    ->index == index)
						parea +=
							ec.get<WorldEditor::components::
								       buildings_layout_area>()
								->area;
				}
				if (ec.has<WorldEditor::components::
						   buildings_layout_unit>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_floor_index>() &&
				    ec.has<WorldEditor::components::
						   buildings_layout_area>()) {
					if (ec.get<WorldEditor::components::
							   buildings_layout_floor_index>()
						    ->index == index)
						parea +=
							ec.get<WorldEditor::components::
								       buildings_layout_area>()
								->area;
				}
			});
			area.area = parea;
			print_line(String(floor_e.path()) +
				   " area: " + String::num(area.area));
		});
#if 0
	ecs.system<WorldEditor::components::buildings_layout_area,
		   const WorldEditor::components::buildings_layout_floor,
		   const WorldEditor::components::buildings_layout_floor_index>(
		   "MakeAreas")
		.kind(flecs::OnUpdate)
		//		.read<WorldEditor::components::buildings_layout_dirty>()
		.with<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_area &area,
			 const WorldEditor::components::buildings_layout_floor
				 &f,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx) {
			flecs::entity floor_e = it.entity(count);
			flecs::world ecs_ = floor_e.world();
			ecs_.system(ecs_.lookup("MakeZoneAreas")).run();
			ecs_.system(ecs_.lookup("MakeUnitAreas")).run();
			ecs_.system(ecs_.lookup("MakeFloorAreas")).run();
		});
#endif
	ecs.system<WorldEditor::components::buildings_layout_area,
		   const WorldEditor::components::buildings_layout_floor,
		   const WorldEditor::components::buildings_layout_floor_index>(
		   "MakeGridEntities")
		.kind(flecs::OnUpdate)
		//		.read<WorldEditor::components::buildings_layout_dirty>()
		.with<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 WorldEditor::components::buildings_layout_area &area,
			 const WorldEditor::components::buildings_layout_floor
				 &f,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx) {
#if 0
			flecs::entity floor_e = it.entity(count);
			List<flecs::entity> queue;
			assert(false);
			floor_e.children([&queue](flecs::entity ec) {
				if (!ec.has<WorldEditor::components::
						    buildings_layout_floor>())
					queue.push_back(ec);
			});
			while (!queue.empty()) {
				flecs::entity e = queue.front()->get();
				queue.pop_front();
			}
#endif
		});
#if 0
	ecs.system<WorldEditor::components::buildings_layout_zone>(
		   "CreateZoneData")
		.kind(flecs::OnUpdate)
		.without<WorldEditor::components::buildings_layout_zone_data>()
		.write<WorldEditor::components::buildings_layout_zone_data>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_zone
				 &p) {
			flecs::entity e = it.entity(count);
			e.set<WorldEditor::components::buildings_layout_zone_data>(
				{ 0.0f, false });
			e.add<WorldEditor::components::buildings_layout_dirty>();
			String path(it.entity(count).path());
			print_line("Create zone data: entity: " + path);
		});
	ecs.system<WorldEditor::components::buildings_layout_unit>(
		   "CreateUnitData")
		.kind(flecs::OnUpdate)
		.without<WorldEditor::components::buildings_layout_unit_data>()
		.write<WorldEditor::components::buildings_layout_unit_data>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_unit
				 &p) {
			flecs::entity e = it.entity(count);
			e.set<WorldEditor::components::buildings_layout_unit_data>(
				{ 0.0f });
			e.add<WorldEditor::components::buildings_layout_dirty>();
			String path(it.entity(count).path());
			print_line("Create unit data: entity: " + path);
		});
#if 0
	ecs.system<WorldEditor::components::buildings_layout_floor>("CreateFloorIndex")
		.kind(flecs::OnUpdate)
		.without<WorldEditor::components::buildings_layout_floor_index>()
		.write<WorldEditor::components::buildings_layout_floor_index>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_floor
				 &p) {
			flecs::entity e = it.entity(count);
			e.set<WorldEditor::components::buildings_layout_unit_data>(
				{ 0.0f });
		});
#endif
	ecs.system<WorldEditor::components::buildings_layout_unit>(
		   "UpdateUnitData")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_unit_data>()
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_unit_data>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_unit
				 &p) {
			flecs::entity e = it.entity(count);
			float area = 0.0f;
			e.children([&area](flecs::entity ec) {
				if (ec.has<WorldEditor::components::
						   buildings_layout_zone_data>())
					area += ec.get<WorldEditor::components::
							       buildings_layout_zone_data>()
							->area;
			});
			WorldEditor::components::buildings_layout_unit_data
				*udata = e.get_mut<
					WorldEditor::components::
						buildings_layout_unit_data>();
			udata->area = area;
			String path(it.entity(count).path());
			print_line("Update unit data: entity: " + path +
				   " area: " + String::num(area));
			e.remove<WorldEditor::components::
					 buildings_layout_dirty>();
			BuildingLayoutGraph::get_singleton()
				->get_layout_base()
				.add<WorldEditor::components::
					     buildings_layout_dirty>();
		});
	ecs.system<WorldEditor::components::buildings_layout_zone>(
		   "UpdateZoneData")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_zone_data>()
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_zone_data>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_zone
				 &p) {
			flecs::entity e = it.entity(count);
			float area = 0.0f;
			bool window = false;
			e.children([&area, &window](flecs::entity ec) {
				if (ec.has<WorldEditor::components::
						   buildings_layout_room_size>())
					area += ec.get<WorldEditor::components::
							       buildings_layout_room_size>()
							->area;
				if (ec.has<WorldEditor::components::
						   buildings_layout_room>()) {
					bool w =
						ec.get<WorldEditor::components::
							       buildings_layout_room>()
							->window;
					if (w)
						window = true;
				}
			});
			WorldEditor::components::buildings_layout_zone_data
				*zdata = e.get_mut<
					WorldEditor::components::
						buildings_layout_zone_data>();
			zdata->area = area;
			zdata->align_wall = window;
			String path(it.entity(count).path());
			print_line("Update zone data: entity: " + path +
				   " area: " + String::num(area));
			e.remove<WorldEditor::components::
					 buildings_layout_dirty>();
			flecs::entity parent_e = e.parent();
			if (parent_e.has<WorldEditor::components::
						 buildings_layout_unit>())
				parent_e.add<WorldEditor::components::
						     buildings_layout_dirty>();
			BuildingLayoutGraph::get_singleton()
				->get_layout_base()
				.add<WorldEditor::components::
					     buildings_layout_dirty>();
		});
	ecs.system<WorldEditor::components::buildings_layout_floor>(
		   "PropogateFloorIndex")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_floor_index>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_floor_data>()
		.immediate()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_floor
				 &r) {
			flecs::entity e = it.entity(count);
			print_line("propogate: " + String(e.path()) + " " +
				   itos(r.index));
			List<flecs::entity> queue;
			float area = 0.0f;
			/* e is a floor so skip it  and add children instead*/
			e.children([&area](flecs::entity ec) {
				if (ec.has<WorldEditor::components::
						   buildings_layout_unit_data>())
					area += ec.get<WorldEditor::components::
							       buildings_layout_unit_data>()
							->area;
				if (ec.has<WorldEditor::components::
						   buildings_layout_zone_data>())
					area += ec.get<WorldEditor::components::
							       buildings_layout_zone_data>()
							->area;
			});
			float size = Math::ceil(Math::sqrt(area) * 2.0f);
			int grid_size = (int)Math::ceil(size / 2.0f);
			e.set<WorldEditor::components::
				      buildings_layout_floor_data>(
				{ area, grid_size });
			e.children([&queue](flecs::entity ec) {
				/* do not add children floors to the queue */
				if (!ec.has<WorldEditor::components::
						    buildings_layout_floor>())
					queue.push_back(ec);
			});
			while (!queue.empty()) {
				flecs::entity qe = queue.front()->get();
				queue.pop_front();
				if (!qe.has<WorldEditor::components::
						    buildings_layout_floor>()) {
					/* do not add children under another floor either */
					qe.set<WorldEditor::components::
						       buildings_layout_floor_index>(
						{ r.index });
					qe.children([&queue](flecs::entity ec) {
						queue.push_back(ec);
					});
				}
			}
			BuildingLayoutGraph::get_singleton()
				->get_layout_base()
				.add<WorldEditor::components::
					     buildings_layout_dirty>();
			e.remove<WorldEditor::components::
					 buildings_layout_dirty>();
		});
#if 0
	ecs.system<WorldEditor::components::buildings_layout_graph>(
		   "CollectFloors")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_graph
				 &p) {
			flecs::entity e = it.entity(count);
			List<flecs::entity> queue;
			queue.push_back(e);
			while (!queue.empty()) {
				flecs::entity em = queue.front()->get();
				if (em.has<WorldEditor::components::buildings_layout_floor_data)
				queue.pop_front();
				em.children([&queue](flecs::entity ec) {
					queue.push_back(ec);
				});
			}
			e.remove<WorldEditor::components::
					 buildings_layout_dirty>();
		});

	ecs.system<WorldEditor::components::buildings_layout_base>(
		   "DestroyGrid")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.immediate()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_base
				 &p) {
			flecs::entity e = it.entity(count);
			flecs::entity grid_base_e =
				BuildingLayoutGraph::get_singleton()
					->get_layout_grid_base();
			grid_base_e.children([](flecs::entity ce) {
				print_line("delete: " + String(ce.path()));
				ce.destruct();
			});
		});
	ecs.system<WorldEditor::components::buildings_layout_base>("CreateGrid")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.immediate()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_base
				 &p) {
			flecs::entity e = it.entity(count);
			flecs::entity grid_base_e =
				BuildingLayoutGraph::get_singleton()
					->get_layout_grid_base();
			e.children([&grid_base_e](flecs::entity ec) {
				if (ec.has<WorldEditor::components::
						   buildings_layout_graph>()) {
					print_line(String(grid_base_e.path()));
					flecs::entity gc =
						ec.world()
							.entity(ec.name())
							.child_of(grid_base_e);
					gc.add<WorldEditor::components::
						       buildings_layout_grid>();
					gc.add<WorldEditor::components::
						       buildings_layout_dirty>();
					print_line("create: " +
						   String(gc.path()));
				}
			});
		});
#endif
#if 0
	ecs.system<WorldEditor::components::buildings_layout_grid>(
		   "PopulateGrid")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.immediate()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_grid
				 &p) {
			flecs::entity e = it.entity(count);
			flecs::entity grid_layout_e =
				BuildingLayoutGraph::get_singleton()
					->get_layout_base();
			flecs::entity layout_e
			
		});
#endif
	ecs.system<WorldEditor::components::buildings_layout_base>(
		   "UpdateGraph")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_base
				 &p) {
			flecs::entity e = it.entity(count);
			EditorEvent::get_singleton()->event.emit(
				"update_layout_view", varray());
			e.remove<WorldEditor::components::
					 buildings_layout_dirty>();
		});
#endif
#if 0
	ecs.observer<WorldEditor::components::buildings_layout_room>()
		.event(flecs::OnSet)
		.each([](flecs::entity e,
			 WorldEditor::components::buildings_layout_room &r) {
			e.add<WorldEditor::components::buildings_layout_dirty>();
			print_line("room set " + String(e.path()));
		});
	ecs.observer<WorldEditor::components::buildings_layout_zone>()
		.event(flecs::OnSet)
		.each([](flecs::entity e,
			 WorldEditor::components::buildings_layout_zone &r) {
			e.add<WorldEditor::components::buildings_layout_zone>();
			print_line("zone set " + String(e.path()));
		});
	ecs.observer<WorldEditor::components::buildings_layout_unit>()
		.event(flecs::OnSet)
		.each([](flecs::entity e,
			 WorldEditor::components::buildings_layout_unit &r) {
			e.add<WorldEditor::components::buildings_layout_dirty>();
			print_line("unit set " + String(e.path()));
		});
#endif
	ecs.system<const WorldEditor::components::buildings_layout_floor,
		   const WorldEditor::components::buildings_layout_floor_index,
		   const WorldEditor::components::buildings_layout_area>(
		   "CreateFloorData")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_floor_data>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_floor
				 &p,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx,
			 const WorldEditor::components::buildings_layout_area
				 &area) {
			flecs::entity e = it.entity(count);
			float grid_size = Math::ceil(
				Math::ceil(Math::sqrt(area.area)) / 4.0f);
			e.set<WorldEditor::components::
				      buildings_layout_floor_data>(
				{ (int)Math::ceil(grid_size) });
			print_line("grid size: " +
				   itos((int)Math::ceil(grid_size)));
			assert(false);
		});
	ecs.system<const WorldEditor::components::buildings_layout_floor,
		   const WorldEditor::components::buildings_layout_floor_index,
		   const WorldEditor::components::buildings_layout_area>(
		   "CreateGridEntity")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_grid>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_floor
				 &p,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx,
			 const WorldEditor::components::buildings_layout_area
				 &area) {
			flecs::entity e = it.entity(count);
			flecs::entity grid_e = e.lookup("grid");
			if (!grid_e.is_valid())
				grid_e = e.world().entity("grid").child_of(e);
			grid_e.add<
				WorldEditor::components::buildings_layout_grid>();
			/* create grid here */
		});
	ecs.system<const WorldEditor::components::buildings_layout_floor,
		   const WorldEditor::components::buildings_layout_floor_index,
		   const WorldEditor::components::buildings_layout_area>(
		   "FinishGraphUpdate")
		.kind(flecs::OnUpdate)
		.with<WorldEditor::components::buildings_layout_dirty>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([](flecs::iter &it, size_t count,
			 const WorldEditor::components::buildings_layout_floor
				 &p,
			 const WorldEditor::components::
				 buildings_layout_floor_index &idx,
			 const WorldEditor::components::buildings_layout_area
				 &area) {
			flecs::entity e = it.entity(count);
			EditorEvent::get_singleton()->event.emit(
				"update_layout_view", varray());
			e.remove<WorldEditor::components::
					 buildings_layout_dirty>();
		});
#endif

	ecs.observer<const WorldEditor::components::buildings_layout_area>()
		.event(flecs::OnSet)
		.with<WorldEditor::components::buildings_layout_room>()
		.write<WorldEditor::components::buildings_layout_dirty>()
		.each([module_name](
			      flecs::entity e,
			      const WorldEditor::components::buildings_layout_area
				      &r) {
			flecs::world w = e.world();
			// create indices
			w.system(w.lookup((module_name + "::FloorIndex")
						  .ascii()
						  .ptr()))
				.run();
			w.system(w.lookup((module_name + "::FloorCompleteArea")
						  .ascii()
						  .ptr()))
				.run();
			EditorEvent::get_singleton()->event.emit(
				"update_layout_view", varray());
#if 0
			/* if set for room make zone dirty */
			flecs::entity parent_e = e.parent();
			while (parent_e.is_valid()) {
				print_line(String(parent_e.path()));
				if (parent_e.has<
					    WorldEditor::components::
						    buildings_layout_floor>()) {
					parent_e.add<
						WorldEditor::components::
							buildings_layout_dirty>();
					break;
				}
				parent_e = parent_e.parent();
			}
#endif
#if 0
				if (parent_e.has<WorldEditor::components::
							 buildings_layout_zone>())
					parent_e.add<
						WorldEditor::components::
							buildings_layout_dirty>();
				parent_e.set<WorldEditor::components::
						     buildings_layout_area>(
					{ 0.0f });
#endif
#if 0
			flecs::world ecs_ = e.world();
			ecs_.system(ecs_.lookup("MakeZoneAreas")).run();
			ecs_.system(ecs_.lookup("MakeUnitAreas")).run();
			ecs_.system(ecs_.lookup("MakeFloorAreas")).run();
#endif
			print_line(String(e.path()) + ": set area");
		});
	/* Propagate floor index to children which are not floor */
	ecs.observer<WorldEditor::components::buildings_layout_floor_index>()
		.event(flecs::OnSet)
		.with<WorldEditor::components::buildings_layout_floor>()
		.each([module_name](flecs::entity e,
				    const WorldEditor::components::
					    buildings_layout_floor_index &r) {
			flecs::world w = e.world();
			// create indices
			w.system(w.lookup((module_name + "::FloorIndex")
						  .ascii()
						  .ptr()))
				.run();
			w.system(w.lookup((module_name + "::FloorCompleteArea")
						  .ascii()
						  .ptr()))
				.run();
			EditorEvent::get_singleton()->event.emit(
				"update_layout_view", varray());
			print_line(String(e.path()) + ": set floor");
#if 0
			List<flecs::entity> queue;
			queue.push_back(e);
			while (!queue.empty()) {
				flecs::entity qe = queue.front()->get();
				queue.pop_front();
				if (!qe.has<WorldEditor::components::
						    buildings_layout_floor>()) {
					qe.set<WorldEditor::components::
						       buildings_layout_floor_index>(
						{ r.index });
				}
			}
			BuildingLayoutGraph::get_singleton()
				->get_layout_base()
				.add<WorldEditor::components::
					     buildings_layout_dirty>();
#endif
		});
}

/* These functions are used from GUI */

flecs::entity
BuildingLayoutGraph::create_graph_entity(const String &base_path,
					 const String &entity_type)
{
	flecs::world ecs = BaseData::get_singleton()->get();
	flecs::entity base_e = ecs.lookup(base_path.ascii().ptr());
	int count = 0;
	const String &type_name = entity_type;
	base_e.children([type_name, &count](flecs::entity e) {
		String name(e.name());
		if (name.begins_with(type_name + "_" + itos(count)))
			count++;
	});
	String ename = type_name + "_" + itos(count);
	flecs::entity new_e = ecs.entity(ename.ascii().ptr()).child_of(base_e);
	return new_e;
}

void BuildingLayoutGraph::create_zone(const String &base_path, int zone_type)
{
	flecs::entity new_e = create_graph_entity(base_path, "zone");
	new_e.set<WorldEditor::components::buildings_layout_zone>(
		{ zone_type });
	new_e.set<WorldEditor::components::buildings_layout_graph_node>(
		{ 0, 0, 0 });
	int count = get_children_count(new_e.parent());
	new_e.set<WorldEditor::components::buildings_layout_order>({ count });
}

void BuildingLayoutGraph::create_unit(const String &base_path)
{
	flecs::entity new_e = create_graph_entity(base_path, "unit");
	new_e.set<WorldEditor::components::buildings_layout_unit>({ 0 });
	new_e.set<WorldEditor::components::buildings_layout_graph_node>(
		{ 0, 0, 0 });
	int count = get_children_count(new_e.parent());
	new_e.set<WorldEditor::components::buildings_layout_order>({ count });
}

void BuildingLayoutGraph::create_floor(const String &base_path)
{
	flecs::entity new_e = create_graph_entity(base_path, "floor");
	new_e.set<WorldEditor::components::buildings_layout_floor>({ 0 });
	new_e.set<WorldEditor::components::buildings_layout_graph_node>(
		{ 0, 0, 0 });
	int count = get_children_count(new_e.parent());
	new_e.set<WorldEditor::components::buildings_layout_order>({ count });
}

void BuildingLayoutGraph::create_room(const String &base_path, int id)
{
	Array room;
	BuildingLayoutGraph::get_singleton()->get_room_data(id, room);
	assert(!room.empty());
	String type_name = room[1];
	Dictionary room_options = room[2];
	bool window = room_options.get("window", false);
	type_name = type_name.replace(" ", "_").to_lower();
	flecs::entity new_e = create_graph_entity(base_path, type_name);
	new_e.set<WorldEditor::components::buildings_layout_room>(
		{ id, window });
	new_e.set<WorldEditor::components::buildings_layout_graph_node>(
		{ 0, 0, 0 });
	new_e.set<WorldEditor::components::buildings_layout_area>({ 0.0f });
	assert(new_e.has<WorldEditor::components::buildings_layout_graph_node>());
	int count = get_children_count(new_e.parent());
	new_e.set<WorldEditor::components::buildings_layout_order>({ count });
	new_e.set<WorldEditor::components::buildings_layout_command>({ -1 });
}

void BuildingLayoutGraph::create_new_layout(const String &layout_name)
{
	flecs::world ecs = BaseData::get_singleton()->get();
	flecs::entity base = get_layout_base();
	flecs::entity e = base.lookup(layout_name.ascii().ptr());
	if (e.is_valid())
		return;
	e = ecs.entity(layout_name.ascii().ptr()).child_of(base);
	if (e.is_valid()) {
		e.add<WorldEditor::components::buildings_layout_graph>();
		e.set<WorldEditor::components::buildings_layout_floor>({ 0 });
		e.set<WorldEditor::components::buildings_layout_graph_node>(
			{ 0, 0, 0 });
		e.set<WorldEditor::components::buildings_layout_floor_index>(
			{ 0 });
		e.set<WorldEditor::components::buildings_layout_area>({ 0 });
		int count = get_children_count(base);
		e.set<WorldEditor::components::buildings_layout_order>(
			{ count });
	}
}