#ifndef MAPMODEL_H
#define MAPMODEL_H

#include <QObject>

#include "MapLayer.h"
#include "MapModelElement.h"
#include "MapModelListener.h"

#include "MMRoot.h"


#include <Indoor/floorplan/v2/Floorplan.h>
#include <Indoor/floorplan/v2/FloorplanReader.h>
#include <Indoor/floorplan/v2/FloorplanWriter.h>

class MapModel : public QObject, public MapLayerListener {

	Q_OBJECT

private:

	///** wrapper-classes for all elements */
	//std::vector<MapModelElement*> selElements;

	/** the map's root-layer containing all other layers */
	MapLayer* root = nullptr;

	/** the currently selected layer (if any) */
	MapLayer* selLayer = nullptr;

	/** the loaded floorplan */
	Floorplan::IndoorMap* im;

	/** listener */
	std::vector<MapModelListener*> listeners;

public:

	/** ctor */
	MapModel() {
		root = new MapLayerRoot(nullptr);
	}

	virtual ~MapModel() {
		cleanup();
	}

	/** attach a listener */
	void addListener(MapModelListener* l) {
		listeners.push_back(l);
	}

	/** create a new, empty root node */
	void startEmpty() {
		im = new Floorplan::IndoorMap();
		root = new MMRoot(nullptr, im);
		root->addListener(this);
		//root->addSublayer(new MMFloors(root, im));
	}

	void cleanup() {
		selLayer = nullptr;
		//selElements.clear();
		if (root) {delete root; root = nullptr;}
	}

	void load(const std::string& file) {

		emit aboutToReset();

		cleanup();

		// load the indoor-map using the given XML-file
		im = Floorplan::Reader::readFromFile(file);
		root = new MMRoot(nullptr, im);
		root->addListener(this);

		emit reset();

	}

	void save(const std::string& file) {

		Floorplan::Writer::writeToFile(im, file);

	}

	void onLayerChanged(MapLayer* layer) override {
		for (MapModelListener* l : listeners) {l->onLayerChanged(layer);}
	}

	void onLayerElementAdded(MapLayer* layer, MapModelElement* elem) override {
		for (MapModelListener* l : listeners) {l->onLayerElementAdded(layer, elem);}
	}

	void onLayerElementRemoved(MapLayer* layer, const MapModelElement* elem) override {
		for (MapModelListener* l : listeners) {l->onLayerElementRemoved(layer, elem);}
	}

	void onLayerVisibilityChanged(MapLayer* layer, const bool visible) override {
		for (MapModelListener* l : listeners) {l->onLayerVisibilityChanged(layer, visible);}
	}

	/** get the constructed map */
	Floorplan::IndoorMap* getMap() const {
		return im;
	}

	/** get the map's root-layer containing all other layers */
	MapLayer* getRootLayer() { return root; }

//	/** get all elements within the currently selected layer */
//	std::vector<MapModelElement*> getSelectedLayerElements() {
//		//return selElements;
//		//return (selLayer) ? (selLayer->getElementsRecursive()) : (std::vector<MapModelElement*>());
////		std::vector<MapModelElement*> elements;
////		root->getVisibleElementsRecursive(elements);
////		return elements;

//	}

	/** get all currently visible elements */
	std::vector<MapModelElement*> getVisibleElements() {
		std::vector<MapModelElement*> elements;
		root->getVisibleElementsRecursive(elements);
		return elements;
	}

	/** set the currently selected layer */
	void setSelectedLayer(MapLayer* ml) {
		//selElements.clear();
		//for (MapModelElement* el : ml->getElementsRecursive()) {selElements.push_back(el);}
		selLayer = ml;
	}

	/** get the currently selected layer */
	MapLayer* getSelectedLayer() const {
		return selLayer;
	}

	void reselect() {
		setSelectedLayer(selLayer);
		emit reset();
	}

signals:

	void aboutToReset();
	void reset();

};

#endif // MAPMODEL_H