/****************************************************************************************

							MENU .c

	Used in the 1999 version of Courtside 2


****************************************************************************************/

#include "menu.h"
#include "ctrl.h"
#include "define.h"
#include "render.h"
#include "ml.h"
#include "fontcode.h"
#include "shell.h"
//#include "shellgfx.h"
#include "states.h"
#include "audio.h"
#include "unstuff.h"
#include "sub.h"
//#include "popup.h"

#include "file.h"
#include "generic.h"
#include "define.h"
#include "stats.h"
#include "shell.h"

#include "camera.h"
#include "cammodes.h"

#include "misc.h"

#include "gamefx.h"

extern u8
	*GameBank;


extern u32
	ReplayButtons,
	ReplayTextTimer;

extern int
	inFreeThrow;

int HintCtr;
int menuFlag;
int	menuChoice,menuChoices;
int	moveDir,moveTime;
int menuScoreboardFlag=0;

extern int 		SubCard,CardCtr;

u8
	MenuWhich,
	ReallyQuit;

global int	menu_controller;

//int BuildNextHint(int dir);

static int	menu_time;

int		pauseTeam,timeOutAllowed,inTimeOut;

extern int gameOver;
extern int timeOutAllowed;

char	pauseSelectable[MAX_PAUSE_MENU_CHOICES];


// new 6/1/99 - separate menu access to shell stuff cuz player gfx are
		// dumped when going to shell and reloaded (takes a while) when leaving shell

char *pauseMenuStrings[MAX_PAUSE_MENU_CHOICES]=
{
    "Call Time-Out",
    "Substitutions",
    "Instant Replay",
    "Camera Options",
    "Scoreboard",
	"Team Settings",
//	"Game Hints",
    "Quit Game",

	"Secret Room",
};



char *PracticeMenuStrings[NUM_PRACTICE_MENU_OPTIONS]=
{
//    "Call Time-Out",
    "Substitutions",
    "Instant Replay",
    "Camera Options",
//    "Scoreboard",
	"Team Settings",
	"Game Hints",
    "Quit Practice",
};

int PracticeMenuOptionMapping[NUM_PRACTICE_MENU_OPTIONS] = 
{
	PAUSE_MENU_SUBSTITUTIONS,		
	PAUSE_MENU_REPLAY,
	PAUSE_MENU_CAMERA_OPTIONS,
	PAUSE_MENU_SHELL_MENU,
	PAUSE_MENU_GAME_HINT,
	PAUSE_MENU_QUIT_GAME,
};


void InitMenu(void){}


#define PAUSE_MENU_Y_START	5
#define PAUSE_MENU_X_START	20

Gfx  *MsgRender(Gfx *gp,char *s,int y,dyn *d)
{
	return 0;
}
void SubAnnounce(int team)
{
}




void CheckForTimeOutAllowed(int team)
{
				if(team==bhp->team && possession_flag)
					if (GetNumberTimeOutsRemaining(team))
						if (!timeout_called)
							if (time_left && shot_clock)
								if (!((ft_flag||free_throws)&&!possession_flag))
									if (TIMEOUT_ALLOWED(team))
										if (!inTimeOut)
											timeOutAllowed=1;

}


void InitShellPausedTeamParameters(void)	// also called if controllers switched during pause
{
	timeOutAllowed=0;

	if (pcl__gMatch->asb__mPads[menu_controller] < 2)	// home or away (2 == CPU)
	{	
		// did old team have locked player????
		if(pcl__gMatch->asb__mPads[menu_controller] != pauseTeam)
		{	// fixes bug inverse of #259 (human manipulating a CPU team)
			ControllerLockOnPlayer[menu_controller] = -1;
		}	

		pauseTeam = pcl__gMatch->asb__mPads[menu_controller]; // home or away

		CheckForTimeOutAllowed(pauseTeam);

	}
	else
	{		// edit home team if CPU vs. CPU
		pauseTeam = 0;
		// below doesn't hurt if normal(non-PAUSED) shell
		ControllerLockOnPlayer[menu_controller] = -1;	

	}

	pcl__gMatch->sb___mEditing = pauseTeam;
}


