#ifndef CN_OBSTACLEMANAGER_H
#define CN_OBSTACLEMANAGER_H

#include "ComponentManagerBase.hpp"
#include "Obstacle.hpp"

namespace cn {

	class EntityManager;

	// --------------------------------------------------------------

	class ObstacleGroup {
	public:

		void updateBounds( );
		void testCollisions( ObstacleGroup &otherGroup, const Collider &collider );
		void addObstacle( Obstacle *o );
		void removeObstacle( Obstacle *o );

	private:

		typedef std::set<Obstacle *> ObstacleSet;
		ObstacleSet obstacles;
		rect boundingBox;

	};

	// --------------------------------------------------------------

	class ObstacleManager : public ComponentManagerBase<Obstacle> {
	public:

		ObstacleManager( EntityManager *entityManager );

		void updateByFrame( );

		void addObstacleToGroup( uint entityId );
		void removeObstacleFromGroup( uint entityId );

	private:

		CircleCollider defaultCollider;

		typedef std::multimap<ObstacleGroupId, ObstacleGroupId> GroupIdMap;
		typedef std::pair<GroupIdMap::iterator,GroupIdMap::iterator> GroupIdMapIteratorPair;
		typedef std::pair<ObstacleGroupId, ObstacleGroupId> GroupIdPair;
		GroupIdMap collisionTargets;

		typedef std::map<ObstacleGroupId, ObstacleGroup> GroupIdGroupMap;
		GroupIdGroupMap groups;

	};

}

#endif

#include "Prerequisites.hpp"
#include "ObstacleManager.hpp"
#include "Obstacle.hpp"
#include "EntityManager.hpp"

namespace cn {

	// --------------------------------------------------------------
	// ObstacleManager class
	// --------------------------------------------------------------

	ObstacleManager::ObstacleManager( EntityManager *entityManager ) 
		: ComponentManagerBase( entityManager ), defaultCollider( entityManager )
	{
		// Here the allowed collision targets for each id are defined.
		// Allies maps to Allies, Enemies and EnemyFire, etc.
		collisionTargets.insert( GroupIdPair( Allies, Allies ));
		collisionTargets.insert( GroupIdPair( Allies, Enemies ));
		collisionTargets.insert( GroupIdPair( Allies, EnemyFire ));
		collisionTargets.insert( GroupIdPair( Enemies, Enemies ));
		collisionTargets.insert( GroupIdPair( Enemies, Allies ));
		collisionTargets.insert( GroupIdPair( Enemies, AlliedFire ));
		collisionTargets.insert( GroupIdPair( AlliedFire, Enemies ));
		collisionTargets.insert( GroupIdPair( EnemyFire, Allies ));
	}

	// --------------------------------------------------------------

	void ObstacleManager::updateByFrame( ) {
		// Make the bounds up to date.
		// NOTE: However intermediate changes during collisions will not be caught.
		GroupIdGroupMap::iterator it;
		for ( it = groups.begin( ); it != groups.end( ); it++ ) {
			it->second.updateBounds( );
		}

		// A-loop: Iterate over all present groups.
		for ( it = groups.begin( ); it != groups.end( ); it++ ) {
			// Find which groups the current group responds to.
			GroupIdMapIteratorPair targetIds = collisionTargets.equal_range( it->first );
			// Proceed if the range is not empty.
			if ( targetIds.first != targetIds.second ) {
				// B-loop: Iterate over all groups at same position and after.
				GroupIdGroupMap::iterator jt;
				for ( jt = it; jt != groups.end( ); jt++ ) {
					// Proceed if A-element id responds to B-element id.
					GroupIdMap::iterator kt;
					for ( kt = targetIds.first; kt != targetIds.second; kt++ ) if ( kt->second == jt->first ) break;
					if ( kt != targetIds.second ) {
						// Now we know the two groups respond to each other.
						// TODO: Make a decision on the test order, f.ex. by greatest area or least count.
						it->second.testCollisions( jt->second, defaultCollider );
					}
				}
			}
		}
	}

	// --------------------------------------------------------------

	void ObstacleManager::addObstacleToGroup( uint entityId ) {
		groups[it->second->getGroupId( )].addObstacle( it->second );
	}
	
	// --------------------------------------------------------------

	void ObstacleManager::removeObstacleFromGroup( uint entityId ) {
		groups[it->second->getGroupId( )].removeObstacle( it->second );
	}

	// --------------------------------------------------------------
	// ObstacleGroup class
	// --------------------------------------------------------------

	void ObstacleGroup::updateBounds( ) {
		boundingBox = rect( 0, 0, 0, 0 );
		ObstacleSet::iterator it;
		for ( it = obstacles.begin( ); it != obstacles.end( ); it++ ) {
			(*it)->updateBoundingBox( );
			fit( boundingBox, (*it)->getBoundingBox( ));
		}
	}

	// --------------------------------------------------------------

	void ObstacleGroup::testCollisions( ObstacleGroup &otherGroup, const Collider &collider ) {
		PROFILE_FUNC( );
		// Check if groups intersect at all.
		if ( intersect( boundingBox, otherGroup.boundingBox )) {
			// Iterate over all local obstacles.
			ObstacleSet::iterator it;
			for ( it = obstacles.begin( ); it != obstacles.end( ); it++ ) {
				// Check if the current local obstacle intersects the other group.
				if ( intersect( (*it)->getBoundingBox( ), otherGroup.boundingBox )) {
					// Check against all in other group.
					ObstacleSet::iterator jt;
					for ( jt = otherGroup.obstacles.begin( ); jt != otherGroup.obstacles.end( ); jt++ ) {
						// Don't check against self.
						if ( (*it)->getId( ) != (*jt)->getId( )) {
							collider.apply( *it, *jt );
						}
					}
				}
			}
		}
	}

	// --------------------------------------------------------------

	void ObstacleGroup::addObstacle( Obstacle *o ) {
		obstacles.insert( o );
	}

	// --------------------------------------------------------------

	void ObstacleGroup::removeObstacle( Obstacle *o ) {
		obstacles.erase( o );
	}

}

#ifndef CN_OBSTACLE_H
#define CN_OBSTACLE_H

#include "ComponentManagerBase.hpp"
#include "ComponentBase.hpp"

namespace cn {

	class EntityData;
	class Obstacle;

	// This is the group id definition.
	enum ObstacleGroupId { Allies, Enemies, Neutrals, AlliedFire, EnemyFire, NeutralFire };

	// --------------------------------------------------------------

	class Obstacle : public ComponentBase {
	public:

		Obstacle( uint entityId, EntityData *entityData, const ComponentParameters<Obstacle> &params );

		uint getId( ) { return id; }
		const rect &getBoundingBox( ) { return boundingBox; }
		void updateBoundingBox( );
		ObstacleGroupId getGroupId( ) { return params.group; }

	private:

		// This object contains the group id for the obstacle.
		ComponentParameters<Obstacle> params;

		rect boundingBox;

	};

}

#endif

#include "Prerequisites.hpp"
#include "Obstacle.hpp"
#include "EntityData.hpp"

namespace cn {

	// --------------------------------------------------------------

	void Obstacle::updateBoundingBox( ) {
		// I didn't include the two functions below but they should be obvious.
		vec2 pos = getPos( );
		real radius = getRadius( );
		boundingBox.left = pos.x - radius;
		boundingBox.right = pos.x + radius;
		boundingBox.bottom = pos.y - radius;
		boundingBox.top = pos.y + radius;
	}

}