#include <ultra64.h>
#include <sched.h>
#include <PR/bcp.h>
#include <PR/bbnand.h>
#include <PR/os_bb.h>
#include "bbtypes.h"
#include "bbskapi.h"
#include "viewer.h"
#include "status.h"
#include "uilogic.h"
#include "audrenderer.h"
#include "pagetop.h"
#include "pagegame.h"
#include "pagegpak.h"
#include "pagecpak.h"
#include "vidreset.h"
#include "gzip.h"
#include "font.h"
#ifndef _PARTNER
extern void __osBbVideoPllInit(s32 tvType);
#endif

/* On card removal/insertion, force the osBbCardProbe() function 
 * to pass at least this many times, each time separated by at 
 * least a field-time. 
 * To use only a single osBbCardProbe() this define may be set 
 * to 0 (BUT this CAN result in a hang that remains
 * until the card is removed and inserted a second time).
 */
#define CARD_PROBE_SUCCESS_COUNT 5

/* for debounce of button */
#define DEBOUNCE_ON_FRAME_WAIT 15
#define DEBOUNCE_OFF_FRAME_WAIT 10
#define BUT_RELEASED (!((IO_READ(MI_EINTR_REG)&MI_EINTR_BUTTON_PRESSED)))
#define BUT_STATE_CHANGED \
             (IO_READ(MI_EINTR_REG)&MI_INTR_BUT)
#define BUT_CLEAR_STATE_CHANGED \
        IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_CLR_BUT)

#ifdef SHOW_BBID
int gFlashErr = 0;
u32 gFlashErrAddr = 0;
#endif

BbId                gBBID;
u32                 gCardID;
u32                 gEntryCode;
int                 gStatus;
int                 gTicketStatus;

u32                 gCid  = 0;
u16                 gTid  = 0;
u16                 gTidx = 0;

char                gWarningFile[9] = "warn.tmp";
int                 gWarn = 0;

OSSched             gSc;
OSMesgQueue        *gpSchedCmdQ;
u64                 gpSchedStack[OS_SC_STACKSIZE/8];
OSScClient          gGfxClient;

OSMesgQueue         gGfxFrameMsgQ;
OSMesg              gpGfxFrameMsgBuf[MAX_MESGS];
Gfx                *gpGfxList;
GFXInfo             gpGfxInfo[2];

u8                  gpDate[7];

u32                 gPageNo;
int                 gCardInit;
u8                  gHotSpot;
OSMesgQueue         gControllerMsgQ;
OSMesg              gControllerMsgBuf;

static OSMesg       PiMessages[DMA_QUEUE_SIZE];
static OSMesgQueue  PiMessageQ;

u64                 bootStack[STACKSIZEBYTES/sizeof(u64)];
static u64          gameThreadStack[STACKSIZEBYTES/sizeof(u64)];
static u64          initThreadStack[STACKSIZEBYTES/sizeof(u64)];
static OSThread     gameThread;
static OSThread     initThread;

static void         gameproc(void *);
static void         initproc(char *);
static void         initGame(void);
static void         checkCard(void);
static int          checkPowerWarning(void);

extern s32 __osShutdown;
#ifdef PAK_COPY
extern SaGpakCopy gGpak;
extern SaCpakCopy gCpak;
#endif
void   resetViewer(void);

#ifndef _FINALROM
OSTime              lastTime;
#endif

void boot(u32 reg)
{
    gEntryCode = reg; 

#ifndef _PARTNER
    /*
     * Turn off the button interrupt
     */
    IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_CLR_BUT);

#ifndef SA2 /* Only need to do this if we are the main sysapp (not SA2) */
    /*
     * Init Pll. No need to do all this if it already happened
     */
    if ((gEntryCode & (MI_SEC_MODE_BUT_TRAP | MI_SEC_MODE_TIMER | MI_SEC_MODE_APP)) == 0) {
        __osBbVideoPllInit(OS_TV_NTSC);
        vidReset(&cfb_16_a[0]);
    } else {
        /*
         * Make the video output black
         */
        IO_WRITE(VI_H_START_REG, 0x0);
    }
#endif
#endif

    osInitialize();

    osCreateThread(&initThread, 1, (void(*)(void *))initproc, (void *)0, 
                  (void *)(initThreadStack+(STACKSIZEBYTES/sizeof(u64))), 
                  (OSPri)INIT_PRIORITY);

    osStartThread(&initThread);
}