void StartShellMenu(int newshellstate)
{

	si___gNxtState = newshellstate;
//	shellDelay=2;
	
	InitShellPausedTeamParameters();

	Gfx_Wait();
	FreeDumpGfx();
}



/*-----------------------------------------------------------------------------*/




static void ProcessCameraMenu( int buttons, int tapped )
{
int savecam;

	switch (menuChoice)
	{
		case 0:			// Camera mode.
			if (tapped & CTRL_PAD_LEFT)
			{
				camMode=(camMode+(CAM_NUMUSERMODES)-1) % (CAM_NUMUSERMODES);
				Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );
			}
			else if (tapped & CTRL_PAD_RIGHT)
			{
				camMode = (camMode+1) % (CAM_NUMUSERMODES);
				Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );
			}
			break;

		case 1:			// Zoom level.
			savecam = camZoomUser;		
			if (buttons & CTRL_PAD_LEFT)
			{
				camZoomUser-=4;
				if(camZoomUser<0)
				{
					camZoomUser=0;
				}
				else
				{
//					Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );
				}
			}
			else if (buttons & CTRL_PAD_RIGHT)
			{
				camZoomUser+=4;
				if(camZoomUser>200)
				{
					camZoomUser=200;
				}
				else
				{
//					Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );
				}

			}
			
			if( (savecam != camZoomUser) && (tapped & (CTRL_PAD_RIGHT | CTRL_PAD_LEFT)) )
			{	// don't play sound too often
				Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );
			}

			break;
	}
}


static void ProcessQuitMenu( int tapped )
{
	if (tapped & (CTRL_PAD_LEFT | CTRL_PAD_RIGHT))
	{
		ReallyQuit = !ReallyQuit;
		Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );

	}
	
	else if (tapped & CTRL_FIRE_A)
	{
		if (ReallyQuit)
		{
			pcl__gMatch->sb___mQuarter=-1;	// signal player quit
			SubCard = CardCtr = 0;	// fixes bug #983???
			gameOver = TRUE;
		}
		Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );

		EndMenu( menu_controller );
		PauseAll( FALSE );
	}

	else if (tapped & CTRL_FIRE_B)
	{
		Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );

		EndMenu( menu_controller );
		PauseAll( FALSE );
	}

}


