/*
   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 "StdAfx.h"

#include "funchandlers.h"

#include "IntersectDialog.h"
#include "PolygonDialog.h"
#include "StairDialog.h"
#include "DoorDialog.h"
#include "IntersectInfoDialog.h"
#include "BrushCheckDialog.h"
#include "AutoCaulkDialog.h"
#include "AutoCaulkStartDialog.h"
#include "TextureResetDialog.h"
#include "pathplotterdialog.h"

#include "DEntity.h"
#include "shapes.h"
#include "lists.h"
#include "misc.h"
#include "DShape.h"

// for autocaulk
std::list<Str> exclusionList;        // whole brush exclusion
std::list<Str> exclusionList_Face;   // single face exclusion

BOOL el1Loaded;
BOOL el2Loaded;

DBobView*   g_PathView = NULL;
// -------------

/************************
    Global Variables
************************/

CPolygonDialog polygonDlg;
CIntersectDialog intrDlg;
CStairDialog stairDlg;
CDoorDialog doorDlg;
CAutoCaulkStartDialog autocaulkDlg;
CTextureResetDialog texRstDlg;
CPathPlotterDialog ppDlg;

/************************
    --Main Functions--
************************/

void LoadLists(){
	char buffer[256];

	if ( !el1Loaded ) {
		el1Loaded = LoadExclusionList( GetFilename( buffer, "bt\\bt-el1.txt" ), &exclusionList );
	}
	if ( !el2Loaded ) {
		el2Loaded = LoadExclusionList( GetFilename( buffer, "bt\\bt-el2.txt" ), &exclusionList );
	}
}

void PolygonBuilder( vec3_t vMin, vec3_t vMax ){
	// ensure we have something selected
	if ( g_FuncTable.m_pfnSelectedBrushCount() != 1 ) {
		MessageBox( NULL, "Invalid number of brushes selected, chose 1 only", "Error", MB_OK );
		return;
	}

	// tell Radiant we want to access the selected brushes
	g_FuncTable.m_pfnAllocateSelectedBrushHandles();

	// get handle to size definition brush
	brush_t *brush = (brush_t*)g_FuncTable.m_pfnGetSelectedBrushHandle( 0 );
	// cant release until we delete the brush, if we do...

	// ask user for type, size, etc....
	if ( polygonDlg.DoModal() == IDOK ) {
		DShape poly;

		g_FuncTable.m_pfnDeleteBrushHandle( brush );

		if ( polygonDlg.m_bInverse ) {
			poly.BuildInversePrism( vMin, vMax, polygonDlg.m_nSideCount, polygonDlg.m_bAlignTop );
		}
		else
		{
			if ( polygonDlg.m_bBorder ) {
				poly.BuildBorderedPrism( vMin, vMax, polygonDlg.m_nSideCount, polygonDlg.m_nBorderSize, polygonDlg.m_bAlignTop );
			}
			else{
				poly.BuildRegularPrism( vMin, vMax, polygonDlg.m_nSideCount, polygonDlg.m_bAlignTop );
			}
		}

		poly.Commit();
	}


	g_FuncTable.m_pfnReleaseSelectedBrushHandles();
}


void IntersectionFinder(){
	if ( intrDlg.DoModal() == IDCANCEL ) {
		return;
	}

	if ( intrDlg.m_nBrushOptions == BRUSH_OPT_SELECTED ) {
		// ensure we have enough brushes selected
		if ( g_FuncTable.m_pfnSelectedBrushCount() < 2 ) {
			MessageBox( NULL, "Invalid number of brushes selected, choose at least 2", "Error", MB_OK );
			return;
		}
	}

	CIntersectInfoDialog*   intrInfoDlg = new CIntersectInfoDialog();
	intrInfoDlg->Create( IDD_INTERSECT_INFO_DIALOG );

	DEntity world;

	switch ( intrDlg.m_nBrushOptions )
	{
	case BRUSH_OPT_SELECTED:
	{
		world.LoadSelectedBrushes( &intrInfoDlg->m_prog1 );
		break;
	}
	case BRUSH_OPT_WHOLE_MAP:
	{
		world.LoadFromEntity( 0, &intrInfoDlg->m_prog1 );
		break;
	}
	}

	world.RemoveNonCheckBrushes( &exclusionList, intrDlg.m_bUseDetail );
	BOOL* pbSelectList;
	if ( intrDlg.m_bDuplicateOnly ) {
		pbSelectList = world.BuildDuplicateList();
	}
	else{
		pbSelectList = world.BuildIntersectList();
	}

	world.SelectBrushes( pbSelectList );

	intrInfoDlg->DestroyWindow();
	delete[] pbSelectList;
}

