/*
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 );
	}*/
}
