package org.atriaSoft.gameEngine;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.atriaSoft.etk.math.Vector2f;
import org.atriaSoft.gale.backend3d.OpenGL;
import org.atriaSoft.gale.event.EventEntry;
import org.atriaSoft.gale.event.EventInput;
import org.atriaSoft.gale.event.EventTime;
import org.atriaSoft.gale.key.KeyKeyboard;
import org.atriaSoft.gale.key.KeySpecial;
import org.atriaSoft.gale.key.KeyStatus;
import org.atriaSoft.gale.key.KeyType;
import org.atriaSoft.gameEngine.camera.Camera;
import org.atriaSoft.gameEngine.engines.EngineRender;
import org.atriaSoft.gameEngine.engines.EngineAI;
import org.atriaSoft.gameEngine.engines.EngineLight;
import org.atriaSoft.gameEngine.engines.EngineParticle;
import org.atriaSoft.gameEngine.engines.EnginePhysics;
//import org.atriaSoft.gameEngine.resource.Mesh;

public class Environement {
	public Signal<Float> signalPlayTimeChange = new Signal<Float>();
	private GameStatus propertyStatus = GameStatus.gameStop; // !< the display is running (not in pause)
	public float propertyRatio = 1.0f; // !< Speed ratio
	protected List<Engine> engine = new ArrayList<Engine>(); // !< EGE sub engine interface (like physique, rendering,
																// audio, ...).
	private List<Entity> listEntity = new ArrayList<Entity>(); // !< List of all entity added in the Game
	List<ControlInterface> controls = new ArrayList<ControlInterface>();
	long lastCallTime = 0;
	
	// ! list of all camera in the world
	protected Map<String, Camera> listCamera = new HashMap<String, Camera>();
	protected long gameTime = 0; // !< time of the game running
	private long startTime;
	//protected List<Mesh> listMeshToDrawFirst = new ArrayList<Mesh>();

	public Environement() {
		// we add the 4 classical engines (the order is used to the global rendering cycle ...
		addEngine(new EnginePhysics(this));
		addEngine(new EngineAI(this));
		addEngine(new EngineRender(this));
		addEngine(new EngineParticle(this));
		addEngine(new EngineLight(this));
	}

	public void addControlInterface(ControlInterface ref) {
		controls.add(ref);
	}
	public void removeControlInterface(ControlInterface ref) {
		controls.remove(ref);
	}

	public void onPointer(KeySpecial special,
			KeyType type,
			int pointerID,
			Vector2f pos,
			KeyStatus state) {
		EventInput event = new EventInput(type, state, pointerID, pos, special);
		for (ControlInterface elem : controls) {
			elem.onEventInput(event, pos);
		}
	}
	public void onKeyboard( KeySpecial special,
			KeyKeyboard type,
			Character value,
			KeyStatus state) {
		EventEntry event = new EventEntry(special, type, state, value);
		for (ControlInterface elem : controls) {
			elem.onEventEntry(event);
		}
	}

	
	public void addEngine(Engine ref) {
		if (ref == null) {
			Log.error("try to add an empty Engine");
			return;
		}
		// check if not exist
		for (Engine it : engine) {
			if (it.getType().contains(ref.getType())) {
				it = ref;
				return;
			}
		}
		// add it at the end ...
		engine.add(ref);
	}

	public void rmEngine(Engine ref) {
		engine.remove(ref);
	}

	public void rmEngine(String type) {
		for (Engine it : engine) {
			if (it.getType().contains(type)) {
				engine.remove(it);
				return;
			}
		}
	}

	public Engine getEngine(String type) {
		for (Engine it : engine) {
			if (it.getType().contains(type)) {
				return it;
			}
		}
		Log.error("try to get an unexisting engine type: '" + type + "'");
		return null;
	}

	public void engineComponentRemove(Component ref) {
		for (Engine it: engine) {
			if (it.getType().contentEquals(ref.getType())) {
				it.componentRemove(ref);
				return;
			}
		}
	}

	public void engineComponentAdd(Component ref) {
		for (Engine it: engine) {
			if (it.getType().contentEquals(ref.getType())) {
				it.componentAdd(ref);
				return;
			}
		}
	}

	public void render(long deltaMilli, String cameraName) {
		// get the correct camera:
		Camera camera = getCamera(cameraName);
		if (camera == null) {
			Log.error("Render: Can not get camera named: '" + cameraName + "'");
			return;
		}
		OpenGL.setCameraMatrix(camera.getConvertionMatrix());
		for (Engine it: engine) {
			//Log.verbose("    render: " + it.getType());
			it.render(deltaMilli, camera);
		}
//		for (Engine it: engine) {
//			if(it == null) {
//				continue;
//			}
//			Log.verbose("    render: " + it.getType());
//			it.renderDebug(deltaMilli, camera);
//		}

	}

	/**
	 * @brief Add a camera in the camera pool.
	 * @param[in] name Name of the camera.
	 * @param[in] camera Pointer on the camera to add.
	 */
	public void addCamera(String name, Camera camera) {
		listCamera.put(name, camera);
	}

