#ifndef _MODEL_H
#define _MODEL_H

#include "ModelBase.h"
#include "AsteroidsEnums.h"

namespace asteroids {

class Model : public Engine::ModelBase {
	public:
		virtual ~Model() {};
		virtual void Process();
		int DoLoadLevel (const char* filename);
		int DoSaveLevel (const char* filename);
		bool OnLevelComplete();
		bool OnGameOver();
		/** \brief Resets values from a previous game */
		void OnNewGame ();

		int GetPlayerLives () { return mPlayerLives; };
		unsigned int GetPoints () { return mPoints; };
		std::string GetPlayerName() { return mPlayerName; };
		void SetPlayerName(const std::string &name) { mPlayerName = name; };

		float GetWorldWidth ();
		float GetWorldHeight ();

		struct HighscoreEntry {
			HighscoreEntry(): name ("unknown"), points (0) {	};
			HighscoreEntry (const char *e_name, const unsigned int e_points):
				name (e_name), points (e_points) { };

			std::string name;
			unsigned int points;
		};

		/* Highscore */
		void LoadHighscoreList ();
		void SaveHighscoreList ();
		unsigned int AddHighscoreEntry(const std::string &name, const unsigned int points);
		bool HighscoreCmp (HighscoreEntry a, HighscoreEntry b);
		std::list<HighscoreEntry> mHighscoreList;
		unsigned int mNewestHighscoreEntryIndex;

	protected:
		/** \brief Initializes the system */
		virtual int OnInit (int argc, char* argv[]);
		virtual void OnDestroy() {
			Engine::ModelBase::OnDestroy();
			mAsteroids.clear();
			mLevelList.clear();
			SaveHighscoreList();
			delete mLevelCompleteEventHandler;
			delete mGameOverEventHandler;
		};
		virtual void OnRegisterCommands ();

		virtual void OnCreateEntity (const int type, const unsigned int id);
		virtual void OnKillEntity (const Engine::EntityBase *entity); 

	private:
		unsigned int InitLevelList ();

		/** \brief Keeps a list of all asteroids */
		std::vector<unsigned int> mAsteroids;

		int mPlayerLives;
		unsigned int mPoints;
		unsigned int mCurrentLevelIndex;
		std::string mPlayerName;
		std::vector<std::string> mLevelList;

		/* event handler class definitions */
		class LevelCompleteEventHandler : public Engine::EventListenerBase {
			public:
				explicit LevelCompleteEventHandler (Model *view) : mModel (view) {};
				virtual bool HandleEvent (const Engine::EventBasePtr &event) const {
					return mModel->OnLevelComplete();
				}
			private:
				LevelCompleteEventHandler() {};
				Model *mModel;
		};

		class GameOverEventHandler : public Engine::EventListenerBase {
			public:
				explicit GameOverEventHandler (Model *view) : mModel (view) {};
				virtual bool HandleEvent (const Engine::EventBasePtr &event) const {
					return mModel->OnGameOver();
				}
			private:
				GameOverEventHandler() {};
				Model *mModel;
		};

		/* event handler member variables */
		LevelCompleteEventHandler *mLevelCompleteEventHandler;
		GameOverEventHandler *mGameOverEventHandler;

	friend class View;
};

}

#endif // _MODEL_H