static void initproc(char *argv) 
{
#ifndef _PARTNER
#ifndef _FINALROM
    int i; 
    osBbUsbInit(); 
    for (i=0; i<10000000; i++);
#endif
#endif

    osCreatePiManager((OSPri) OS_PRIORITY_PIMGR, &PiMessageQ, PiMessages,
                      DMA_QUEUE_SIZE);

    osCreateThread(&gameThread, 6, gameproc, argv, gameThreadStack + 
                   (STACKSIZEBYTES/sizeof(u64)), (OSPri)GAME_PRIORITY);

    osStartThread(&gameThread);
    osSetThreadPri(0, 0);
    for(;;);
}

/**********************************************************************
 *
 * A continual loop, primarily used for servicing the starts of graphic 
 * tasks and controller reads. Audio is serviced by the audio thread. 
 * You receive several message on the same queue, they are:
 *    OS_SC_RETRACE_MSG: this comes from the scheduler every retrace. 
 *         If you don't already have 2 graphics tasks either pending or 
 *         processing, start creating another.
 *    OS_SC_DONE_MSG: sent by the scheduler when a graphics task has 
 *         completed. 
 *    OS_SC_PRE_NMI_MSG: sent to indicate the reset button has been 
 *         pressed, and that the game will reboot momentarily. Might 
 *         want to fade or say goodbye.
 *
 **********************************************************************/
static void gameproc(void *argv)
{
    u32     drawbuffer = 0;
    u32     pendingGFX = 0;
    int powerOff = 0;
    GFXMsg *msg = NULL;

    /*
     * Used for debounce
     */
    int waitFrame = DEBOUNCE_ON_FRAME_WAIT;
    int ready = 0;
    u32 mode;
    int rcount = 0;

#ifndef _FINALROM
    u32     doneTask = 0;
#endif

    initGame();

    /*
     * Startup sound - wait till it starts before going on
     */
    if (gEntryCode & MI_SEC_MODE_TIMER) {
        ready = 1;
        IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_SET_BUT);
    } else {
        if (gEntryCode & MI_SEC_MODE_BUT_TRAP || 
            gEntryCode & MI_SEC_MODE_APP ) {
            playSound(SOUND_MENU_DOWN, AUDIO_NOWAIT);
        } else {
            playSound(SOUND_STARTUP, AUDIO_NOWAIT);
        }
    }

    while (1) 
    {
        checkCard();

        /*
         * This is for startup and debounce. Only start listening to 
         * buttons once the startup sound is done and DEBOUNCE_ON_FRAME_WAIT
         * frames have passed by
         */
        if (ready) {
            osContStartReadData(&gControllerMsgQ);
            updateController();
        } else {
#ifndef PARTNER
            if (BUT_STATE_CHANGED) {
                BUT_CLEAR_STATE_CHANGED;
                waitFrame = DEBOUNCE_ON_FRAME_WAIT;
            }
            if (BUT_RELEASED) {
                waitFrame--;
            }
            if (waitFrame < 0) {
                IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_SET_BUT);
                ready = 1;
            }
#else
            ready = 1;
#endif
        }

	mode = osViGetCurrentMode();
        if ( gStatus== VW_GAME_PRE_LAUNCH1 ||
             gStatus== VW_GAME_PRE_LAUNCH2 ||
             gStatus == VW_GAME_PRE_LAUNCH3 ||
             gStatus == VW_GAME_PRE_LAUNCH ||
             gStatus == VW_GAME_PERSONALIZE ||
             gStatus == VW_GAME_LAUNCH1 ||
             gStatus == VW_GAME_LAUNCH2 ||
             gStatus == VW_GAME_LAUNCH ) {
	    if (mode != OS_VI_NTSC_LAN1) {
		osViSetMode(&osViModeNtscLan1);
		osViBlack(TRUE);
		rcount = 3;
	    }
	} else {
	    if (mode != OS_VI_NTSC_HAF1) {
		osViSetMode(&osViModeNtscHaf1);
		osViBlack(TRUE);
		rcount = 3;
	    } 
	}

        (void) osRecvMesg(&gGfxFrameMsgQ, (OSMesg *)&msg, OS_MESG_BLOCK);
        switch (msg->gen.type) 
        {
            case (OS_SC_RETRACE_MSG):
                if (powerOff) {
                    PRINTF("waitFrame = %d\n",waitFrame);
                    if (BUT_STATE_CHANGED) {
                        BUT_CLEAR_STATE_CHANGED;
                        waitFrame = DEBOUNCE_OFF_FRAME_WAIT;
                    }
                    if (BUT_RELEASED) {
                        waitFrame--;
                        if (waitFrame-- < 0) {
                            osBbFDelete( gWarningFile );
                            osBbPowerOff();
                            for (;;) ;
                        }
                    }
                } else {
                    /**** Create a new gfx task unless we already have 2  ****/                 
                    if (pendingGFX < 2) 
                    {
                        createGfxTask(&gpGfxInfo[drawbuffer]);
                        pendingGFX++;
                        drawbuffer ^= 1; /* switch the drawbuffer */
                    }
                }
                break;

            case (OS_SC_DONE_MSG):
#ifndef _FINALROM
                lastTime = gpGfxInfo[doneTask].task.totalTime;
                doneTask ^= 1;
#endif
                pendingGFX--;        /* decrement number of pending tasks */
		if (rcount && --rcount == 0)
		    osViBlack(FALSE);
                break;
                
            case (OS_SC_PRE_NMI_MSG): /* stop creation of graphics tasks */
                pendingGFX += 2;
#ifndef _PARTNER
                /*
                 * TODO: Need to clean up before turning power off!
                 */
                PRINTF("Power Off\n");
                waitFrame = DEBOUNCE_OFF_FRAME_WAIT;
                powerOff = 1;
                break;
#endif
        }

    }
}

