#include <PR/bcp.h>
#include <PR/R4300.h>
#include <PR/bbsim.h>
#include <PR/bbskapi.h>
#include <PR/os.h>
#include <PR/os_bbfs.h>
#include <PR/os_bbatb.h>
#include <PR/os_bbexec.h>
#include "common.h"
#include <PR/os_bbsa.h>
#include <PR/os_internal_reg.h>

/* 16 KB buffer for internal use */
static u8 gLaunchBuf[SK_RECRYPT_KEYLIST_SIZE] ALIGN_DCACHE;

static struct {
    s32 sfd;
    s32 dfd;
    BbTicketBundle ticketBundle;    
    BbAppLaunchCrls appRls;
    u32 recoveryBTgt;  /* target for recovery. 0 for no recovery */
    u32 destBProc;     /* dest bytes processed since saGamePrelaunch() */
    char launchAppName[16];
} gRecryptState;

/* bit flags for return */
#define SA_CID_EXT_NONE 0
#define SA_CID_EXT_APP  1 
#define SA_CID_EXT_REC  2
int getAppExtensionsPresent(BbContentId cid)
{
    char appName[16];
    s32 fd;
    int ret=0;

    osBbSaCidToAppName(cid,gSaAppExt,appName);
    if( (fd = osBbFOpen(appName,"r")) >= 0){
        ret |= SA_CID_EXT_APP;
        osBbFClose(fd);
    }

    osBbSaCidToAppName(cid,gSaRecExt,appName);
    if( (fd = osBbFOpen(appName,"r")) >= 0){
        OSBbStatBuf fsStat;
        osBbFStat(fd, &fsStat, NULL, 0);
        if(fsStat.size==0){
            osBbFClose(fd);
            osBbFDelete(appName);
        }
        else{
            ret |= SA_CID_EXT_REC;
            osBbFClose(fd);
        }
    }
    
    return ret;
}

int readKeylist(u8 *keylist)
{
    s32 fd;

    int ret = SALAUNCH_OK;

    if( (fd = osBbFOpen(gSaRecryptKeyFname,"r")) < 0){
        return SALAUNCH_ERR_FILE_NOT_FOUND;
    }
    if(osBbFRead(fd, 0, keylist, KEYLIST_SIZE)<0){
        ret = SALAUNCH_ERR_FS;
    }
    osBbFClose(fd);
    return ret;
}

/* create if necessary */
int saveKeylist(u8 *keylist)
{
    s32 fd;
    int ret = SALAUNCH_OK;
    char tmpFile[] = "_recrypt.sys";
    osBbFDelete(tmpFile);
    if( (fd = osBbFCreate(tmpFile,1,KEYLIST_SIZE)) < 0){
            return SALAUNCH_ERR_FS;
    }
    if(osBbFWrite(fd, 0, keylist, KEYLIST_SIZE)<0){
        ret = SALAUNCH_ERR_FS;
    }
    osBbFClose(fd);
    osBbFRename(tmpFile,gSaRecryptKeyFname);
    return ret;
}



/*
 * convert cid to app name given desired extension
 */
void osBbSaCidToAppName(BbContentId cid, const char *ext, char *name)
{
    int i,j;
    u32 id=(u32)cid;
    for(j=0,i=28;i>=0;i-=4)
        name[j++]=NIBBLE_TO_ASCII((id>>i)&0xf);
    name[j++]='.';
    name[j++]=ext[0];
    name[j++]=ext[1];
    name[j++]=ext[2];
    name[j++]='\0';
}

/*
 * NOTE: 
 *       ticketBundle (output) will not copy the ticket, so the memory
 *       used to hold the ticket ptr must not be altered until the
 *       ticketBundle is no longer needed.
 */
int osBbSaBundleTicket(BbTicket *ticket,
                       BbTicketBundle *ticketBundle,
                       BbAppLaunchCrls *appRls)
{
    BbContentMetaDataHead *pCmdh;

    ticketBundle->ticket = ticket;
    pCmdh = &(ticketBundle->ticket->cmd.head);

    PRINTF("content size: %08x\n", pCmdh->size);

    /* create ticket bundle */
    if(osBbSaCertCreateChain(ticket->head.issuer,
                         ticketBundle->ticketChain)<0){
        PRINTF("osBbSaCertCreateChain() failure for ticket chain.\n");
        return SALAUNCH_ERR_DATA;
    }
    if(osBbSaCertCreateChain(pCmdh->issuer, ticketBundle->cmdChain)<0){
        PRINTF("osBbSaCertCreateChain() failure for cmd chain.\n");
        return SALAUNCH_ERR_DATA;
    }

    if(osBbSaRlBundle(appRls)!=BB_SYSAPP_PASS)
        return SALAUNCH_ERR_DATA;

    return BB_SYSAPP_PASS;
}