	/**
	 * @brief Get a specific camera.
	 * @param[in] name Name of the camera.
	 * @return A pointer on the camera requested.
	 */
	public Camera getCamera(String name) {
		return listCamera.get(name);
	}

	/**
	 * @brief Get List of all camera.
	 * @return All the camera registerred.
	 */
	public Map<String, Camera> getCameraList() {
		return listCamera;
	}

	/**
	 * @brief Remove all from the current environement
	 */
	public void clear() {
		listEntity.clear();
	}

	private static Map<String, CreatorEntity> creators = new HashMap<String, CreatorEntity>();

	/**
	 * @brief add a creator entity system
	 * @param[in] type Type of the entity.
	 * @param[in] creator Function pointer that reference the entity creating.
	 */
	public static void addCreator(String type, CreatorEntity creator) {
		if (creator == null) {
			Log.error("Try to add an empty CREATOR ...");
			return;
		}
		Log.debug("Add creator: " + type);
		creators.put(type, creator);
		Log.debug("Add creator: " + type + " (done)");

	}

	/**
	 * @brief Create an entity on the curent scene.
	 * @param[in] type Type of the entity that might be created.
	 * @param[in] description String that describe the content of the entity
	 *            properties.
	 * @param[in] autoAddEntity this permit to add the entity if it is created == >
	 *            no more action ...
	 * @return null if an error occured OR the pointer on the entity and it is
	 *         already added on the system.
	 * @note Pointer is return in case of setting properties on it...
	 */
	public Entity createEntity(String type, Object value, boolean autoAddEntity) {
		if (creators.containsKey(type) == false) {
			Log.error("Request creating of an type that is not known '" + type + "'");
			return null;
		}
		CreatorEntity creatorPointer = creators.get(type);
		if (creatorPointer == null) {
			Log.error("null pointer creator  == > internal error... '" + type + "'");
			return null;
		}
		Entity tmpEntity = creatorPointer.create(this, value);
		if (tmpEntity == null) {
			Log.error("allocation error '" + type + "'");
			return null;
		}
		if (autoAddEntity == true) {
			addEntity(tmpEntity);
		}
		return tmpEntity;

	}

	public Entity createEntity(String type, boolean autoAddEntity) {
		return this.createEntity(type, null, autoAddEntity);
	}

	/**
	 * @breif get a reference on the curent list of entity games
	 * @return all entity list
	 */
	public List<Entity> getEntity() {
		return listEntity;
	};

	/**
	 * @brief add an entity on the list availlable.
	 * @param[in] newEntity Entity to add.
	 */
	public void addEntity(Entity newEntity) {
		// prevent memory allocation and un allocation ...
		if (newEntity == null) {
			return;
		}
		listEntity.add(newEntity);
		newEntity.dynamicEnable();
	}

	/**
	 * @brief remove an entity on the list availlable.
	 * @param[in] removeEntity Entity to remove.
	 */
	public void rmEntity(Entity removeEntity) {
		if (removeEntity == null) {
			return;
		}
		for (int iii=0; iii<listEntity.size() ; iii++) {
			listEntity.get(iii).entityIsRemoved(removeEntity);
		}
		if (listEntity.remove(removeEntity) == true) {
			removeEntity.onDestroy();
			removeEntity.dynamicDisable();
			removeEntity.unInit();
		}
	}

