/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined ( INCLUDED_INSTANCELIB_H )
#define INCLUDED_INSTANCELIB_H

#include "debugging/debugging.h"

#include "iscenegraph.h"

#include "scenelib.h"
#include "generic/reference.h"
#include "generic/callback.h"
#include <map>

class InstanceSubgraphWalker : public scene::Traversable::Walker
{
scene::Instantiable::Observer* m_observer;
mutable scene::Path m_path;
mutable Stack<scene::Instance*> m_parent;
public:
InstanceSubgraphWalker( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* parent )
	: m_observer( observer ), m_path( path ), m_parent( parent ){
}
bool pre( scene::Node& node ) const {
	m_path.push( makeReference( node ) );
	scene::Instance* instance = Node_getInstantiable( node )->create( m_path, m_parent.top() );
	m_observer->insert( instance );
	Node_getInstantiable( node )->insert( m_observer, m_path, instance );
	m_parent.push( instance );
	return true;
}
void post( scene::Node& node ) const {
	m_path.pop();
	m_parent.pop();
}
};

class UninstanceSubgraphWalker : public scene::Traversable::Walker
{
scene::Instantiable::Observer* m_observer;
mutable scene::Path m_path;
public:
UninstanceSubgraphWalker( scene::Instantiable::Observer* observer, const scene::Path& parent )
	: m_observer( observer ), m_path( parent ){
}
bool pre( scene::Node& node ) const {
	m_path.push( makeReference( node ) );
	return true;
}
void post( scene::Node& node ) const {
	scene::Instance* instance = Node_getInstantiable( node )->erase( m_observer, m_path );
	m_observer->erase( instance );
	delete instance;
	m_path.pop();
}
};

class InstanceSet : public scene::Traversable::Observer
{
typedef std::pair<scene::Instantiable::Observer*, PathConstReference> CachePath;

typedef CachePath key_type;

typedef std::map<key_type, scene::Instance*> InstanceMap;
InstanceMap m_instances;
public:

typedef InstanceMap::iterator iterator;

iterator begin(){
	return m_instances.begin();
}
iterator end(){
	return m_instances.end();
}

// traverse observer
void insert( scene::Node& child ){
	for ( iterator i = begin(); i != end(); ++i )
	{
		Node_traverseSubgraph( child, InstanceSubgraphWalker( ( *i ).first.first, ( *i ).first.second, ( *i ).second ) );
		( *i ).second->boundsChanged();
	}
}
void erase( scene::Node& child ){
	for ( iterator i = begin(); i != end(); ++i )
	{
		Node_traverseSubgraph( child, UninstanceSubgraphWalker( ( *i ).first.first, ( *i ).first.second ) );
		( *i ).second->boundsChanged();
	}
}

// instance
void forEachInstance( const scene::Instantiable::Visitor& visitor ){
	for ( iterator i = begin(); i != end(); ++i )
	{
		visitor.visit( *( *i ).second );
	}
}

void insert( scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance ){
	ASSERT_MESSAGE( m_instances.find( key_type( observer, PathConstReference( instance->path() ) ) ) == m_instances.end(), "InstanceSet::insert - element already exists" );
	m_instances.insert( InstanceMap::value_type( key_type( observer, PathConstReference( instance->path() ) ), instance ) );
}
scene::Instance* erase( scene::Instantiable::Observer* observer, const scene::Path& path ){
	ASSERT_MESSAGE( m_instances.find( key_type( observer, PathConstReference( path ) ) ) != m_instances.end(), "InstanceSet::erase - failed to find element" );
	InstanceMap::iterator i = m_instances.find( key_type( observer, PathConstReference( path ) ) );
	scene::Instance* instance = i->second;
	m_instances.erase( i );
	return instance;
}

void transformChanged(){
	for ( InstanceMap::iterator i = m_instances.begin(); i != m_instances.end(); ++i )
	{
		( *i ).second->transformChanged();
	}
}
typedef MemberCaller<InstanceSet, &InstanceSet::transformChanged> TransformChangedCaller;
void boundsChanged(){
	for ( InstanceMap::iterator i = m_instances.begin(); i != m_instances.end(); ++i )
	{
		( *i ).second->boundsChanged();
	}
}
typedef MemberCaller<InstanceSet, &InstanceSet::boundsChanged> BoundsChangedCaller;
};

template<typename Functor>
inline void InstanceSet_forEach( InstanceSet& instances, const Functor& functor ){
	for ( InstanceSet::iterator i = instances.begin(), end = instances.end(); i != end; ++i )
	{
		functor( *( *i ).second );
	}
}

template<typename Type>
class InstanceEvaluateTransform
{
public:
inline void operator()( scene::Instance& instance ) const {
	InstanceTypeCast<Type>::cast( instance )->evaluateTransform();
}
};

template<typename Type>
class InstanceSetEvaluateTransform
{
public:
static void apply( InstanceSet& instances ){
	InstanceSet_forEach( instances, InstanceEvaluateTransform<Type>() );
}
typedef ReferenceCaller<InstanceSet, &InstanceSetEvaluateTransform<Type>::apply> Caller;
};

#endif