static int prelaunchRecryptNotReq(BbContentMetaDataHead *pCmdh, u8 *keylist)
{
    if(SK_API_SUCCESS != skLaunchSetup(&gRecryptState.ticketBundle, 
                                       &gRecryptState.appRls, 
                                       keylist)){
        PRINTF("skLaunch() failure!\n");
        return SALAUNCH_ERR_DATA;
    }
    osBbSaCidToAppName(pCmdh->id,gSaAppExt,gRecryptState.launchAppName);
    return SALAUNCH_OK;
}


static int prelaunchFullRecrypt(BbContentMetaDataHead *pCmdh,u8 *keylist)
{
    OSBbStatBuf fsStat;
    char appName[16];

    /* save keylist */
    saveKeylist(keylist);
    
    /* setup state for chunked personalization calls */
    /* source fd */
    osBbSaCidToAppName(pCmdh->id,gSaAppExt,appName);
    if( (gRecryptState.sfd = osBbFOpen(appName,"r")) < 0){
        PRINTF("Failed to open source app.\n");
        return SALAUNCH_ERR_FS;
    }
    
    /* destination fd */
    osBbSaCidToAppName(pCmdh->id,gSaRecExt,appName);
    if((gRecryptState.dfd = osBbFCreate(appName, 1, 0)) < 0){
        PRINTF("Failed to open dest app.\n");
        return SALAUNCH_ERR_FS;
    }
    if((osBbFStat(gRecryptState.sfd, &fsStat, NULL, 0)) < 0){
        return SALAUNCH_ERR_FS;
    }
    if(fsStat.size<pCmdh->size){
        return SALAUNCH_ERR_FS;
    }

    gRecryptState.recoveryBTgt=0;
    gRecryptState.destBProc=0;
    return SALAUNCH_PERSONALIZE;
}

/* global state - no support for launching multiple games at a time.
 *   must be called from a single thread.
 */
