/*
   BobToolz plugin for GtkRadiant
   Copyright (C) 2001 Gordon Biggans

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

   This library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "DTrainDrawer.h"

#include <list>
#include "str.h"

#include "DPoint.h"
#include "DPlane.h"
#include "DBrush.h"
#include "DEPair.h"
#include "DPatch.h"
#include "DEntity.h"

#include "misc.h"
#include "funchandlers.h"

#include "iglrender.h"
#include "ientity.h"
#include "math/matrix.h"

#include "dialogs/dialogs-gtk.h"

DTrainDrawer::DTrainDrawer() {
	m_bDisplay = false;

	BuildPaths();
	constructShaders();
	GlobalShaderCache().attachRenderable( *this );
}

DTrainDrawer::~DTrainDrawer( void ) {
	GlobalShaderCache().detachRenderable( *this );
	destroyShaders();

	ClearPoints();
	ClearSplines();
}

void DTrainDrawer::ClearSplines() {
	for ( std::list<splinePoint_t *>::const_iterator deadSpline = m_splineList.begin(); deadSpline != m_splineList.end(); deadSpline++ ) {
		( *deadSpline )->m_pointList.clear();
		( *deadSpline )->m_vertexList.clear();
		delete ( *deadSpline );
	}

	m_splineList.clear();
}

void DTrainDrawer::ClearPoints() {
	for ( std::list<controlPoint_t *>::const_iterator deadPoint = m_pointList.begin(); deadPoint != m_pointList.end(); deadPoint++ ) {
		delete *deadPoint;
	}

	m_pointList.clear();
}

void CalculateSpline_r( vec3_t* v, int count, vec3_t out, float tension ) {
	vec3_t dist;

	if ( count < 2 ) {
		return;
	}

	if ( count == 2 ) {
		VectorSubtract( v[1], v[0], dist );
		VectorMA( v[0], tension, dist, out );
		return;
	}

	vec3_t* v2 = new vec3_t[count - 1];

	for ( int i = 0; i < count - 1; i++ ) {
		VectorSubtract( v[i + 1], v[i], dist );
		VectorMA( v[i], tension, dist, v2[i] );
	}

	CalculateSpline_r( v2, count - 1, out, tension );

	delete[] v2;
}

void DTrainDrawer::render( RenderStateFlags state ) const {
	for ( std::list<splinePoint_t* >::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
		splinePoint_t* pSP = ( *sp );

		glBegin( GL_LINE_STRIP );
		for ( std::list<DPoint >::const_iterator v = pSP->m_vertexList.begin(); v != pSP->m_vertexList.end(); v++ ) {
			glVertex3fv( ( *v )._pnt );
		}
		glEnd();

	}
}

const char* DTrainDrawer_state_wireframe = "$bobtoolz/traindrawer/wireframe";
const char* DTrainDrawer_state_solid = "$bobtoolz/traindrawer/solid";

void DTrainDrawer::constructShaders(){
	OpenGLState state;
	GlobalOpenGLStateLibrary().getDefaultState( state );
	state.m_state = RENDER_COLOURWRITE | RENDER_DEPTHWRITE | RENDER_BLEND;
	state.m_sort = OpenGLState::eSortOverlayFirst;
	state.m_linewidth = 1;
	state.m_colour[0] = 1;
	state.m_colour[1] = 0;
	state.m_colour[2] = 0;
	state.m_colour[3] = 1;
	state.m_linewidth = 1;
	GlobalOpenGLStateLibrary().insert( DTrainDrawer_state_wireframe, state );

	state.m_colour[0] = 1;
	state.m_colour[1] = 1;
	state.m_colour[2] = 1;
	state.m_colour[3] = 1;
	state.m_linewidth = 2;
	GlobalOpenGLStateLibrary().insert( DTrainDrawer_state_solid, state );

	m_shader_wireframe = GlobalShaderCache().capture( DTrainDrawer_state_wireframe );
	m_shader_solid = GlobalShaderCache().capture( DTrainDrawer_state_solid );
}

void DTrainDrawer::destroyShaders(){
	GlobalOpenGLStateLibrary().erase( DTrainDrawer_state_wireframe );
	GlobalOpenGLStateLibrary().erase( DTrainDrawer_state_solid );
	GlobalShaderCache().release( DTrainDrawer_state_wireframe );
	GlobalShaderCache().release( DTrainDrawer_state_solid );
}


void DTrainDrawer::renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
	if ( !m_bDisplay ) {
		return;
	}

	renderer.SetState( m_shader_wireframe, Renderer::eWireframeOnly );
	renderer.SetState( m_shader_solid, Renderer::eFullMaterials );
	renderer.addRenderable( *this, g_matrix4_identity );
}
void DTrainDrawer::renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
	renderSolid( renderer, volume );
}

void AddSplineControl( const char* control, splinePoint_t* pSP ) {
	controlPoint_t cp;
	strncpy( cp.strName, control, 64 );

	pSP->m_pointList.push_front( cp );
}

class EntityBuildPaths
{
mutable DEntity e;
DTrainDrawer& drawer;
public:
EntityBuildPaths( DTrainDrawer& drawer ) : drawer( drawer ){
}
void operator()( scene::Instance& instance ) const {
	e.ClearEPairs();
	e.LoadEPairList( Node_getEntity( instance.path().top() ) );

	const char* classname = e.m_Classname.GetBuffer();
	const char* target;
	const char* control;
	const char* targetname;
	vec3_t vOrigin;

	e.SpawnString( "targetname", NULL, &targetname );
	e.SpawnVector( "origin", "0 0 0", vOrigin );

	if ( !strcmp( classname, "info_train_spline_main" ) ) {
		if ( !targetname ) {
			globalOutputStream() << "info_train_spline_main with no targetname";
			return;
		}

		e.SpawnString( "target", NULL, &target );

		if ( !target ) {
			drawer.AddControlPoint( targetname, vOrigin );
		}
		else {
			splinePoint_t* pSP = drawer.AddSplinePoint( targetname, target, vOrigin );

			e.SpawnString( "control", NULL, &control );

			if ( control ) {
				AddSplineControl( control, pSP );

				for ( int j = 2;; j++ ) {
					char buffer[16];
					sprintf( buffer, "control%i", j );

					e.SpawnString( buffer, NULL, &control );
					if ( !control ) {
						break;
					}

					AddSplineControl( control, pSP );
				}
			}
		}
	}
	else if ( !strcmp( classname, "info_train_spline_control" ) ) {
		if ( !targetname ) {
			globalOutputStream() << "info_train_spline_control with no targetname";
			return;
		}

		drawer.AddControlPoint( targetname, vOrigin );
	}
}
};

void DTrainDrawer::BuildPaths() {
	Scene_forEachEntity( EntityBuildPaths( *this ) );

	std::list<splinePoint_t* >::const_iterator sp;
	for ( sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
		splinePoint_t* pSP = ( *sp );

		controlPoint_t* pTarget = FindControlPoint( pSP->strTarget );

		if ( !pTarget ) {
			globalOutputStream() << "couldn't find target " << pSP->strTarget;
			return;
//			continue;
		}

		pSP->pTarget = pTarget;


		for ( std::list<controlPoint_t >::iterator cp = pSP->m_pointList.begin(); cp != pSP->m_pointList.end(); cp++ ) {
			controlPoint_t* pControl = FindControlPoint( ( *cp ).strName );
			if ( !pControl ) {
				globalOutputStream() << "couldn't find control " << ( *cp ).strName;
				return;
			}

			VectorCopy( pControl->vOrigin, ( *cp ).vOrigin );
		}
	}

	m_bDisplay = true;

	for ( sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
		splinePoint_t* pSP = ( *sp );
		DPoint out;

		if ( !pSP->pTarget ) {
			continue;
		}

		std::size_t count = pSP->m_pointList.size() + 2;
		vec3_t* v = new vec3_t[count];

		VectorCopy( pSP->point.vOrigin, v[0] );

		int i = 1;
		for ( std::list<controlPoint_t>::reverse_iterator cp = pSP->m_pointList.rbegin(); cp != pSP->m_pointList.rend(); cp++ ) {
			VectorCopy( ( *cp ).vOrigin, v[i] );
			i++;
		}
		VectorCopy( pSP->pTarget->vOrigin, v[i] );

		for ( float tension = 0.0f; tension <= 1.f; tension += 0.01f ) {
			CalculateSpline_r( v, static_cast<int>( count ), out._pnt, tension );
			pSP->m_vertexList.push_front( out );
		}

		delete[] v;

		VectorCopy( pSP->pTarget->vOrigin, out._pnt );
		pSP->m_vertexList.push_front( out );
	}

	SceneChangeNotify();
}

void DTrainDrawer::AddControlPoint( const char* name, vec_t* origin ){
	controlPoint_t* pCP = new controlPoint_t;

	strncpy( pCP->strName, name, 64 );
	VectorCopy( origin, pCP->vOrigin );

	m_pointList.push_back( pCP );
}

splinePoint_t* DTrainDrawer::AddSplinePoint( const char* name, const char* target, vec_t* origin ){
	splinePoint_t* pSP = new splinePoint_t;

	strncpy( pSP->point.strName, name,       64 );
	strncpy( pSP->strTarget,     target,     64 );
	VectorCopy( origin, pSP->point.vOrigin );
	m_splineList.push_back( pSP );

	return pSP;
}

controlPoint_t* DTrainDrawer::FindControlPoint( const char* name ){
	for ( std::list<controlPoint_t*>::const_iterator cp = m_pointList.begin(); cp != m_pointList.end(); cp++ ) {
		if ( !strcmp( name, ( *cp )->strName ) ) {
			return ( *cp );
		}
	}

	for ( std::list<splinePoint_t*>::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
		if ( !strcmp( name, ( *sp )->point.strName ) ) {
			return &( ( *sp )->point );
		}
	}

	return NULL;
}