/**********************************************************************
 *
 * initGame sets up the message queues used, and starts the scheduler.
 * After that call routines to init the graphics, init the controllers,
 * and init the audio.
 *
 *********************************************************************/
static void initGame(void)
{    

    /**** set up a needed message q's ****/
    osCreateMesgQueue(&gControllerMsgQ, &gControllerMsgBuf, 1);
    osCreateMesgQueue(&gGfxFrameMsgQ, gpGfxFrameMsgBuf, MAX_MESGS);

    /**** Initialize the RCP task scheduler ****/
#ifdef HI_RES
    osCreateScheduler(&gSc, (void *)(gpSchedStack + OS_SC_STACKSIZE/8),
                      SCHEDULER_PRIORITY, OS_VI_NTSC_HAF1, NUM_FIELDS);
#else
    osCreateScheduler(&gSc, (void *)(gpSchedStack + OS_SC_STACKSIZE/8),
                      SCHEDULER_PRIORITY, OS_VI_NTSC_LAN1, NUM_FIELDS);
#endif

    /**** Add ourselves to the scheduler to receive retrace messages ****/
    osScAddClient(&gSc, &gGfxClient, &gGfxFrameMsgQ);  

    gpSchedCmdQ = osScGetCmdQ(&gSc);

    initGFX(); 
    initCntrl();
    initAudio( &gSc );
    osBbRtcInit();

    resetViewer();

    if ( (gEntryCode & MI_SEC_MODE_APP) || 
         (gEntryCode & MI_SEC_MODE_BUT_TRAP) || 
         (gEntryCode & MI_SEC_MODE_TIMER) )
        gWarn = 0;
    else {
        gWarn = checkPowerWarning();
    }
}

void resetViewer(void)
{
    int ret = VW_OK;

    gCardInit = 0;
    gTicketStatus = VW_OK;
#ifdef PAK_COPY
    gPageGpakInit = 0;
#endif

    if ((gStatus=uiBbidCheck()) == VW_OK) {
        if (gEntryCode & MI_SEC_MODE_TIMER) {  // return from LP or PC expire
            char stateName[16]; /* 8.3 file <cid>.sta */
            BbTicketId tid;
            if(0==osBbSaveState(stateName, &tid)){
                PRINTF("Calling sberrCorrect()\n");
                sberrCorrect(stateName);
            }

            gCardInit = 0;
            initPageTop(PAGE_GAME);
            gLogoCnt = MAX_LOGO_COUNT; 

            gStatus = uiCheckExpiration(tid);
            ret = uiUpdateTimer(tid, 0);
            if (ret==VW_ERR_FS) 
                gStatus = ret;

            initPageGame(0, 0);
            playSound(SOUND_LPLAY_EXIT, AUDIO_NOWAIT);
            return;
        } else {
            initPageTop(PAGE_GAME);
            if (gEntryCode & MI_SEC_MODE_APP) { // "B" return from club
                gLogoCnt = MAX_LOGO_COUNT;
            } else if (gEntryCode & MI_SEC_MODE_BUT_TRAP) {  // return from games
                char stateName[16]; /* 8.3 file <cid>.sta */
                BbTicketId tid;
                if(0==osBbSaveState(stateName, &tid)){
                    PRINTF("Calling sberrCorrect()\n");
                    sberrCorrect(stateName);
                }
                gLogoCnt = MAX_LOGO_COUNT; 
                uiUpdateTimer(tid, 1);
                initPageGame(0, 0);
            } else {                     // power on
                uiUpdateTimer(0, 1);  // in case powered off w/o power button
            }
        }
        //gGpakIdxMax = uiGetGpaks(gGpakIds);

#ifdef SHOW_BBID
        if (IO_READ(PI_ERROR_REG) & PI_ERROR_CORRECTABLE_ECC) {
            gFlashErr = 1;
            gFlashErrAddr = IO_READ(PI_ERROR_REG)&PI_ERROR_ADDR_MASK;
        }
        if (IO_READ(PI_ERROR_REG) & PI_ERROR_UNCORRECTABLE_ECC) {
            gFlashErr = 2;
            gFlashErrAddr = IO_READ(PI_ERROR_REG)&PI_ERROR_ADDR_MASK;
        }
#endif

    } else 
        initPageTop(PAGE_GAME);
}

