#include <tigcclib.h>
#include "equates.h"
#include "usb.h"

INT_HANDLER OldInt3 = NULL;
HANDLE execHandle;

void HandleUSBInterrupt();
void LoadPS3JBOptions();
void FetchOptions(char* requestBuffer, short* pulldownBuffer);
void RedrawMenu();
void DoJailbreak();
const char* GetStateString(int state);
extern unsigned int state;

void HandleConnected();
void HUB_Task();

DEFINE_INT_HANDLER(MyInt3)
{
	HandleUSBInterrupt();
}

void _main(void)
{
	if (strcmp(ReleaseVersion, "3.10") != 0)
	{
		DlgMessage("Wrong AMS Version",
			"For now, you must be on AMS version 3.10 to use this program.\n\nDownload it from http://education.ti.com or elsewhere.",
			BT_NONE, BT_OK);
		return;
	}

  clrscr(); //Clear the screen and reset print position
	HANDLE handle = MenuNew(MF_TOOLBOX, 160, 0);
	MenuAddText(handle, 0, "Jailbreak", 1, DMF_TOP);
	MenuAddText(handle, 0, "Install", 2, DMF_TOP);
	MenuAddText(handle, 0, "Uninstall", 3, DMF_TOP);
	MenuAddText(handle, 0, "Options", 4, DMF_TOP);
	execHandle = MenuBegin(NULL, 0, 0, MBF_HMENU | MBF_MAX_MENU_WIDTH, 160, handle);
	RedrawMenu();
	LoadPS3JBOptions();

	short result, key;
	do
	{
		key = ngetchx();
		
		if (key == KEY_ESC || key == KEY_CLEAR)
		{
			break;
		}

		result = MenuKey(execHandle, key);
		if (result > 0)
		{
			MenuOff(execHandle);
			
			switch(result)
			{
				case 1:
				{
					DoJailbreak();
					break;
				}
				case 2:
				{
					//TODO: Install hook?
					break;
				}
				case 3:
				{
					//TODO: Install hook?
					break;
				}
				case 4:
				{
					//Fill our buffers with the current options
					char requestBuffer[40*3+3];
					short pulldownBuffer[1];
					FetchOptions(requestBuffer, pulldownBuffer);

					//Build options dialog to display
					HANDLE d = DialogNewSimple(140, 75);
					DialogAddXFlags(d, DF_SCREEN_SAVE, XF_ALLOW_VARLINK | XF_VARLINK_SELECT_ONLY, 0, 0, 0);
					DialogAddTitle(d, "PS3JB89 Options", BT_OK, BT_CANCEL);
					DialogAddRequest(d, 3, 20, "Stage 1:", 0*40+0, 40, 14);
					DialogAddRequest(d, 3, 30, "Stage 2:", 1*40+1, 40, 14);
					DialogAddRequest(d, 3, 40, "FW Compat.:", 2*40+2, 40, 14);
					HANDLE p = PopupNew(NULL, 0);
					PopupAddText(p, -1, "No", 1);
					PopupAddText(p, -1, "Yes", 2);
					DialogAddPulldownEx(d, 0, 3, 50, "Use Device 6?", p, 0);

					//Show options dialog
					if (DialogDo(d, CENTER, CENTER, requestBuffer, pulldownBuffer) == KEY_ENTER)
					{
						//See if the old configuration variable exists first
						HSym hsym = SymFind(SYMSTR(configFileName));
						short wasArchived = 0;
						//NOTE: This apparently doesn't work, and this isn't what I really want which is to delete the archived variable directly
						if (hsym.folder > 0)
							if (DerefSym(hsym)->flags.bits.archived > 0)
								if (!EM_moveSymToExtMem(SYMSTR(configFileName), HS_NULL))
									wasArchived = 1;

						//Delete the configuration variable if it exists
						FDelete(configFileName);

						//Save the data to our configuration variable
						FILES f;
						if (FOpen(configFileName, &f, FM_WRITE, "CONF") == FS_OK)
						{
							short id = 0x5678;
							FWrite(&id, 2, &f);
							FWrite(requestBuffer, 41*3, &f);
							FWrite(pulldownBuffer, 2, &f);
							FClose(&f);

							if (wasArchived)
								EM_moveSymToExtMem(SYMSTR(configFileName), HS_NULL);
						}
					}
					HeapFree(d);
					FontSetSys(F_6x8);
					
					LoadPS3JBOptions();
					break;
				}
			}

			RedrawMenu();
		}
	} while (1);
	MenuEnd(execHandle);
	MenuUpdate();
	
	//Flush the keyboard buffer
	GKeyFlush();
}