void StairBuilder( vec3_t vMin, vec3_t vMax ){
	// ensure we have something selected
	if ( g_FuncTable.m_pfnSelectedBrushCount() != 1 ) {
		MessageBox( NULL, "Invalid number of brushes selected, chose 1 only", "Error", MB_OK );
		return;
	}

	// tell Radiant we want to access the selected brushes
	g_FuncTable.m_pfnAllocateSelectedBrushHandles();

	// get handle to size definition brush
	brush_t *brush = (brush_t*)g_FuncTable.m_pfnGetSelectedBrushHandle( 0 );
	// cant release until we delete the brush, if we do...


	// ask user for type, size, etc....
	if ( stairDlg.DoModal() == IDOK ) {

		// calc brush size
		vec3_t size;
		_VectorSubtract( vMax, vMin, size );


		if ( ( (int)size[2] % stairDlg.m_nStairHeight ) != 0 ) {
			// stairs must fit evenly into brush
			MessageBox( NULL, "Invalid stair height\nHeight of block must be divisable by stair height", "Error", MB_OK );
		}
		else
		{

			// Remove Size Brush
			g_FuncTable.m_pfnDeleteBrushHandle( brush );


			// Get Step Count, Direction of Stairs, Stair Style
			int numSteps = (int)size[2] / stairDlg.m_nStairHeight;
			int direction = stairDlg.m_StairDir;
			int style = stairDlg.m_StairStyle;

			if ( stairDlg.m_StairStyle == STYLE_CORNER ) {
				BuildCornerStairs( vMin, vMax, numSteps, "textures/common/caulk", (LPCTSTR)stairDlg.m_riserTexture );
			}
			else
			{
				// Get Step Dimensions
				float stairHeight = (float)stairDlg.m_nStairHeight;
				float stairWidth;
				if ( ( direction == MOVE_EAST ) || ( direction == MOVE_WEST ) ) {
					stairWidth = ( size[0] ) / numSteps;
				}
				else{
					stairWidth = ( size[1] ) / numSteps;
				}


				// Build Base For Stair (bob's style)
				if ( style == STYLE_BOB ) {
					Build_Wedge( direction, vMin, vMax, TRUE );
				}


				// Set First Step Starting Position
				vMax[2] = vMin[2] + stairHeight;
				SetInitialStairPos( direction, vMin, vMax, stairWidth );


				// Build The Steps
				for ( int i = 0; i < numSteps; i++ )
				{
					if ( style == STYLE_BOB ) {
						Build_StairStep_Wedge( direction, vMin, vMax, "textures/common/caulk", (LPCTSTR)stairDlg.m_riserTexture, stairDlg.m_bDetail );
					}
					else if ( style == STYLE_ORIGINAL ) {
						Build_StairStep( vMin, vMax, "textures/common/caulk", (LPCTSTR)stairDlg.m_riserTexture, direction );
					}

					// get step into next position
					MoveBlock( direction, vMin, vMax, stairWidth );
					vMax[2] += stairHeight;
					if ( style == STYLE_BOB ) {
						vMin[2] += stairHeight; // wedge bottom must be raised
					}
				}
			}
		}
	}

	g_FuncTable.m_pfnReleaseSelectedBrushHandles();
}

void DoorBuilder( vec3_t vMin, vec3_t vMax ){
	// ensure we have something selected
	if ( g_FuncTable.m_pfnSelectedBrushCount() != 1 ) {
		MessageBox( NULL, "Invalid number of brushes selected, chose 1 only", "Error", MB_OK );
		return;
	}

	// tell Radiant we want to access the selected brushes
	g_FuncTable.m_pfnAllocateSelectedBrushHandles();

	// get handle to size definition brush
	brush_t *brush = (brush_t*)g_FuncTable.m_pfnGetSelectedBrushHandle( 0 );
	// cant release until we delete the brush, if we do...



	strcpy( doorDlg.m_fbTextureName.GetBuffer( 256 ), g_FuncTable.m_pfnGetCurrentTexture() );

	if ( doorDlg.DoModal() == IDOK ) {
		g_FuncTable.m_pfnDeleteBrushHandle( brush );

		BuildDoorsX2( vMin, vMax,
					  doorDlg.m_bSclMainHor, doorDlg.m_bSclMainVert,
					  doorDlg.m_bSclTrimHor, doorDlg.m_bSclTrimVert,
					  (LPCTSTR)doorDlg.m_fbTextureName,
					  (LPCTSTR)doorDlg.m_trimTextureName,
					  doorDlg.m_doorDirection );
	}

	g_FuncTable.m_pfnReleaseSelectedBrushHandles();
}