int osBbSaGamePrelaunch(BbTicket *ticket)
{
    BbTicketId tid; 
    BbContentMetaDataHead *pCmdh;
    u8 *keylist=gLaunchBuf;
    OSBbStatBuf fsStat;
    char appName[16];
    int i, ret;
    u16 limit, window, cc[BB_MAX_CC];

    pCmdh = &(ticket->cmd.head);

    /* check limited play ticket*/
    tid = ticket->head.tid;
    limit = ticket->head.limit;
    if (tid >= BB_TICKET_ID_LIMITED) {
        skGetConsumption(&window, cc);
        for (i=0; i<BB_MAX_CC; i++) {
            if ( (tid & (BB_TICKET_ID_LIMITED-1)) == window+i ) { 
                if (cc[i]==limit && ticket->head.code < BB_LIMIT_CODE_EXTERN) 
                    return SALAUNCH_ERR_EXPIRED;
                else
                    break;
            }
        }
    }

    /* check keylist */
    memset(keylist, 0, KEYLIST_SIZE);
    if((ret = readKeylist(keylist)) == SALAUNCH_ERR_FS)
        return ret;

    if(BB_SYSAPP_PASS != osBbSaBundleTicket(ticket, 
                                        &gRecryptState.ticketBundle,
                                        &gRecryptState.appRls)){
        PRINTF("saBundleTicket() failure!\n");
        return SALAUNCH_ERR_DATA;
    }

    /* default to recrypted app name for launch. change in code
     * to follow if necessary.
     */
    osBbSaCidToAppName(pCmdh->id,gSaRecExt,gRecryptState.launchAppName);

    /* determine state of recryption by extension */
    i = getAppExtensionsPresent(pCmdh->id);

    switch(i){
    case SA_CID_EXT_NONE:
        return SALAUNCH_ERR_FS;
    case SA_CID_EXT_APP:
        /* original app directly from depot only */
        ret = skRecryptBegin(&gRecryptState.ticketBundle, 
                             &gRecryptState.appRls, 
                             keylist);
        switch(ret){
        case SK_API_RECRYPT_NOT_REQUIRED:
            return prelaunchRecryptNotReq(pCmdh, keylist);
        case SK_API_RECRYPT_INCOMPLETE:
            /* crossover call for inside SK */
            if(skRecryptData(NULL, 0) != SK_API_SUCCESS)
                return SALAUNCH_ERR_DATA;
            return prelaunchFullRecrypt(pCmdh, keylist);
        case SK_API_RECRYPT_NEW:
        case SK_API_RECRYPT_COMPLETE:
            /* full recrypt */
            return prelaunchFullRecrypt(pCmdh, keylist);
        default:
            /* error case */
            return SALAUNCH_ERR_DATA;
        }
        break;
    case SA_CID_EXT_REC:
        /* personalized version only */
        ret = skLaunchSetup(&gRecryptState.ticketBundle, 
                            &gRecryptState.appRls, 
                            keylist);
        switch(ret){
        case SK_API_SUCCESS:
            return SALAUNCH_OK;
        case SK_API_RECRYPT_INCOMPLETE:
            if(skRecryptBegin(&gRecryptState.ticketBundle, 
                                 &gRecryptState.appRls, 
                                 keylist)!=SK_API_RECRYPT_INCOMPLETE)
                return SALAUNCH_ERR_DATA;
            /* destination fd */
            osBbSaCidToAppName(pCmdh->id,gSaRecExt,appName);
            if((gRecryptState.dfd = osBbFOpen(appName,"rw")) < 0){
                PRINTF("Failed to open dest app.\n");
                return SALAUNCH_ERR_FS;
            }
            if((osBbFStat(gRecryptState.dfd, &fsStat, NULL, 0)) < 0){
                return SALAUNCH_ERR_FS;
            }

            gRecryptState.recoveryBTgt=fsStat.size;
            gRecryptState.destBProc=0;

            return SALAUNCH_PERSONALIZE;
        case SK_API_RECRYPT_NEW:
            if((readKeylist(keylist) == SALAUNCH_ERR_FS) ||
               (skRecryptListValid(keylist)==SK_API_FAIL)){
                    return SALAUNCH_ERR_KEYLIST;
            }
        default:
            return SALAUNCH_ERR_DATA;
        }
    default:
        /* both original and personalized versions (most likely recovery
         * scenario) 
         */
        ret = skRecryptBegin(&gRecryptState.ticketBundle, 
                             &gRecryptState.appRls, 
                             keylist);
        switch(ret){
        case SK_API_RECRYPT_NOT_REQUIRED:
            /* this case shouldn't occur */
            /* remove <cid>.rec, since shouldn't exist */
            osBbFDelete(gRecryptState.launchAppName);
            return prelaunchRecryptNotReq(pCmdh, keylist);
        case SK_API_RECRYPT_NEW:
            /* allow flow-through to next case if keylist ok */
            if((readKeylist(keylist) == SALAUNCH_ERR_FS) ||
               (skRecryptListValid(keylist)==SK_API_FAIL)){
                    return SALAUNCH_ERR_KEYLIST;
            }
        case SK_API_RECRYPT_COMPLETE:
            /* these cases shouldn't occur */
            /* remove <cid>.rec, since shouldn't exist */
            osBbFDelete(gRecryptState.launchAppName);
            return prelaunchFullRecrypt(pCmdh, keylist);
        case SK_API_RECRYPT_INCOMPLETE:
            /* the recovery expected case */

            /* setup state for chunked personalization calls */
            /* source fd */
            osBbSaCidToAppName(pCmdh->id,gSaAppExt,appName);
            if( (gRecryptState.sfd = osBbFOpen(appName,"r")) < 0){
                PRINTF("Failed to open source app.\n");
                return SALAUNCH_ERR_FS;
            }

            /* destination fd */
            osBbSaCidToAppName(pCmdh->id,gSaRecExt,appName);
            if((gRecryptState.dfd = osBbFOpen(appName,"rw")) < 0){
                PRINTF("Failed to open dest app.\n");
                return SALAUNCH_ERR_FS;
            }
            if((osBbFStat(gRecryptState.dfd, &fsStat, NULL, 0)) < 0){
                return SALAUNCH_ERR_FS;
            }

            if((gRecryptState.recoveryBTgt=fsStat.size)==0){
                /* len=0 .rec file is illegal case (delete earlier) */
                return SALAUNCH_ERR_FS;
            }
            
            gRecryptState.destBProc=0;

            return SALAUNCH_PERSONALIZE;
            
        default:
            /* error case */
            return SALAUNCH_ERR_DATA;
        }
    }

    /* shouldn't come here */
    return SALAUNCH_ERR_DATA;
}


/* return SALAUNCH_OK when done, SALAUNCH_PERSONALIZE indicates call again.
 *
 * chunkBuffer must always be of size RECRYPT_CHUNK_SIZE.
 */