void RedrawMenu()
{
	clrscr();
	
	//TODO: Add hook functionality...
	MenuTopStat(execHandle, 1, 0);
	MenuTopStat(execHandle, 2, 0);
	MenuOn(execHandle);

	//Draw...something...in the empty space
	const char* title = "PS3JB89";
	MoveTo(((26-strlen(title))/2)*6, 3*8);
	printf(title);
	MoveTo(((26-strlen(version))/2)*6, 4*8);
	printf(version);
	const char* name = "Brandon Wilson";
	MoveTo(((26-strlen(name))/2)*6, 8*8);
	printf(name);
	const char* site = "brandonw.net/ps3jb89";
	MoveTo(((26-strlen(site))/2)*6, 9*8);
	printf(site);
}

void DoJailbreak()
{
  clrscr(); //Clear the screen and reset print position
  printf("Connect a USB cable to    \n");
  printf("your calculator and your  \n");
  printf("PS3 now.\n\n");
  printf("Press any key to quit.\n\n");
  
  LoadPS3JBOptions();

  //HACK: Try and straighten out USB
  *USB_BASE_POWER_ADDR = (unsigned char)2;
  *USB_INT_ENABLE_ADDR = (char)1;
  *USB_INT_MASK_ADDR = (char)0xFF;

  //Back up the old and install the new handler
  OldInt3 = GetIntVec(AUTO_INT_3);
  SetIntVec(AUTO_INT_3, MyInt3);

  //HACK: Until we shift the main loop to hook.c/hub.c...
  HandleConnected();

  unsigned int previousState = init;
  void* kbdq = kbd_queue();
  unsigned short key;
	while(1)
	{
		if (!OSdequeue(&key, kbdq))
			break;
			
		HUB_Task();

		if (previousState != state)
		{
			previousState = state;
			printf("State: %s\n", GetStateString(state));
		}
		
		if (state == done)
		{
			printf("\nPress any key...\n");
			ngetchx();		
			break;
		}
	}
	
	//Restore the old handler
	SetIntVec(AUTO_INT_3, OldInt3);

	//Flush the keyboard buffer
	GKeyFlush();
}

const char* GetStateString(int state)
{
	const char* ret = NULL;
	
	switch(state)
	{
		case init:
		{
			ret = "s_init";
			break;
		}
		case wait_hub_ready:
		{
			ret = "wait_hub_ready";
			break;
		}
		case hub_ready:
		{
			ret = "hub_ready";
			break;
		}
		case p1_wait_reset:
		{
			ret = "p1_wait_reset";
			break;
		}
		case p1_wait_enumerate:
		{
			ret = "p1_wait_enumerate";
			break;
		}
		case p1_ready:
		{
			ret = "p1_ready";
			break;
		}
		case p2_wait_reset:
		{
			ret = "p2_wait_reset";
			break;
		}
		case p2_wait_enumerate:
		{
			ret = "p2_wait_enumerate";
			break;
		}
		case p2_ready:
		{
			ret = "p2_ready";
			break;
		}
		case p3_wait_reset:
		{
			ret = "p3_wait_reset";
			break;
		}
		case p3_wait_enumerate:
		{
			ret = "p3_wait_enumerate";
			break;
		}
		case p3_ready:
		{
			ret = "p3_ready";
			break;
		}
		case p2_wait_disconnect:
		{
			ret = "p2_wait_disconnect";
			break;
		}
		case p4_wait_connect:
		{
			ret = "p4_wait_connect";
			break;
		}
		case p4_wait_reset:
		{
			ret = "p4_wait_reset";
			break;
		}
		case p4_wait_enumerate:
		{
			ret = "p4_wait_enumerate";
			break;
		}
		case p4_ready:
		{
			ret = "p4_ready";
			break;
		}
		case p5_wait_reset:
		{
			ret = "p5_wait_reset";
			break;
		}
		case p5_wait_enumerate:
		{
			ret = "p5_wait_enumerate";
			break;
		}
		case p5_challenged:
		{
			ret = "p5_challenged";
			break;
		}
		case p5_responded:
		{
			ret = "p5_responded";
			break;
		}
		case p3_wait_disconnect:
		{
			ret = "p3_wait_disconnect";
			break;
		}
		case p3_disconnected:
		{
			ret = "p3_disconnected";
			break;
		}
		case p5_wait_disconnect:
		{
			ret = "p5_wait_disconnect";
			break;
		}
		case p5_disconnected:
		{
			ret = "p5_disconnected";
			break;
		}
		case p4_wait_disconnect:
		{
			ret = "p4_wait_disconnect";
			break;
		}
		case p4_disconnected:
		{
			ret = "p4_disconnected";
			break;
		}
		case p1_wait_disconnect:
		{
			ret = "p1_wait_disconnect";
			break;
		}
		case p1_disconnected:
		{
			ret = "p1_disconnected";
			break;
		}
		case p6_wait_reset:
		{
			ret = "p6_wait_reset";
			break;
		}
		case p6_wait_enumerate:
		{
			ret = "p6_wait_enumerate";
			break;
		}
		case done:
		{
			ret = "done";
			break;
		}
		default:
		{
			ret = "<Unknown>";
			break;
		}
	}
	
	return ret;
}