void FixBrushes(){
	DEntity world;

	CIntersectInfoDialog*   intrInfoDlg = new CIntersectInfoDialog();
	intrInfoDlg->Create( IDD_INTERSECT_INFO_DIALOG );

	world.LoadFromEntity( 0, &intrInfoDlg->m_prog1 );

	intrInfoDlg->DestroyWindow();

	CBrushCheckDialog*  chkDlg = new CBrushCheckDialog();
	chkDlg->Create( IDD_BRUSHCHECKER_DIALOG );

	int count = world.FixBrushes( TRUE, &chkDlg->m_prog1 );

	chkDlg->DestroyWindow();

	Sys_Printf( "%i invalid/duplicate planes removed\n", count );
}

void AutoCaulk(){
	if ( !el1Loaded ) {
		autocaulkDlg.m_Warning1 = "WARNING: Brush exclusion list not found\n, ALL BRUSHES WILL BE USED";
	}

	if ( autocaulkDlg.DoModal() == IDCANCEL ) {
		return;
	}

	if ( autocaulkDlg.m_nMode == MODE_AC_BUILD_MINI_PRT ) {
		BuildMiniPrt( &exclusionList );
		return;
	}

	CAutoCaulkDialog* acDlg = new CAutoCaulkDialog;
	acDlg->Create( IDD_AUTOCAULK_DIALOG );

	char filename[1204];

	if ( autocaulkDlg.m_nMode == MODE_AC_NORMAL ) {
		char* rad_filename = g_BSPTable.m_pfnGetMapName();
		if ( !rad_filename ) {
			MessageBox( NULL, "An Error Occurred While Trying To Get The Map Filename", "Error", MB_OK );
			acDlg->DestroyWindow();
			return;
		}

		strcpy( filename, rad_filename );

		char* ext = strrchr( filename, '.' ) + 1;
		strcpy( ext, "prt" ); // rename the extension
	}
	else
	{
		IEpair* pEp = g_EpairTable.m_pfnIEpairForProjectKeys();
		char *pn = pEp->ValueForKey( "mapspath" );
		pEp->DecRef();

		strcpy( filename, pn );
		strcat( filename, "/ac_prt.prt" );
	}

	DEntity portals;
	if ( !portals.LoadFromPrt( filename, &acDlg->m_prog1 ) ) {
		MessageBox( NULL, "Failed To Load Portal File", "Error", MB_OK );
		acDlg->DestroyWindow();
		return;
	}
	// load portal file

	CIntersectInfoDialog*   intrInfoDlg = new CIntersectInfoDialog();
	intrInfoDlg->Create( IDD_INTERSECT_INFO_DIALOG );

	DEntity world;

	world.LoadFromEntity( 0, &intrInfoDlg->m_prog1 );
	intrInfoDlg->DestroyWindow();

	if ( autocaulkDlg.m_nMode == MODE_AC_NORMAL ) {
		world.RemoveNonCheckBrushes( &exclusionList, FALSE );
	}
	else{
		world.RemoveNonCheckBrushes( &exclusionList, TRUE );
	}

	world.ResetChecks( &exclusionList_Face );

	int caulkedCount = 0;
	int killCnt = world.AutoCaulk( &portals, autocaulkDlg.m_bAllowDestruction, &caulkedCount, &acDlg->m_prog2 );

	if ( autocaulkDlg.m_bAllowDestruction ) {
		Sys_Printf( "%i unrequired brush(es) killed\n", killCnt );
	}
	Sys_Printf( "%i face(s) caulked\n", caulkedCount );

	acDlg->DestroyWindow();
}

