/*
   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_TARGETABLE_H )
#define INCLUDED_TARGETABLE_H

#include <set>
#include <map>

#include "cullable.h"
#include "renderable.h"

#include "math/line.h"
#include "render.h"
#include "generic/callback.h"
#include "selectionlib.h"
#include "entitylib.h"
#include "eclasslib.h"
#include "stringio.h"

class Targetable
{
public:
virtual const Vector3& world_position() const = 0;
};

typedef std::set<Targetable*> targetables_t;

extern const char* g_targetable_nameKey;

targetables_t* getTargetables( const char* targetname );

class EntityConnectionLine : public OpenGLRenderable
{
public:
Vector3 start;
Vector3 end;

void render( RenderStateFlags state ) const {
	float s1[2], s2[2];
	Vector3 dir( vector3_subtracted( end, start ) );
	double len = vector3_length( dir );
	vector3_scale( dir, 8.0 * ( 1.0 / len ) );
	s1[0] = dir[0] - dir[1];
	s1[1] = dir[0] + dir[1];
	s2[0] = dir[0] + dir[1];
	s2[1] = -dir[0] + dir[1];

	glBegin( GL_LINES );

	glVertex3fv( vector3_to_array( start ) );
	glVertex3fv( vector3_to_array( end ) );

	len *= 0.0625; // half / 8

	Vector3 arrow( start );
	for ( unsigned int i = 0, count = ( len < 32 ) ? 1 : static_cast<unsigned int>( len * 0.0625 ); i < count; i++ )
	{
		vector3_add( arrow, vector3_scaled( dir, ( len < 32 ) ? len : 32 ) );
		glVertex3fv( vector3_to_array( arrow ) );
		glVertex3f( arrow[0] + s1[0], arrow[1] + s1[1], arrow[2] + dir[2] );
		glVertex3fv( vector3_to_array( arrow ) );
		glVertex3f( arrow[0] + s2[0], arrow[1] + s2[1], arrow[2] + dir[2] );
	}

	glEnd();
}
};

class TargetedEntity
{
Targetable& m_targetable;
targetables_t* m_targets;

void construct(){
	if ( m_targets != 0 ) {
		m_targets->insert( &m_targetable );
	}
}
void destroy(){
	if ( m_targets != 0 ) {
		m_targets->erase( &m_targetable );
	}
}
public:
TargetedEntity( Targetable& targetable )
	: m_targetable( targetable ), m_targets( getTargetables( "" ) ){
	construct();
}
~TargetedEntity(){
	destroy();
}
void targetnameChanged( const char* name ){
	destroy();
	m_targets = getTargetables( name );
	construct();
}
typedef MemberCaller1<TargetedEntity, const char*, &TargetedEntity::targetnameChanged> TargetnameChangedCaller;
};


class TargetingEntity
{
targetables_t* m_targets;
public:
TargetingEntity() :
	m_targets( getTargetables( "" ) ){
}
void targetChanged( const char* target ){
	m_targets = getTargetables( target );
}
typedef MemberCaller1<TargetingEntity, const char*, &TargetingEntity::targetChanged> TargetChangedCaller;

typedef targetables_t::iterator iterator;

iterator begin() const {
	if ( m_targets == 0 ) {
		return iterator();
	}
	return m_targets->begin();
}
iterator end() const {
	if ( m_targets == 0 ) {
		return iterator();
	}
	return m_targets->end();
}
size_t size() const {
	if ( m_targets == 0 ) {
		return 0;
	}
	return m_targets->size();
}
bool empty() const {
	return m_targets == 0 || m_targets->empty();
}
};



template<typename Functor>
void TargetingEntity_forEach( const TargetingEntity& targets, const Functor& functor ){
	for ( TargetingEntity::iterator i = targets.begin(); i != targets.end(); ++i )
	{
		functor( ( *i )->world_position() );
	}
}

typedef std::map<std::size_t, TargetingEntity> TargetingEntities;

template<typename Functor>
void TargetingEntities_forEach( const TargetingEntities& targetingEntities, const Functor& functor ){
	for ( TargetingEntities::const_iterator i = targetingEntities.begin(); i != targetingEntities.end(); ++i )
	{
		TargetingEntity_forEach( ( *i ).second, functor );
	}
}

class TargetLinesPushBack
{
RenderablePointVector& m_targetLines;
const Vector3& m_worldPosition;
const VolumeTest& m_volume;
public:
TargetLinesPushBack( RenderablePointVector& targetLines, const Vector3& worldPosition, const VolumeTest& volume ) :
	m_targetLines( targetLines ), m_worldPosition( worldPosition ), m_volume( volume ){
}
void operator()( const Vector3& worldPosition ) const {
	if ( m_volume.TestLine( segment_for_startend( m_worldPosition, worldPosition ) ) ) {
		m_targetLines.push_back( PointVertex( reinterpret_cast<const Vertex3f&>( m_worldPosition ) ) );
		m_targetLines.push_back( PointVertex( reinterpret_cast<const Vertex3f&>( worldPosition ) ) );
	}
}
};

class TargetKeys : public Entity::Observer
{
TargetingEntities m_targetingEntities;
Callback m_targetsChanged;

bool readTargetKey( const char* key, std::size_t& index ){
	if ( string_equal_n( key, "target", 6 ) ) {
		index = 0;
		if ( string_empty( key + 6 ) || string_parse_size( key + 6, index ) ) {
			return true;
		}
	}
	if ( string_equal( key, "killtarget" ) ) {
		index = -1;
		return true;
	}
	return false;
}
public:
void setTargetsChanged( const Callback& targetsChanged ){
	m_targetsChanged = targetsChanged;
}
void targetsChanged(){
	m_targetsChanged();
}

void insert( const char* key, EntityKeyValue& value ){
	std::size_t index;
	if ( readTargetKey( key, index ) ) {
		TargetingEntities::iterator i = m_targetingEntities.insert( TargetingEntities::value_type( index, TargetingEntity() ) ).first;
		value.attach( TargetingEntity::TargetChangedCaller( ( *i ).second ) );
		targetsChanged();
	}
}
void erase( const char* key, EntityKeyValue& value ){
	std::size_t index;
	if ( readTargetKey( key, index ) ) {
		TargetingEntities::iterator i = m_targetingEntities.find( index );
		value.detach( TargetingEntity::TargetChangedCaller( ( *i ).second ) );
		m_targetingEntities.erase( i );
		targetsChanged();
	}
}
const TargetingEntities& get() const {
	return m_targetingEntities;
}
};



class RenderableTargetingEntity
{
TargetingEntity& m_targets;
mutable RenderablePointVector m_target_lines;
public:
static Shader* m_state;

RenderableTargetingEntity( TargetingEntity& targets )
	: m_targets( targets ), m_target_lines( GL_LINES ){
}
void compile( const VolumeTest& volume, const Vector3& world_position ) const {
	m_target_lines.clear();
	m_target_lines.reserve( m_targets.size() * 2 );
	TargetingEntity_forEach( m_targets, TargetLinesPushBack( m_target_lines, world_position, volume ) );
}
void render( Renderer& renderer, const VolumeTest& volume, const Vector3& world_position ) const {
	if ( !m_targets.empty() ) {
		compile( volume, world_position );
		if ( !m_target_lines.empty() ) {
			renderer.addRenderable( m_target_lines, g_matrix4_identity );
		}
	}
}
};

class RenderableTargetingEntities
{
const TargetingEntities& m_targets;
mutable RenderablePointVector m_target_lines;
public:
static Shader* m_state;

RenderableTargetingEntities( const TargetingEntities& targets )
	: m_targets( targets ), m_target_lines( GL_LINES ){
}
void compile( const VolumeTest& volume, const Vector3& world_position ) const {
	m_target_lines.clear();
	TargetingEntities_forEach( m_targets, TargetLinesPushBack( m_target_lines, world_position, volume ) );
}
void render( Renderer& renderer, const VolumeTest& volume, const Vector3& world_position ) const {
	if ( !m_targets.empty() ) {
		compile( volume, world_position );
		if ( !m_target_lines.empty() ) {
			renderer.addRenderable( m_target_lines, g_matrix4_identity );
		}
	}
}
};


class TargetableInstance :
	public SelectableInstance,
	public Targetable,
	public Entity::Observer
{
mutable Vertex3f m_position;
EntityKeyValues& m_entity;
TargetKeys m_targeting;
TargetedEntity m_targeted;
RenderableTargetingEntities m_renderable;
public:

TargetableInstance(
	const scene::Path& path,
	scene::Instance* parent,
	void* instance,
	InstanceTypeCastTable& casts,
	EntityKeyValues& entity,
	Targetable& targetable
	) :
	SelectableInstance( path, parent, instance, casts ),
	m_entity( entity ),
	m_targeted( targetable ),
	m_renderable( m_targeting.get() ){
	m_entity.attach( *this );
	m_entity.attach( m_targeting );
}
~TargetableInstance(){
	m_entity.detach( m_targeting );
	m_entity.detach( *this );
}

void setTargetsChanged( const Callback& targetsChanged ){
	m_targeting.setTargetsChanged( targetsChanged );
}
void targetsChanged(){
	m_targeting.targetsChanged();
}

void insert( const char* key, EntityKeyValue& value ){
	if ( string_equal( key, g_targetable_nameKey ) ) {
		value.attach( TargetedEntity::TargetnameChangedCaller( m_targeted ) );
	}
}
void erase( const char* key, EntityKeyValue& value ){
	if ( string_equal( key, g_targetable_nameKey ) ) {
		value.detach( TargetedEntity::TargetnameChangedCaller( m_targeted ) );
	}
}

const Vector3& world_position() const {
#if 1
	const AABB& bounds = Instance::worldAABB();
	if ( aabb_valid( bounds ) ) {
		return bounds.origin;
	}
#else
	const AABB& childBounds = Instance::childBounds();
	if ( aabb_valid( childBounds ) ) {
		return childBounds.origin;
	}
#endif
	return vector4_to_vector3( localToWorld().t() );
}

void render( Renderer& renderer, const VolumeTest& volume ) const {
	renderer.SetState( m_entity.getEntityClass().m_state_wire, Renderer::eWireframeOnly );
	renderer.SetState( m_entity.getEntityClass().m_state_wire, Renderer::eFullMaterials );
	m_renderable.render( renderer, volume, world_position() );
}

const TargetingEntities& getTargeting() const {
	return m_targeting.get();
}
};


class RenderableConnectionLines : public Renderable
{
typedef std::set<TargetableInstance*> TargetableInstances;
TargetableInstances m_instances;
public:
void attach( TargetableInstance& instance ){
	ASSERT_MESSAGE( m_instances.find( &instance ) == m_instances.end(), "cannot attach instance" );
	m_instances.insert( &instance );
}
void detach( TargetableInstance& instance ){
	ASSERT_MESSAGE( m_instances.find( &instance ) != m_instances.end(), "cannot detach instance" );
	m_instances.erase( &instance );
}

void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
	for ( TargetableInstances::const_iterator i = m_instances.begin(); i != m_instances.end(); ++i )
	{
		if ( ( *i )->path().top().get().visible() ) {
			( *i )->render( renderer, volume );
		}
	}
}
void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
	renderSolid( renderer, volume );
}
};

typedef Static<RenderableConnectionLines> StaticRenderableConnectionLines;

#endif