void ProcessMenu(SI *ctrl)
{
	int		dir, buttons, tapped;
	int		choice,oldchoice;
	ctrlrT	*c;

	c=&ctrlrs[menu_controller+1];

	menu_time++;

	if (replay_flag)
	{
		CamProcessReplay(c->ctrlr);
	}
	else if (si___gCurState || si___gNxtState)
	{
		DoShellExec(ctrl);
	}
	else
	{
		ProcessJoypads( ctrl, 1 );
		buttons = asi__gJoyPad[menu_controller];
		tapped = asi__gJoyBtn[menu_controller];

//		subAllowed=0;	moved to StartMenu
		menuScoreboardFlag=0;

		memset(pauseSelectable,1,MAX_PAUSE_MENU_CHOICES);	// turn all choices ON

		if (MenuWhich == MENU_PAUSE)
		{
			// .... except these ones
			pauseSelectable[PAUSE_MENU_CALL_TIME_OUT]		= timeOutAllowed;
//			pauseSelectable[PAUSE_MENU_TEAM_SETTINGS]	=
//			pauseSelectable[PAUSE_MENU_OFF_SETS]		= 
//				pauseSelectable[PAUSE_MENU_SUBSTITUTIONS]	= 0;
			pauseSelectable[PAUSE_MENU_SUBSTITUTIONS]= ((inTimeOut || (SUBS_ALLOWED)) && possession_flag);

			if (inFreeThrow)
				pauseSelectable[PAUSE_MENU_CAMERA_OPTIONS] = FALSE;
		}

		while(!pauseSelectable[menuChoice])
			menuChoice=(menuChoice+1)%menuChoices;

		// Check for menu selection
		switch (MenuWhich)
		{
			case MENU_CAMERA:
				ProcessCameraMenu( buttons, tapped );
				break;

			case MENU_QUIT:
				ProcessQuitMenu( tapped );
				break;

			case MENU_CONTEST:
				if (tapped & CTRL_FIRE_A)
				{
					Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
					EndMenu( menu_controller );
					StartMenu( menu_controller, MENU_QUIT );
					return;
				}

				if (menu_time>6)
					if (CTL_DOWN(c,CTRL_FIRE_B))
					{
						Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
						PauseAll(FALSE);
						EndMenu(menu_controller);
						return;
					}


				break;

			case MENU_PRACTICE:
			case MENU_PAUSE:

				if (menu_time>6)
					if (CTL_DOWN(c,CTRL_FIRE_B))
					{
						Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
						PauseAll(FALSE);
						EndMenu(menu_controller);
						return;
					}

				if (tapped & CTRL_FIRE_A)
				{
					//c->db_ctrlr &= (~CTRL_FIRE_A);	// clear so no quick exit from shell menus(debounce)
		//			ProcessJoypads(ctrl, 1);	// debounce shell joypads so no quick exit from shell menus
					c->c_mask|=CTRL_FIRE_A;

					if(MenuWhich == MENU_PRACTICE)
					{
						choice = PracticeMenuOptionMapping[menuChoice];
					}
					else
					{
						choice = menuChoice;
					}
					switch(choice)
					{
					
						case PAUSE_MENU_REPLAY:		// Instant replay
							Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );

							manualReplayFlag=TRUE;
							camReplayTargetNo = -1;
							ReplayButtons = buttons;
ReplayTextTimer = (5*ONE_SEC);
							start_replay(c-ctrlrs-1);
							break;

						case PAUSE_MENU_GOTO_SCOREBOARD:
							Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
							menuScoreboardFlag=TRUE;
							CamScoreBoard( TRUE );
							EndMenu(menu_controller);
							break;

						case PAUSE_MENU_SHELL_MENU:
							StartShellMenu(STATE_PAUSE_MENU);
							Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
							break;

						case PAUSE_MENU_QUIT_GAME:
							Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );

//							pcl__gMatch->sb___mQuarter=-1;	// signal player quit
//							gameOver=1;
							EndMenu(menu_controller);
							StartMenu( menu_controller, MENU_QUIT );
							return;

						case PAUSE_MENU_SPECIAL:
							StartShellMenu(STATE_SPECIAL_MENU);	//STATE_PAUSE_MENU);
							break;

						case PAUSE_MENU_CALL_TIME_OUT:
//							Audio_SfxPlay( GameBank, SFX_WHISTLE, SfxVolume ); moved into process_timeout
							timeout_called=1;
							inTimeOut = 1;
							process_timeout();
							timeOutAllowed=0;
							break;

						case PAUSE_MENU_CAMERA_OPTIONS:
							Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
							EndMenu(menu_controller);
							StartMenu( menu_controller, MENU_CAMERA );
							break;

						case PAUSE_MENU_SUBSTITUTIONS:		
							StartShellMenu(PAUSE_E);
							break;

						case PAUSE_MENU_GAME_HINT:
							Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
//							PauseAll(FALSE);
//							EndMenu(menu_controller);
//							BuildNextHint();
							EndMenu(menu_controller);
							StartMenu( menu_controller, MENU_HINT );
							break;

						default:
							EndMenu(menu_controller);
							return;
					}
				}
				break;
		
			case MENU_FORCESUB:
					PauseAll(FALSE);
					EndMenu(menu_controller);
					return;

			case MENU_HINT:
				if (menu_time>6)
				{
//					HintCtr--;
					
					if (CTL_DOWN(c,CTRL_FIRE_B | CTRL_FIRE_A | CTRL_START)
//						|| HintCtr <= ZERO
					   )
					{
//						HintCtr = 0;
						Audio_SfxPlay( GameBank, SFX_NETG, SfxVolume );
						PauseAll(FALSE);
						EndMenu(menu_controller);
//						return;
					}

					else if (tapped & CTRL_PAD_LEFT)
					{
						Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );
						HintCtr = OverGfx_BuildNextHint(-1,TRUE) * 4 * ONE_SEC;	// x seconds per line as default

					}
					else if (tapped & CTRL_PAD_RIGHT)
					{
						Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );
						HintCtr = OverGfx_BuildNextHint(1,TRUE) * 4 * ONE_SEC;	// x seconds per line as default
					
					}	
				}

				return;		// don't look at d-pad
		}

