/*
   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 "DTreePlanter.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 "ScriptParser.h"
#include "misc.h"
#include "scenelib.h"



#include "funchandlers.h"

SignalHandlerResult DTreePlanter::mouseDown( const WindowVector& position, ButtonIdentifier button, ModifierFlags modifiers ){
	if ( button != c_buttonLeft ) {
		return SIGNAL_CONTINUE_EMISSION;
	}
	VIEWTYPE vt = GlobalRadiant().XYWindow_getViewType();

	switch ( vt ) {
	case XY:
		break;
	case YZ:
	case XZ:
	default:
		return SIGNAL_CONTINUE_EMISSION;
	}

	Vector3 pt, vhit;

	pt = vector3_snapped( GlobalRadiant().XYWindow_windowToWorld( position ), GlobalRadiant().getGridSize() );

	if ( FindDropPoint( vector3_to_array( pt ), vector3_to_array( vhit ) ) ) {
		vhit[2] += m_offset;

		char buffer[128];
		DEntity e( m_entType );

		sprintf( buffer, "%i %i %i", (int)vhit[0], (int)vhit[1], (int)vhit[2] );
		e.AddEPair( "origin", buffer );

		if ( m_autoLink ) {

			const scene::Path* pLastEntity = NULL;
			const scene::Path* pThisEntity = NULL;

			int entpos;
			for ( int i = 0; i < 256; i++ ) {
				sprintf( buffer, m_linkName, i );
				pThisEntity = FindEntityFromTargetname( buffer );

				if ( pThisEntity ) {
					entpos = i;
					pLastEntity = pThisEntity;
				}
			}

			if ( !pLastEntity ) {
				sprintf( buffer, m_linkName, 0 );
			}
			else {
				sprintf( buffer, m_linkName, entpos + 1 );
			}

			e.AddEPair( "targetname", buffer );

			if ( pLastEntity ) {
				DEntity e2;
				e2.LoadFromEntity( pLastEntity->top(), true );
				e2.AddEPair( "target", buffer );
				e2.RemoveFromRadiant();
				e2.BuildInRadiant( false );
			}

		}

		if ( m_setAngles ) {
			int angleYaw = ( rand() % ( m_maxYaw - m_minYaw + 1 ) ) + m_minYaw;
			int anglePitch = ( rand() % ( m_maxPitch - m_minPitch + 1 ) ) + m_minPitch;

			sprintf( buffer, "%i %i 0", anglePitch, angleYaw );
			e.AddEPair( "angles", buffer );
		}

		if ( m_numModels ) {
			int treetype = rand() % m_numModels;
			e.AddEPair( "model", m_trees[treetype].name );
		}

		if ( m_useScale ) {
			float scale = ( ( ( rand() % 1000 ) * 0.001f ) * ( m_maxScale - m_minScale ) ) + m_minScale;

			sprintf( buffer, "%f", scale );
			e.AddEPair( "modelscale", buffer );
		}

		e.BuildInRadiant( false );
	}

	if ( m_autoLink ) {
		DoTrainPathPlot();
	}

	return SIGNAL_STOP_EMISSION;
}

bool DTreePlanter::FindDropPoint( vec3_t in, vec3_t out ) {
	DPlane p1;
	DPlane p2;

	vec3_t vUp =        { 0, 0, 1 };
	vec3_t vForward =   { 0, 1, 0 };
	vec3_t vLeft =      { 1, 0, 0 };

	in[2] = 65535;

	VectorCopy( in, p1.points[0] );
	VectorCopy( in, p1.points[1] );
	VectorCopy( in, p1.points[2] );
	VectorMA( p1.points[1], 20, vUp,         p1.points[1] );
	VectorMA( p1.points[1], 20, vLeft,       p1.points[2] );

	VectorCopy( in, p2.points[0] );
	VectorCopy( in, p2.points[1] );
	VectorCopy( in, p2.points[2] );
	VectorMA( p1.points[1], 20, vUp,         p2.points[1] );
	VectorMA( p1.points[1], 20, vForward,    p2.points[2] );

	p1.Rebuild();
	p2.Rebuild();

	bool found = false;
	vec3_t temp;
	vec_t dist;
	int cnt = m_world.GetIDMax();
	for ( int i = 0; i < cnt; i++ ) {
		DBrush* pBrush = m_world.GetBrushForID( i );

		if ( pBrush->IntersectsWith( &p1, &p2, temp ) ) {
			vec3_t diff;
			vec_t tempdist;
			VectorSubtract( in, temp, diff );
			tempdist = VectorLength( diff );
			if ( !found || ( tempdist < dist ) ) {
				dist = tempdist;
				VectorCopy( temp, out );
				found  = true;
			}
		}
	}

	return found;
}

class TreePlanterDropEntityIfSelected
{
mutable DEntity ent;
DTreePlanter& planter;
public:
TreePlanterDropEntityIfSelected( DTreePlanter& planter ) : planter( planter ){
}
void operator()( scene::Instance& instance ) const {
	if ( !instance.isSelected() ) {
		return;
	}
	ent.LoadFromEntity( instance.path().top() );

	DEPair* pEpair = ent.FindEPairByKey( "origin" );
	if ( !pEpair ) {
		return;
	}

	vec3_t vec, out;
	sscanf( pEpair->value.GetBuffer(), "%f %f %f", &vec[0], &vec[1], &vec[2] );

	planter.FindDropPoint( vec, out );

	char buffer[256];
	sprintf( buffer, "%f %f %f", out[0], out[1], out[2] );
	ent.AddEPair( "origin", buffer );
	ent.RemoveFromRadiant();
	ent.BuildInRadiant( false );
}
};

void DTreePlanter::DropEntsToGround( void ) {
	Scene_forEachEntity( TreePlanterDropEntityIfSelected( *this ) );
}

void DTreePlanter::MakeChain( int linkNum, const char* linkName ) {
	char buffer[256];
	int i;
	for ( i = 0; i < linkNum; i++ ) {
		DEntity e( "info_train_spline_main" );

		sprintf( buffer, "%s_pt%i", linkName, i );
		e.AddEPair( "targetname", buffer );

		sprintf( buffer, "0 %i 0", i * 64 );
		e.AddEPair( "origin", buffer );

		if ( i != m_linkNum - 1 ) {
			sprintf( buffer, "%s_pt%i", linkName, i + 1 );
			e.AddEPair( "target", buffer );

			sprintf( buffer, "%s_ctl%i", linkName, i );
			e.AddEPair( "control", buffer );
		}
		e.BuildInRadiant( false );
	}

	for ( i = 0; i < linkNum - 1; i++ ) {
		DEntity e( "info_train_spline_control" );

		sprintf( buffer, "%s_ctl%i", linkName, i );
		e.AddEPair( "targetname", buffer );

		sprintf( buffer, "0 %i 0", ( i * 64 ) + 32 );
		e.AddEPair( "origin", buffer );

		e.BuildInRadiant( false );
	}
}

void DTreePlanter::SelectChain( void ) {
/*	char buffer[256];

    for(int i = 0; i < m_linkNum; i++) {
        DEntity e("info_train_spline_main");

        sprintf( buffer, "%s_pt%i", m_linkName, i );
        e.AddEPair( "targetname", buffer );

        sprintf( buffer, "0 %i 0", i * 64 );
        e.AddEPair( "origin", buffer );

        if(i != m_linkNum-1) {
            sprintf( buffer, "%s_pt%i", m_linkName, i+1 );
            e.AddEPair( "target", buffer );

            sprintf( buffer, "%s_ctl%i", m_linkName, i );
            e.AddEPair( "control", buffer );
        }

        e.BuildInRadiant( false );
    }

    for(int i = 0; i < m_linkNum-1; i++) {
        DEntity e("info_train_spline_control");

        sprintf( buffer, "%s_ctl%i", m_linkName, i );
        e.AddEPair( "targetname", buffer );

        sprintf( buffer, "0 %i 0", (i * 64) + 32);
        e.AddEPair( "origin", buffer );

        e.BuildInRadiant( false );
    }*/
}
