/*---------------------------------------------------------------------------*
  Project:      Sample demo program for NAND library
  File:         cancel.c
  Programmer:   HIRATSU Daisuke

  Copyright (C) 2007 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Log: cancel.c,v $
  Revision 1.3  2007/05/07 12:50:54  hiratsu
  Modified copy buffer size.

  Revision 1.2  2007/05/04 02:05:51  hiratsu
  Removed retry error handling.

  Revision 1.1  2007/04/23 06:50:08  hiratsu
  Sample demo program for NANDSimpleSafeCancel().

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


#include <string.h>
#include <stdlib.h>
#include <revolution.h>

#include "util.h"

#define FILENAME "cancel.txt"
#define PERM (NAND_PERM_OWNER_READ | NAND_PERM_OWNER_WRITE)    // Owner can read/write
#define ATTR          0x00                                     // No attributes.
#define DATASIZE       256   // byte

#define STATUS_SUCCESS   0
#define STATUS_FAILURE  -1
#define STATUS_BROKEN   -2


static BOOL isBrokenDataError(s32 err);
static BOOL prepareFile(void);
static int  updateFile(void);
static BOOL cleanUpFile(void);
static void tryCancel(NANDFileInfo *info);


int main(void)
{
    if(!prepareFile())
    {
        OSReport("Failed to prepare file.\n");
        return EXIT_FAILURE;
    }

    switch(updateFile())
    {
    case STATUS_SUCCESS:
        break;
    case STATUS_FAILURE:
        OSReport("Failed to update file.\n");
        return EXIT_FAILURE;
        break;
    case STATUS_BROKEN:
        OSReport("Original file is broken.\n");
        OSReport("Application program should ask a player to delete the file.\n");
        return EXIT_FAILURE;
    default:
        OSHalt("Never reach here...");
        break;
    }

    if(!cleanUpFile())
    {
        OSReport("Failed to clean up file.\n");
        return EXIT_FAILURE;
    }

    OSHalt("Cancel demo program finished with success.");
    return EXIT_SUCCESS;     // Never reach here.
}


static BOOL isBrokenDataError(s32 err)
{
    if(err==NAND_RESULT_AUTHENTICATION || err==NAND_RESULT_ECC_CRIT)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


static BOOL prepareFile(void)
{
    NANDFileInfo info;
    s32 ret = NAND_RESULT_FATAL_ERROR;
    char data[DATASIZE] ATTRIBUTE_ALIGN(32);
    memset(data, 'A', DATASIZE);

    ret = NANDCreate(FILENAME, PERM, ATTR);
    if(ret==NAND_RESULT_OK || ret==NAND_RESULT_EXISTS)
    {
        // No problem.
    }
    else
    {
        printErrMsg(ret);
        OSReport("NANDCreate() failed.\n");
        return FALSE;
    }

    ret = NANDOpen(FILENAME, &info, NAND_ACCESS_WRITE | NAND_ACCESS_READ);
    if(ret != NAND_RESULT_OK)
    {
        printErrMsg(ret);
        OSReport("NANDOpen() failed.  Result code: %d\n", ret);
        return FALSE;
    }

    ret = NANDWrite(&info, data, DATASIZE);
    if(ret != DATASIZE)
    {
        printErrMsg(ret);
        OSReport("NANDWrite() failed.\n");
        NANDClose(&info);
        return FALSE;
    }

    ret = NANDClose(&info);
    if(ret != NAND_RESULT_OK)
    {
        printErrMsg(ret);
        OSReport("NANDClose() failed.\n");
        return FALSE;
    }

    return TRUE;
}


static int updateFile(void)
{
    NANDFileInfo info;
    u8 copyBuf[NAND_FSBLOCK_SIZE] ATTRIBUTE_ALIGN(32);
    char dataB[DATASIZE] ATTRIBUTE_ALIGN(32);
    memset(dataB, 'B', DATASIZE);

    while(1)
    {
        // Opening phase
        s32 ret = NANDSimpleSafeOpen(FILENAME, &info, NAND_ACCESS_WRITE, copyBuf, NAND_FSBLOCK_SIZE);
        if(ret == NAND_RESULT_OK)
        {
            // No problem.
        }
        else if(isBrokenDataError(ret))
        {
            // Original file is broken.  Application program shuould consider delete this file.
            tryCancel(&info);
            return STATUS_BROKEN;
        }
        else
        {
            printErrMsg(ret);
            return STATUS_FAILURE;
        }

        // Writing phase
        ret = NANDWrite(&info, dataB, DATASIZE);
        if(ret==DATASIZE)
        {
            // No problem.
        }
        else if(isBrokenDataError(ret))
        {
            tryCancel(&info);
            continue;
        }
        else
        {
            printErrMsg(ret);
            return STATUS_FAILURE;
        }

        // Closing phase
        ret = NANDSimpleSafeClose(&info);
        if(ret==NAND_RESULT_OK)
        {
            break;
        }
        else
        {
            printErrMsg(ret);
            return STATUS_FAILURE;
        }
    }

    return STATUS_SUCCESS;
}


static BOOL cleanUpFile(void)
{
    s32 ret = NANDDelete(FILENAME);
    if(ret != NAND_RESULT_OK)
    {
        printErrMsg(ret);
        OSReport("NANDDelete() failed.\n");
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}


static void tryCancel(NANDFileInfo *info)
{
    s32 ret = NANDSimpleSafeCancel(info);
    if(ret==NAND_RESULT_OK)
    {
        return;
    }
    else
    {
        printErrMsg(ret);
        OSHalt("NANDSimpleSafeCancel() failed.  Stop.");
    }
}