#if	1	//def DEBUG 
		if (MenuWhich == MENU_PAUSE)
		{
//			if (CTL_NEWPRESS(c,CTRL_C_UP & CTRL_C_DOWN))
			if ( (tapped & (CTRL_C_UP | CTRL_C_DOWN)) ==   (CTRL_C_UP | CTRL_C_DOWN) )
				menuChoices = NORMAL_PAUSE_MENU_CHOICES+1;
		}
#endif

		oldchoice = menuChoice;

		if (tapped & CTRL_PAD_UP)
		{
			do
			{
				menuChoice--;
				if (menuChoice < 0)
					menuChoice = (menuChoices - 1);
			} while (!pauseSelectable[menuChoice]);

//			Audio_SfxPlay( GameBank, oldchoice == menuChoice ? SFX_BUZZER : SFX_BALL1, SfxVolume );

		}
		else if (tapped & CTRL_PAD_DOWN)
		{
			oldchoice = menuChoice;
			do
			{
				menuChoice++;
				if (menuChoice >= menuChoices)
					menuChoice = 0;
			} while (!pauseSelectable[menuChoice]);
//			Audio_SfxPlay( GameBank, oldchoice == menuChoice ? SFX_BUZZER : SFX_BALL1, SfxVolume );
//			Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );

		}
		if(oldchoice != menuChoice)
			Audio_SfxPlay( GameBank, SFX_BALL1, SfxVolume );

	}

	// keep camera moving! (if not in a replay)
	if(!replay_flag) move_camera();
}


