/********************************************************************************
						   NINTENDO64 Disk Drive IPL4

							  clock setting module

								February 27, 1997
 ********************************************************************************/

#include <ultra64.h>
#include "ipl4.h"
#include "AUDIO/cpuaudio.h"
#include "graphics.h"


#define	MODE_CONT_LEFT			1
#define	MODE_CONT_RIGHT			2
#define	MODE_CONT_UP			3
#define	MODE_CONT_DOWN			4
#define	MODE_STCK_LEFT			5
#define	MODE_STCK_RIGHT			6
#define	MODE_STCK_UP			7
#define	MODE_STCK_DOWN			8

typedef struct {
	char		 	stickx;				/* analog stick position x				*/
	char		 	sticky;				/* analog stick position y				*/
	ushort		 	button;				/* controller button status				*/
	ushort		 	trigger;			/* controller button trigger			*/
	short			repeat;				/* auto repeat counter					*/
	short			curmode;			/* current process mode					*/
} Controller;

static int process;
static int counter;

static OSContPad *	activePad;
static Controller	controller;


static ClockInfo clockinfo;			// BUG 1997.1.31

//	static ClockInfo clockinfo = {
//		1, 0, 97, 1, 10, 4, 22, 0
//	};


static char monthTable[2][12] = {
	31,28,31,30,31,30,31,31,30,31,30,31,
	31,29,31,30,31,30,31,31,30,31,30,31
};

#define	IsDiskLoading()			((diskStatus == DISK_STAT_LOADING) || (diskStatus == DISK_STAT_LOADEND))
#define	IsClockWorking()		(diskClock.status == CLOCK_STAT_ACTIVE)


