#ifndef  CARD_H
#define  CARD_H

#include <nds.h>
#include <types.h>
#include <os_card.h>


#ifdef __cplusplus
extern "C" {
#endif

/*-----------------------------------------------------------------------------
-- macros
-----------------------------------------------------------------------------*/

#define MAX_CARD_RETRIES				10
#define LPKM_BACKUP_TYPE_4MBIT_FLASH	0xFF1302

/*-----------------------------------------------------------------------------
-- type definitions
-----------------------------------------------------------------------------*/

typedef void (*CardCallbackFn)(void*);


/*-----------------------------------------------------------------------------
-- enums 
-----------------------------------------------------------------------------*/

typedef enum CardResult {

  RESULT_SUCCESS		= 0,
  RESULT_FAIL			= 1,
  RESULT_INVALID_PARAM	= 2,
  RESULT_UNSUPPORTED	= 3,
  RESULT_TIMEOUT		= 4,
  RESULT_ERROR			= 5,
  RESULT_NO_RESPONSE	= 6,
  RESULT_CANCELED		= 7

} CardResult;


typedef enum CardRequest {

	REQUEST_INIT					= 0,                 
	REQUEST_ACK						= 1,     
	REQUEST_IDENTIFY				= 2,                 
	REQUEST_READ_ID					= 3,                  
	REQUEST_READ_ROM				= 4,                 
	REQUEST_WRITE_ROM				= 5,               
	REQUEST_READ_BACKUP				= 6,              
	REQUEST_WRITE_BACKUP			= 7,             
	REQUEST_PROGRAM_BACKUP			= 8,           
	REQUEST_VERIFY_BACKUP			= 9,            
	REQUEST_ERASE_PAGE_BACKUP		= 10,       
	REQUEST_ERASE_SECTOR_BACKUP		= 11,      
	REQUEST_ERASE_CHIP_BACKUP		= 12,       
	REQUEST_READ_STATUS				= 13,              
	REQUEST_WRITE_STATUS			= 14,             
	REQUEST_ERASE_SUBSECTOR_BACKUP	= 15,   
	REQUEST_MAX						= 16

} CardRequest;


typedef enum CardRequestMode {

	REQUEST_MODE_RECV			= 0,            
	REQUEST_MODE_SEND			= 1,            
	REQUEST_MODE_SEND_VERIFY	= 2,     
	REQUEST_MODE_SPECIAL		= 3       

} CardRequestMode;


/*-----------------------------------------------------------------------------
-- structs
-----------------------------------------------------------------------------*/

typedef struct RomRegion {

    u32     offset;
    u32     length;

} RomRegion;


/*-----------------------------------------------------------------------------
-- types 
-----------------------------------------------------------------------------*/




/*-----------------------------------------------------------------------------
-- inline Functions
-----------------------------------------------------------------------------*/

_INLINE bool ReadCardBackupHw(u32 src, void* dest, u32 size, CardCallbackFn cb, void* cb_arg, bool is_async)
{
	return CARDi_RequestStreamCommand((u32)src, (u32)dest, size, cb, cb_arg, is_async, REQUEST_READ_BACKUP, 1, REQUEST_MODE_RECV);
}


/*
ReadSave args:

src:	offset to start reading at in the save- 0 if you're reading from the top
dest:	buffer to read into
size:	read size
cb:		callback function- this is the function that will be run if the save read completes successfully. use NULL if you don't need one.
cb_arg:	callback function argument- ptr to the argument for the callback function.  also NULL if unused.
*/
_INLINE bool ReadSave(u32 src, void* dest, u32 size, CardCallbackFn cb, void* cb_arg)	
{
	return ReadCardBackupHw(src, dest, size, cb, cb_arg, TRUE);
}

/*
to use:

bool g_save_read = FALSE;

void SetSavReadFlag()
{
	save_read = TRUE;
}

const char* sav_src = "save_src.cpp";
void* save_buf = allocateBlockFromExpHeap(GRP_ID_SAV_BLK, BLK_LEN, TRUE, sav_src, SAV_BLK_LOAD_MK);

bool save_result = ReadSave(0 + block_address_you_use_if_any, save_buf, BLK_LEN, SetSavReadFlag, NULL);

*/


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

_INLINE void WriteCardBackupHw(u32 dest, const void* src, u32 size, CardCallbackFn cb, void* cb_arg, bool is_async)
{
	CARDi_RequestStreamCommand((u32)src, (u32)dest, size, cb, cb_arg, is_async, REQUEST_WRITE_BACKUP, MAX_CARD_RETRIES, REQUEST_MODE_SEND_VERIFY);
}


/*
WriteSave args:

dest:	offset into the save to write
src:	address in memory to start writing from
size:	write size
cb:		callback function- this is the function that will be run if the save read completes successfully. use NULL if you don't need one.
cb_arg:	callback function argument- ptr to the argument for the callback function.  also NULL if unused.
*/
_INLINE void WriteSave(u32 dest, const void* src, u32 size, CallbackFn cb, void* cb_arg)
{
	WriteCardBackupHw(dest, src, size, cb, cb_arg, TRUE);
}


/*-----------------------------------------------------------------------------
-- function declarations
-----------------------------------------------------------------------------*/

bool CARD_IsEnabled();
void CARD_CheckEnabled();
void CARD_Enable(bool enable);
CardResult CARD_GetResultCode();
const u8* CARD_GetRomHeader();
void CARD_LockRom(u16 lock_id);		// lock access to card rom - you call OS_GetLockID first to get the lock id to use here, lock_id is basically the owner of the current lock/unlock action
void CARD_UnlockRom(u16 lock_id);	// once you unlock access, use the same os lock id
void CARD_LockBackup(u16 lock_id);	// lock access to card backup - call OS_GetLockID first
void CARD_UnlockBackup(u16 lock_id);
bool CARDi_RequestStreamCommand(u32 src, u32 dst, u32 len, CallbackFn callback, void *arg, BOOL is_async, CardRequest req_type, int req_retry, CardRequestMode req_mode);
bool CARD_IdentifyBackup(u32 backup_type);	// you CAN use this, but you don't have to.  the type of backup is pre-identified by gamefreak.
u32	 CARD_GetBackupSectorSize();
bool CARD_WaitBackupAsync();
bool CARD_TryWaitBackupAsync();
void CARD_CancelBackupAsync();	// kill the currently running async process for the card
void CARD_WaitRomAsync();
bool CARD_IsPulledOut();


#ifdef __cplusplus
} /* extern "C"*/
#endif

#endif // CARD_H


/*
full example of reading from a save:

bool g_save_read = FALSE;

void ReadInSavBlk(u32 read_size, void* data_dest, u32 read_offset)
{

s32 id = OS_GetLockID();

if(id == LOCK_ID_ERR)
{
	assert_fail();
}

CARD_LockBackup((u16)id);

UnsetSavReadFlag();
ReadSave(read_offset, data_dest, read_size, SetSavReadFlag, NULL);

CARD_UnlockBackup((u16)id);
OS_ReleaseLockID((u16)id);
}


void SetSavReadFlag()
{
	save_read = TRUE;
}


void UnsetSavReadFlag()
{
	save_read = FALSE;
}
*/

// NOTE: you do not have to use a callback.  this is just a demonstration of how to.