void StartMenu(int which,int whichMenu)
{
	if (menuFlag)
		BRK;

	MenuWhich = whichMenu;
	menu_controller=which;		// 0-3
	menuChoice=0;
	moveDir=moveTime=0;

	menu_time=0;

	if (which)
	{
		ctrlrs[which].ctrlr=0;
		ctrlrs[which].mctrlr=0;
		ctrlrs[which].c_mask=-1;
	}

	switch(whichMenu)
	{
		case MENU_PAUSE:

//			pauseMenuStrings[PAUSE_MENU_QUIT_GAME] = (PracticeMode) ? "Quit Practice" : "Quit Game";

//			subAllowed=0;	// assume

			timeOutAllowed=0;
			menuFlag=TRUE;
			menuChoices = NORMAL_PAUSE_MENU_CHOICES;
			si___gCurState=si___gNxtState=0;

			if (pcl__gMatch->asb__mPads[menu_controller] < 2)
			{	
				pauseTeam = pcl__gMatch->sb___mEditing=pcl__gMatch->asb__mPads[menu_controller]; // home or away
				CheckForTimeOutAllowed(pauseTeam);	// sets timeOutAllowed
			}
			else
			{
				pcl__gMatch->sb___mEditing=0;
			}

/******	these are done real time every frame
//			pauseSelectable[PAUSE_MENU_SUBSTITUTIONS]=0;

			if(pauseTeam==0 || pauseTeam==1)
			{
//				pauseSelectable[PAUSE_MENU_TEAM_SETTINGS] = 
//								pauseSelectable[PAUSE_MENU_OFF_SETS]=1;

				if (timeOutAllowed)
					pauseSelectable[PAUSE_MENU_CALL_TIME_OUT]=1;

				if(inTimeOut || (SUBS_ALLOWED))
				{
//					subAllowed=1;
					pauseSelectable[PAUSE_MENU_SUBSTITUTIONS]=1;
				}
			// sub menu screen is always available now... (provided we have a team!)
			// but we still require subAllowed to have the old value...
//				pauseSelectable[PAUSE_MENU_SUBSTITUTIONS]=1;

			}
******/
			break;

		case MENU_CAMERA:
			timeOutAllowed=0;
			menuFlag=TRUE;
			menuChoices = 2;
			si___gCurState=si___gNxtState=0;
			break;

		case MENU_QUIT:
			ReallyQuit = FALSE;	//TRUE;
			menuFlag = TRUE;
			menuChoices = 1;
			si___gCurState=si___gNxtState=0;
			break;

		case MENU_CONTEST:
			menuFlag = TRUE;
			PauseAll( TRUE );
			menuChoices = 1;
			pauseSelectable[0] = TRUE;
			si___gCurState=si___gNxtState=0;
			break;

		case MENU_PRACTICE:
			menuFlag = TRUE;
			menuChoices = NUM_PRACTICE_MENU_OPTIONS;	//1;
			pauseSelectable[0] = TRUE;
			si___gCurState=si___gNxtState=0;
			break;

		case MENU_FORCESUB:
			menuFlag = TRUE;
			PauseAll( TRUE );
			StartShellMenu(PAUSE_E);
			break;

		case MENU_HINT:
			menuFlag = TRUE;
			HintCtr = OverGfx_BuildNextHint(1,TRUE) * 4 * ONE_SEC;	// x seconds per line as default
			menuChoices = 1;
			break;
	}

	if (menuFlag)
	{
		SetStepMode( TRUE );
		ShellPauseMenuInited = FALSE;	// not backing up thru shell menu - allows for proper shell menu init
//		ShellFromGameOpen();
	}
}


void EndMenu(int which)
{
int	i,j;

	if (which!=menu_controller)
		return;

	if (menuFlag)
	{
		SetStepMode( currentProcess->StepMode );
		tempo=mtempo=0x100+((0x21*pcl__gMatch->pcl__mOptions->sb___GameSpeed)>>7);
		if (inTimeOut)
			time_rate=0x100;

		// Kill button presses in the menu that might affect gameplay
#if 0
		if (which!=-1)
#else
		for (i=0; i<5; i++)
#endif
		{
//			ctrlrs[which+1].c_mask=-1;
//			ctrlrs[which+1].r_mask=-1;
//			ctrlrs[which+1].db_ctrlr=0;
//			ctrlrs[which+1].mctrlr=0;
	// is this what you want??? - mjk 9/11/99
			ctrlrs[i].c_mask=-1;
			ctrlrs[i].r_mask=-1;
			ctrlrs[i].db_ctrlr=0;
			ctrlrs[i].mctrlr=0;
			ctrlrs[i].tap = 0;			// Button(s) being tapped - fixes bug #676
			ctrlrs[i].hold = 0;			// Button(s) being held down- fixes bug #676

			for(j=0; j<18; j++)
			{
				ctrlrs[i].htime[j]= 0;			// Button(s) being held down- fixes bug #676
			}

		}

//	ShellFromGameClose();		
//	InitGfxAllPlayers();	// 

//	end_replay(which);
		menuFlag=FALSE;
	}
}



void PlayWhistleSfx(void)
{
		Audio_SfxPlay( GameBank, SFX_WHISTLE, SfxVolume );
}

/****************************************************************************************

					end of file:MENU .c  Used in the 1999 version of Courtside 2

****************************************************************************************/