void ResetTextures(){
	texRstDlg.m_TextureName = GetCurrentTexture();
	texRstDlg.m_NewTextureName = GetCurrentTexture();

	if ( texRstDlg.DoModal() == IDCANCEL ) {
		return;
	}

	float fScale[2];
	float fShift[2];
	fScale[1] = texRstDlg.m_fScaleVertical;
	fScale[0] = texRstDlg.m_fScaleHorizontal;

	fShift[1] = (float)texRstDlg.m_nShiftVertical;
	fShift[0] = (float)texRstDlg.m_nShiftHorizontal;

	DEntity world;
	world.LoadFromEntity( 0, NULL );

	if ( texRstDlg.m_bAllTextures ) {
		world.ResetTextures( NULL, fScale, fShift, texRstDlg.m_nRotation, texRstDlg.m_NewTextureName, texRstDlg.m_bOnlyTexture );
	}
	else{
		world.ResetTextures( texRstDlg.m_TextureName, fScale, fShift, texRstDlg.m_nRotation, texRstDlg.m_NewTextureName, texRstDlg.m_bOnlyTexture );
	}
}

void PathPlotter(){
	int ret = ppDlg.DoModal();
	if ( ret == IDCANCEL ) {
		return;
	}
	if ( ret == IDNO ) {
		if ( g_PathView ) {
			delete g_PathView;
		}

		return;
	}

	if ( g_FuncTable.m_pfnSelectedBrushCount() != 1 ) {
		MessageBox( NULL, "Invalid number of brushes selected, chose 1 only", "Error", MB_OK );
		return;
	}

	// tell Radiant we want to access the selected brushes
	g_FuncTable.m_pfnAllocateSelectedBrushHandles();

	// get handle to size definition brush
	brush_t *brush = (brush_t*)g_FuncTable.m_pfnGetSelectedBrushHandle( 0 );
	// cant release until we delete the brush, if we do...

	DEntity world;
	world.LoadEPairList( *g_FuncTable.m_pfnGetEntityKeyValList( brush->owner ) );

	DEPair* trigger_ep = world.FindEPairByKey( "targetname" );

	if ( trigger_ep ) {
		if ( !strcmp( world.m_Classname, "trigger_push" ) ) {
			DEPair* target_ep = world.FindEPairByKey( "target" );
			if ( target_ep ) {
				entity_s* entTarget = FindEntityFromTargetname( target_ep->value );
				if ( entTarget ) {
					if ( g_PathView ) {
						delete g_PathView;
					}
					g_PathView = new DBobView;

					g_PathView->Begin( trigger_ep->value, target_ep->value, ppDlg.m_fMultiplier, ppDlg.m_nPoints, ppDlg.m_fGravity, ppDlg.m_bNoUpdate, ppDlg.m_bShowExtra );
				}
				else{
					MessageBox( NULL, "trigger_push target could not be found.", "Error", MB_OK );
				}
			}
			else{
				MessageBox( NULL, "trigger_push has no target.", "Error", MB_OK );
			}
		}
		else{
			MessageBox( NULL, "You must select a 'trigger_push' entity.", "Error", MB_OK );
		}
	}
	else{
		MessageBox( NULL, "Entity must have a targetname", "Error", MB_OK );
	}

	g_FuncTable.m_pfnReleaseSelectedBrushHandles();
}

void PitBuilder( vec3_t vMin, vec3_t vMax ){
	// ensure we have something selected
	if ( g_FuncTable.m_pfnSelectedBrushCount() != 1 ) {
		MessageBox( NULL, "Invalid number of brushes selected, chose 1 only", "Error", MB_OK );
		return;
	}

	// tell Radiant we want to access the selected brushes
	g_FuncTable.m_pfnAllocateSelectedBrushHandles();

	// get handle to size definition brush
	brush_t *brush = (brush_t*)g_FuncTable.m_pfnGetSelectedBrushHandle( 0 );
	// cant release until we delete the brush, if we do...

	DShape pit;

	if ( pit.BuildPit( vMin, vMax ) ) {
		pit.Commit();

		g_FuncTable.m_pfnDeleteBrushHandle( brush );
	}
	else{
		MessageBox( NULL, "Failed To Make Pit\nTry Making The Brush Bigger", "Error", MB_OK );
	}

	g_FuncTable.m_pfnReleaseSelectedBrushHandles();
}