static int checkPowerWarning()
{
    s32 ifd;

    if ( (ifd=osBbFOpen(gWarningFile, "r"))==BBFS_ERR_ENTRY ) {
        osBbFCreate( gWarningFile, 1, BB_FL_BLOCK_SIZE);
        return 0;
    } else {
        osBbFClose( ifd );
        return 1;
    }
}

static void checkCard(void)
{
    static int cardProbePassCount = 0;
    static int cardProbePassLimit = CARD_PROBE_SUCCESS_COUNT;
    s32 ret = 0;

    if(cardProbePassCount==0)
        ret = osBbCardUnhappy();
    else{
        ret = BBCARD_ERR_CHANGED;
    }

    switch (gStatus) {
#ifdef PAK_COPY
    case VW_GP_CPY_SRC_CARD:         // waiting for src card
    case VW_ERR_GP_CPY_SRC_NO_GPAK:     // src card no gpak
    case VW_ERR_GP_CPY_SRC_NO_TICKET:   // src card no ticket.sys
        if ( ret == BBCARD_ERR_CHANGED) {
	    if (osBbCardProbe(0) == 0){
                if(cardProbePassCount < cardProbePassLimit){
                    if(cardProbePassCount==0){
                        cardProbePassLimit = gGfxFrameMsgQ.validCount + 
                                             CARD_PROBE_SUCCESS_COUNT;
                        PRINTF("Setting cardProbe limit = %d\n",
                                cardProbePassLimit);
                    }
                    PRINTF("Incrementing cardProbe count\n");
                    cardProbePassCount++;
                }
                else{
                    PRINTF("Zeroing cardProbe count\n");
                    cardProbePassCount=0;
                    gStatus = uiGpakSrcCardOkay();
                }
            }
        }
        break;
    case VW_GP_CPY_DST_CARD:         // waiting for dst. card
    case VW_ERR_GP_CPY_WRONG_DST_CARD:  // incorrect dst. card
    case VW_ERR_GP_CPY_DST_NO_SPACE:    // dst. card doesn't have space left
    case VW_ERR_GP_CPY_DST_NO_TICKET:   // dst. card doesn't have ticket
        if ( ret == BBCARD_ERR_CHANGED) {
	    if (osBbCardProbe(0) == 0){
                if(cardProbePassCount < cardProbePassLimit){
                    if(cardProbePassCount==0){
                        cardProbePassLimit = gGfxFrameMsgQ.validCount + 
                                             CARD_PROBE_SUCCESS_COUNT;
                        PRINTF("Setting cardProbe limit = %d\n",
                                cardProbePassLimit);
                    }
                    PRINTF("Incrementing cardProbe count\n");
                    cardProbePassCount++;
                }
                else{
                    PRINTF("Zeroing cardProbe count\n");
                    cardProbePassCount=0;
                    gStatus = uiGpakDstCardOkay(&gGpak); 
                }
            }
        }
        break;
    case VW_GP_CPY_CANCEL:  // copying cancelled
        if ( ret == BBCARD_ERR_CHANGED) {
	    if (osBbCardProbe(0) == 0){
                if(cardProbePassCount < cardProbePassLimit){
                    if(cardProbePassCount==0){
                        cardProbePassLimit = gGfxFrameMsgQ.validCount + 
                                             CARD_PROBE_SUCCESS_COUNT;
                        PRINTF("Setting cardProbe limit = %d\n",
                                cardProbePassLimit);
                    }
                    PRINTF("Incrementing cardProbe count\n");
                    cardProbePassCount++;
                }
                else{
                    PRINTF("Zeroing cardProbe count\n");
                    cardProbePassCount=0;
		    resetViewer();
                    if (gStatus!=VW_ERR_ID_MISMATCH && gStatus!=VW_ERR_FS) 
                    {
                        initPageGpak(0, 0);
                    }
                }
            }
        }
        break;
    case VW_CP_CPY_SRC_CARD:         // waiting for src card
    case VW_ERR_CP_CPY_SRC_NO_CPAK:     // src card no cpak
    case VW_ERR_CP_CPY_SRC_NO_TICKET:   // src card no ticket.sys
        if ( ret == BBCARD_ERR_CHANGED) {
	    if (osBbCardProbe(0) == 0){
                if(cardProbePassCount < cardProbePassLimit){
                    if(cardProbePassCount==0){
                        cardProbePassLimit = gGfxFrameMsgQ.validCount + 
                                             CARD_PROBE_SUCCESS_COUNT;
                        PRINTF("Setting cardProbe limit = %d\n",
                                cardProbePassLimit);
                    }
                    PRINTF("Incrementing cardProbe count\n");
                    cardProbePassCount++;
                }
                else{
                    PRINTF("Zeroing cardProbe count\n");
                    cardProbePassCount=0;
                    gStatus = uiCpakSrcCardOkay();
                }
            }
        }
        break;
    case VW_CP_CPY_DST_CARD:         // waiting for dst. card
    case VW_ERR_CP_CPY_WRONG_DST_CARD:  // incorrect dst. card
    case VW_ERR_CP_CPY_DST_NO_TICKET:   // dst. card doesn't have ticket
        if ( ret == BBCARD_ERR_CHANGED) {
	    if (osBbCardProbe(0) == 0){
                if(cardProbePassCount < cardProbePassLimit){
                    if(cardProbePassCount==0){
                        cardProbePassLimit = gGfxFrameMsgQ.validCount + 
                                             CARD_PROBE_SUCCESS_COUNT;
                        PRINTF("Setting cardProbe limit = %d\n",
                                cardProbePassLimit);
                    }
                    PRINTF("Incrementing cardProbe count\n");
                    cardProbePassCount++;
                }
                else{
                    PRINTF("Zeroing cardProbe count\n");
                    cardProbePassCount=0;
                    gStatus = uiCpakDstCardOkay(&gCpak); 
                }
            }
        }
        break;
    case VW_CP_CPY_CANCEL:  // copying cancelled
        if ( ret == BBCARD_ERR_CHANGED) {
	    if (osBbCardProbe(0) == 0){
                if(cardProbePassCount < cardProbePassLimit){
                    if(cardProbePassCount==0){
                        cardProbePassLimit = gGfxFrameMsgQ.validCount + 
                                             CARD_PROBE_SUCCESS_COUNT;
                        PRINTF("Setting cardProbe limit = %d\n",
                                cardProbePassLimit);
                    }
                    PRINTF("Incrementing cardProbe count\n");
                    cardProbePassCount++;
                }
                else{
                    PRINTF("Zeroing cardProbe count\n");
                    cardProbePassCount=0;
		    resetViewer();
                    if (gStatus!=VW_ERR_ID_MISMATCH && gStatus!=VW_ERR_FS) 
                    {
                        initPageCpak(0);
                    }
                }
            }
        }
        break;
#endif
    default:
        if ( ret == BBCARD_ERR_NO_CARD ) {
            gCardInit = 0;
            initPageTop(PAGE_GAME);
            gStatus = VW_ERR_NO_CARD; 
        } else if ( ret == BBCARD_ERR_CHANGED) {
	    if (osBbCardProbe(0) == 0){
                if(cardProbePassCount < cardProbePassLimit){
                    if(cardProbePassCount==0){
                        cardProbePassLimit = gGfxFrameMsgQ.validCount + 
                                             CARD_PROBE_SUCCESS_COUNT;
                        PRINTF("Setting cardProbe limit = %d\n",
                                cardProbePassLimit);
                    }
                    PRINTF("Incrementing cardProbe count\n");
                    cardProbePassCount++;
                }
                else{
                    PRINTF("Zeroing cardProbe count\n");
                    cardProbePassCount=0;
		    resetViewer();
                }
            }
        }
        break;
    }
}