	/**
	 * @brief generate an event on all the sub entity of the game == > usefull for
	 *        explosion, or lazer fire ...
	 * @param[in] event event that might be apply ...
	 */
	public void generateInteraction(EntityInteraction event) {
		// inform the entity that an entity has been removed  ==> this permit to keep pointer on entitys ...
		for (int iii=0; iii<listEntity.size() ; iii++) {
			event.applyEvent(listEntity.get(iii));
			/*
			Vector3f destPosition = mlistEntity[iii].getPosition();
			float dist = (sourcePosition - destPosition).length;
			if (dist == 0 || dist>decreasePower) {
				continue;
			}
			float inpact = (decreasePower-dist)/decreasePower * power;
			glistEntity[iii].setFireOn(groupIdSource, type, -inpact, sourcePosition);
			*/
		}

	}
//	private void onCallbackPeriodicCall(ewol::event::Time event) {
//	float curentDelta = event.getDeltaCall();
//	EGEVERBOSE("periodic call : " + event);
//	// small hack to change speed ...
//	curentDelta *= *propertyRatio;
//	// check if the processing is availlable
//	if (propertyStatus.get() == gameStop) {
//		return;
//	}
//	// update game time:
//	int lastGameTime = mgameTime*0.000001f;
//	mgameTime += curentDelta;
//	if (lastGameTime != (int)(mgameTime*0.000001f)) {
//		EGEVERBOSE("    Emit Signal");
//		signalPlayTimeChange.emit(mgameTime*0.000001f);
//	}
//	
//	//EWOLDEBUG("Time: mlastCallTime=" + mlastCallTime + " deltaTime=" + deltaTime);
//	
//	// update camera positions:
//	for (auto it : mlistCamera) {
//		if (it.second != null) {
//			EGEVERBOSE("    update camera : '" + it.first + "'");
//			it.second.periodicCall(curentDelta);
//		}
//	}
//	EGEVERBOSE("    step simulation : " + curentDelta);
//	for (auto it: mengine) {
//		if(it == null) {
//			continue;
//		}
//		EGEVERBOSE("    update: " + it.getType());
//		it.update(echrono::Duration(double(curentDelta)));
//	}
//	
//	//EGE.debug("stepSimulation (start)");
//	///step the simulation
//	// TODO : mphysicEngine.update(curentDelta);
//	// TODO : //optional but useful: debug drawing
//	// TODO : mphysicEngine.debugDrawWorld();
//	// TODO : EGEINFO("    Update particule engine");
//	// TODO : mparticuleEngine.update(curentDelta);
//	// remove all entity that requested it ...
//	/**
//	{
//		int numberEnnemyKilled=0;
//		int victoryPoint=0;
//		auto it(mlistEntity.begin());
//		while (it != mlistEntity.end()) {
//			if(*it != null) {
//				if ((*it).needToRemove() == true) {
//					if ((*it).getGroup() > 1) {
//						numberEnnemyKilled++;
//						victoryPoint++;
//					}
//					EGEINFO("[" + (*it).getUID() + "] entity Removing ... " + (*it).getType());
//					rmEntity((*it));
//					it = mlistEntity.begin();
//				} else {
//					++it;
//				}
//			} else {
//				++it;
//			}
//		}
//		if (numberEnnemyKilled != 0) {
//			//signalKillEnemy.emit(numberEnnemyKilled);
//		}
//	}
//	*/
//	}

//	public void addStaticMeshToDraw(Mesh mesh) {
//		listMeshToDrawFirst.add(mesh);
//	}
//
//	public List<Mesh> getStaticMeshToDraw() {
//		return listMeshToDrawFirst;
//	}

	public GameStatus getPropertyStatus() {
		return propertyStatus;
	}

	public void setPropertyStatus(GameStatus propertyStatus) {
		if (this.propertyStatus == propertyStatus) {
			return;
		}
		this.propertyStatus = propertyStatus;
//		if (propertyStatus == GameStatus.gameStart) {
//			mperiodicCallConnection = getObjectManager().periodicCall.connect(this, Environement::onCallbackPeriodicCall);
//		} else {
//			mperiodicCallConnection.disconnect();
//		}
	}

	public void periodicCall() {
		if (lastCallTime == 0 ) {
			startTime = System.nanoTime()/1000;
			lastCallTime = startTime;
		}
		long lastUpdate = lastCallTime;
		lastCallTime = System.nanoTime()/1000;
		EventTime event = new EventTime(lastCallTime, lastCallTime-startTime, lastCallTime-lastUpdate, lastCallTime-lastUpdate);
		for (ControlInterface elem : controls) {
			elem.periodicCall(event);
		}
	}
}

/*
 * void Environement::getEntityNearest( Vector3f sourcePosition, float
 * distanceMax, List<Environement::ResultNearestEntity> resultList) {
 * resultList.clear(); Environement::ResultNearestEntity result; result.dist =
 * 99999999999.0f; result.entity = null; for (int iii=0; iii<mlistEntity.size()
 * ; iii++) { // chack null pointer result.entity = mlistEntity[iii]; if
 * (result.entity == null) { continue; } // check distance ... Vector3f
 * destPosition = result.entity.getPosition(); if (sourcePosition ==
 * destPosition) { continue; } result.dist = (sourcePosition -
 * destPosition).length(); //EGE.debug("Distance : " + distance + " >? " +
 * distance + " id=" + iii); if (distanceMax>result.dist) {
 * resultList.pushBack(result); } } }
 * 
 * void Environement::getEntityNearestFixed( Vector3f sourcePosition, float
 * distanceMax, List<Environement::ResultNearestEntity> resultList) {
 * resultList.clear(); Environement::ResultNearestEntity result; result.dist =
 * 99999999999.0f; result.entity = null; for (int iii=0; iii<mlistEntity.size()
 * ; iii++) { // chack null pointer result.entity = mlistEntity[iii]; if
 * (result.entity == null) { continue; } if (result.entity.isFixed() == false)
 * { continue; } // check distance ... Vector3f destPosition =
 * result.entity.getPositionTheoric(); result.dist = (sourcePosition -
 * destPosition).length(); //EGE.debug("Distance : " + distance + " >? " +
 * distance + " id=" + iii); if (distanceMax <= result.dist) { continue; } //
 * try to add the entity at the best positions: int jjj; for (jjj=0;
 * jjj<resultList.size(); jjj++) { if (resultList[jjj].dist>result.dist) {
 * resultList.insert(resultList.begin()+jjj, result); break; } } // add entity
 * at the end : if (jjj >= resultList.size()) { resultList.pushBack(result); } }
 * }
 */