/********************************************************************************/
/*																				*/
/*	Get length of month.														*/
/*																				*/
/********************************************************************************/
static int
GetMonthLength(ClockInfo *clock)
{
	int year = 1900 + clock->year;
	int leap = ((year - 1996) % 4 == 0);

	return((int)monthTable[leap][clock->month-1]);
}
/********************************************************************************/
/*																				*/
/*	Set week.																	*/
/*																				*/
/********************************************************************************/
static void
SetWeek(ClockInfo *clock)
{
	int index;
	int year = 1900 + clock->year;
	int leap = ((year - 1996) % 4 == 0);
	int week = ((year - 1996) + (year - 1993) / 4) % 7;


	if (clock->day > monthTable[leap][clock->month-1]) {
		clock->day = monthTable[leap][clock->month-1];
	}
	for (index = 0; index < clock->month-1; index++) {
		week += monthTable[leap][index];
	}
	clock->week = (week + (clock->day-1)) % 7;
}
/********************************************************************************/
/*																				*/
/*	Read clock from disk drive.													*/
/*																				*/
/********************************************************************************/
static void
ReadClock(ClockInfo *clock)
{
	clock->cursor = 1;								// BUG 1997.1.31
	clock->blink  = 0;								// BUG 1997.1.31
	clock->year	  = BcdToBin(diskClock.year	 );
	clock->month  = BcdToBin(diskClock.month );
	clock->day	  = BcdToBin(diskClock.day	 );
	clock->hour	  = BcdToBin(diskClock.hour	 );
	clock->minute = BcdToBin(diskClock.minute);

	if (clock->year < 21)  clock->year += 100;
	if (clock->year < 96)  clock->year  =  96;
	SetWeek(clock);
}
/********************************************************************************/
/*																				*/
/*	Read clock from disk drive.													*/
/*																				*/
/********************************************************************************/
static void
WriteClock(ClockInfo *clock)
{
	DDClock dskclk;

	dskclk.year	  = BinToBcd(clock->year - ((clock->year >= 100) ? 100 : 0));
	dskclk.month  = BinToBcd(clock->month );
	dskclk.day	  = BinToBcd(clock->day	  );
	dskclk.hour	  = BinToBcd(clock->hour  );
	dskclk.minute = BinToBcd(clock->minute);
	dskclk.second = 0;

	WriteDDClock(&dskclk);
}
/********************************************************************************/
/*																				*/
/*	Add value.																	*/
/*																				*/
/********************************************************************************/
static void
AddValue(ClockInfo *clock)
{
	switch (clock->cursor) {
		case 1:	if (++clock->year > 120)  clock->year  = 96;
				SetWeek(clock);
				break;

		case 2: if (++clock->month > 12)  clock->month = 1;
				SetWeek(clock);
				break;

		case 3: if (++clock->day > GetMonthLength(clock))  clock->day = 1;
				SetWeek(clock);
				break;

		case 4: if (++clock->hour > 23)  clock->hour = 0;
				break;

		case 5: if (++clock->minute > 59)  clock->minute = 0;
				break;
	}
	Nacp_SeStart(NACP_CHANGE);
}
/********************************************************************************/
/*																				*/
/*	Sub value.																	*/
/*																				*/
/********************************************************************************/
static void
SubValue(ClockInfo *clock)
{
	switch (clock->cursor) {
		case 1:	if (--clock->year < 96)  clock->year  = 120;
				SetWeek(clock);
				break;

		case 2: if (--clock->month < 1)  clock->month = 12;
				SetWeek(clock);
				break;

		case 3: if (--clock->day < 1)  clock->day = GetMonthLength(clock);
				SetWeek(clock);
				break;

		case 4: if (--clock->hour < 0)  clock->hour = 23;
				break;

		case 5: if (--clock->minute < 0)  clock->minute = 59;
				break;
	}
	Nacp_SeStart(NACP_CHANGE);
}
/********************************************************************************/
/*																				*/
/*	Set controller stick level.													*/
/*																				*/
/********************************************************************************/
static void
SetController(void)
{
	uchar	status = 0;

	controller.stickx  = 0;
	controller.sticky  = 0;
	controller.trigger = activePad->button & (activePad->button ^ controller.button);
	controller.button  = activePad->button;

	if (activePad->stick_x < -7)  controller.stickx = (activePad->stick_x + 6);
	if (activePad->stick_x >  7)  controller.stickx = (activePad->stick_x - 6);
	if (activePad->stick_y < -7)  controller.sticky = (activePad->stick_y + 6);
	if (activePad->stick_y >  7)  controller.sticky = (activePad->stick_y - 6);

	if (controller.stickx < -64)  controller.stickx = -64;
	if (controller.stickx >  64)  controller.stickx =  64;
	if (controller.sticky < -64)  controller.sticky = -64;
	if (controller.sticky >  64)  controller.sticky =  64;
}
/********************************************************************************/
/*																				*/
/*	Check stick neutral.														*/
/*																				*/
/********************************************************************************/
static int
IsStickNeutral(void)
{
	return(-8 <= controller.stickx && controller.stickx <= 8 && 
		   -8 <= controller.sticky && controller.sticky <= 8	);
}
/********************************************************************************/
/*																				*/
/*	Check stick neutral.														*/
/*																				*/
/********************************************************************************/
static void
SetCurrentMode(short mode, short repeat, short blink)
{
	controller.curmode = mode;
	controller.repeat  = repeat;
	clockinfo.blink    = blink;
	if (repeat == 0)  Nacp_SeStart(NACP_CMOVE);			/* when move cursor		*/
}
/********************************************************************************/
/*																				*/
/*	Begin button process.														*/
/*																				*/
/********************************************************************************/
static void
BeginButtonProcess(void)
{
	if (controller.button & CONT_LEFT) {
		SetCurrentMode(MODE_CONT_LEFT, 0, 0);
		if (--clockinfo.cursor < 1)  clockinfo.cursor = 5;
	}
	else if (controller.button & CONT_RIGHT) {
		SetCurrentMode(MODE_CONT_RIGHT, 0, 0);
		if (++clockinfo.cursor > 5)  clockinfo.cursor = 1;
	}
	else if (controller.button & CONT_UP) {
		SetCurrentMode(MODE_CONT_UP, 20, 10);
		AddValue(&clockinfo);
	}
	else if (controller.button & CONT_DOWN) {
		SetCurrentMode(MODE_CONT_DOWN, 20, 10);
		SubValue(&clockinfo);
	}
	else if (controller.stickx < -32) {
		SetCurrentMode(MODE_STCK_LEFT, 0, 0);
		if (--clockinfo.cursor < 1)  clockinfo.cursor = 5;
	}
	else if (controller.stickx > 32) {
		SetCurrentMode(MODE_STCK_RIGHT, 0, 0);
		if (++clockinfo.cursor > 5)  clockinfo.cursor = 1;
	}
	else if (controller.sticky > 32) {
		SetCurrentMode(MODE_STCK_UP, 30, 10);
		AddValue(&clockinfo);
	}
	else if (controller.sticky < -32) {
		SetCurrentMode(MODE_STCK_DOWN, 30, 10);
		SubValue(&clockinfo);
	}
}
/********************************************************************************/
/*																				*/
/*	Repeat button process.														*/
/*																				*/
/********************************************************************************/
static void
RepeatButtonProcess(void)
{
	int reset = FALSE;

	switch (controller.curmode) {
		case MODE_CONT_LEFT : reset = !(controller.button & CONT_LEFT );			break;
		case MODE_CONT_RIGHT: reset = !(controller.button & CONT_RIGHT);			break;
		case MODE_CONT_UP   : reset = !(controller.button & CONT_UP	  );			break;
		case MODE_CONT_DOWN : reset = !(controller.button & CONT_DOWN );			break;
		default				: reset = controller.curmode && IsStickNeutral();		break;
	}
	if (reset) {
		controller.curmode = 0;
	} else {
		switch (controller.curmode) {
			case MODE_CONT_UP:
						if (--controller.repeat == 0) {
							SetCurrentMode(MODE_CONT_UP, 2, 10);
							AddValue(&clockinfo);
						}
						break;

			case MODE_CONT_DOWN:
						if (--controller.repeat == 0) {
							SetCurrentMode(MODE_CONT_DOWN, 2, 10);
							SubValue(&clockinfo);
						}
						break;

			case MODE_STCK_UP:
						if (controller.sticky  > 8) {
							if (--controller.repeat == 0) {
								SetCurrentMode(MODE_STCK_UP, (64-controller.sticky)/6 + 2, 10);
								AddValue(&clockinfo);
							}
						}
						break;

			case MODE_STCK_DOWN:
						if (controller.sticky < -8) {
							if (--controller.repeat == 0) {
								SetCurrentMode(MODE_STCK_DOWN, (64+controller.sticky)/6 + 2, 10);
								SubValue(&clockinfo);
							}
						}
						break;
		}
	}
}
/********************************************************************************/
/*																				*/
/*	Scan active controller (pressed start button)								*/
/*																				*/
/********************************************************************************/
static void
ScanActiveController(void)
{
	int cont;

	if (!IsClockWorking() || !IsDiskLoading()) {
		for (cont = 0; cont < MAXCONTROLLERS; cont++) {
			if (contStatus[cont].type == (CONT_JOYPORT|CONT_ABSOLUTE)) {
				if (contRdData[cont].button & CONT_A) {
					activePad = &contRdData[cont];
					counter	  = 30;
					process   = 1;
					break;
				}
			}
		}
	}
}
/********************************************************************************/
/*																				*/
/*	Check pressing start button													*/
/*																				*/
/********************************************************************************/
static void
CheckStartButton(void)
{
	if (activePad->button & CONT_A) {
		if (!IsClockWorking() || !IsDiskLoading()) {
			counter -= 1;
		}
		if (counter == 0) {
			ReadClock(&clockinfo);
			controller.button  = CONT_A;
			controller.curmode = 0;
			process			   = 2;
			Nacp_SeStart(NACP_OPEN);
		}
	}
	else {
		activePad = NULL;
		process	  = 0;
	}
}		
/********************************************************************************/
/*																				*/
/*	Do clock setting															*/
/*																				*/
/********************************************************************************/
static void
DoClockSetting(void)
{
	SetController();
	if (controller.trigger & (CONT_START|CONT_A|CONT_B)) {
		Nacp_SeStart(NACP_DECIDE);
		if (controller.trigger & (CONT_START|CONT_A)) {
			WriteClock(&clockinfo);
		}
		activePad = NULL;
		process	  = 0;
	}
	else {
		RepeatButtonProcess();
		if (controller.curmode == 0)  BeginButtonProcess();
	}
	DrawClockSetting(&clockinfo);
}
/********************************************************************************/
/*																				*/
/*	Clock setting main															*/
/*																				*/
/********************************************************************************/
extern int
SetClock(void)
{
	switch (process) {
		case 0: ScanActiveController();		break;
		case 1: CheckStartButton();			break;
		case 2: DoClockSetting();			break;
	}
	clockSetting = (process == 2);
	return(clockSetting);
}
/********************************************************************************/
/*																				*/
/*	Clock setting main															*/
/*																				*/
/********************************************************************************/
extern void
InitClock(void)
{
	process      = 0;
	counter	     = 0;
	clockSetting = FALSE;
	activePad    = NULL;
}
/********************************************************************************/
/*																				*/
/*	Display disk drive clock													*/
/*																				*/
/********************************************************************************/
extern void
DisplayClock(int alpha)
{
	ClockInfo clock;

	ReadClock(&clock);

	DrawClock(144, 212, 											/* for TEST */
		clock.month, clock.day   , clock.week,
		clock.hour , clock.minute, BcdToBin(diskClock.second), alpha
	);
}