int osBbSaGamePersonalize(u8 *chunkBuffer)
{
    u32 chunkSize=RECRYPT_CHUNK_SIZE;
    u32 contentSize=gRecryptState.ticketBundle.ticket->cmd.head.size;
    int ret;

    if(contentSize<(gRecryptState.destBProc+chunkSize)) 
        chunkSize = contentSize-gRecryptState.destBProc;
        
    if(gRecryptState.recoveryBTgt){

        if(osBbFRead(gRecryptState.dfd, 
                     gRecryptState.destBProc, 
                     chunkBuffer, chunkSize) < 0) {
            ret = SALAUNCH_ERR_FS;
            goto chunkerr;
        }
        if(skRecryptComputeState(chunkBuffer,chunkSize)!=SK_API_SUCCESS){
            ret = SALAUNCH_ERR_DATA;
            goto chunkerr;
        }
        gRecryptState.destBProc += chunkSize;

        /* need to crossover? */
        if(gRecryptState.destBProc < contentSize && 
           gRecryptState.destBProc == gRecryptState.recoveryBTgt){

            gRecryptState.recoveryBTgt = 0;
            if(osBbFRead(gRecryptState.sfd, 0, chunkBuffer, chunkSize) < 0){
                ret = SALAUNCH_ERR_FS;
                goto chunkerr;
            }
            if(skRecryptData(chunkBuffer,chunkSize)!=SK_API_SUCCESS){
                ret = SALAUNCH_ERR_DATA;
                goto chunkerr;
            }
        }
    }
    else{
        if(osBbFRead(gRecryptState.sfd, 
                     gRecryptState.destBProc ? RECRYPT_CHUNK_SIZE : 0, 
                     chunkBuffer, chunkSize) < 0) {
            ret = SALAUNCH_ERR_FS;
            goto chunkerr;
        }
        if(skRecryptData(chunkBuffer, chunkSize)!=SK_API_SUCCESS){
            ret = SALAUNCH_ERR_DATA;
            goto chunkerr;
        }
        if(osBbFShuffle(gRecryptState.sfd, gRecryptState.dfd, 
                        gRecryptState.destBProc!=0, 
                        chunkBuffer, chunkSize) < 0) {
            ret = SALAUNCH_ERR_FS;
            goto chunkerr;
        }        
        gRecryptState.destBProc += chunkSize;
    }

    /* finished? */
    if(gRecryptState.destBProc>=contentSize){
        /* done, prepare for launch */
        char appName[16];
        u8 *keylist = gLaunchBuf; /* keylist at beginning of heap from 
                                   * saGamePrelaunch() 
                                   */
        osBbSaCidToAppName(gRecryptState.ticketBundle.ticket->cmd.head.id,
                     gSaAppExt,appName);
        osBbFClose(gRecryptState.sfd);
        osBbFClose(gRecryptState.dfd);
        osBbFDelete(appName);
        if(skRecryptEnd(keylist)!=SK_API_SUCCESS){
            osBbSaCidToAppName(gRecryptState.ticketBundle.ticket->cmd.head.id,
                         gSaRecExt,appName);
            osBbFDelete(appName);
            return SALAUNCH_ERR_DATA;
        }
        saveKeylist(keylist);
        PRINTF("skLaunchSetup()\n");
        if(skLaunchSetup(&gRecryptState.ticketBundle, 
                         &gRecryptState.appRls, keylist)!=SK_API_SUCCESS){
            return SALAUNCH_ERR_DATA;
        }
        return SALAUNCH_OK;
    }

    return SALAUNCH_PERSONALIZE;

 chunkerr:
    osBbFClose(gRecryptState.sfd);
    osBbFClose(gRecryptState.dfd);
    return ret;
}


int osBbSaGameLoadState(OSBbStateVector *sv, u32 bindings[4], BbTicketId tid)
{
    return osBbLoadState(gRecryptState.launchAppName, tid, sv, bindings);
}

int osBbSaGameLaunch(OSBbLaunchMetaData *md)
{
    u16 *blkList;
    OSBbStatBuf fsStat;
    s32 fsret,fd,listSize,loadAll;
    u32 addr;

    if( (fd = osBbFOpen(gRecryptState.launchAppName,"r")) < 0){
        return SALAUNCH_ERR_FS;
    }

    memset(gLaunchBuf,0,sizeof(gLaunchBuf));
    blkList = (u16 *)gLaunchBuf;

    fsret = osBbFStat(fd, &fsStat, blkList, sizeof(gLaunchBuf)/2);
    if(fsret !=0)
        return SALAUNCH_ERR_FS;
    
    listSize = fsStat.size/BB_FL_BLOCK_SIZE;

    loadAll=!(gRecryptState.ticketBundle.ticket->cmd.head.execFlags &
              BB_CMD_EXEC_RECRYPT);
    osWritebackDCacheAll();
    if ((addr = osBbLoadApp(md, blkList, listSize, loadAll)) != NULL) {
        s32 mask;
        mask = __osDisableInt();
        skLaunch(addr);
        __osRestoreInt(mask);
    }

    return SALAUNCH_ERR_DATA;
}