//////////////////////////////////////////////////////////////////////////////
//
// Asura_PS2_MemoryCard_Error.cpp
//
// Created by Neil Massey.
//
// Copyright (c) 2002 Rebellion. All rights reserved.
//
// Error message system for memory card
//
//////////////////////////////////////////////////////////////////////////////

#include "Core/Asura.h"

#include "MemoryCard/Asura_PS2_MemoryCard_Error.h"

#include <stdio.h>

#include <libmc.h>

#include "Core/Asura_Timers.h"
#include "Debugging/Asura_Assert.h"
#include "MemoryCard/Asura_PS2_MemoryCard_SubSystem.h"

u_int Asura_PS2_MemoryCard_ErrorSystem::s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
u_int Asura_PS2_MemoryCard_ErrorSystem::s_uErrorFrameStamp = 0;

void Asura_PS2_MemoryCard_ErrorSystem::ProcessCardInfoError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResChangedCard:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_CARD_CHANGED;
#ifdef ASURA_PS2_SHOW_MEMORY_CARD_COMPLETION_MSGS
            printf("Card changed\n");
#endif
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
#ifdef ASURA_PS2_SHOW_MEMORY_CARD_COMPLETION_MSGS
            printf("No format\n");
#endif
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessOpenError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResFullDevice:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FULL;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_FOUND;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		case sceMcResUpLimitHandle:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_LIMIT_REACHED;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessCloseError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_OPENED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessSeekError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;			
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_OPENED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessReadError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;			
		break;
		case sceMcResFullDevice:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_CORRUPT;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_OPENED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessWriteError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;			
		break;
		case sceMcResFullDevice:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FULL;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_OPENED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessFlushError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;			
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_OPENED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessMkDirError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResFullDevice:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FULL;			
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_OPENED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessChDirError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
        case sceMcResNoEntry:
            s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_DIRECTORY_NOT_FOUND;
        break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessGetDirError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_OPENED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessFileInfoError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_FOUND;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessDeleteError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_FOUND;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		case sceMcResNotEmpty:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_DIRECTORY_NOT_EMPTY;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessFormatError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessUnformatError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessEntSpaceError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessRenameError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResNoEntry:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_FILE_NOT_FOUND;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessChgPriorError(const int iError)
{
	switch(iError)
	{
		case sceMcResSucceed:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_SUCCEED;
		break;
		case sceMcResNoFormat:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NOT_FORMATTED;
		break;
		case sceMcResDeniedPermit:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
		break;
		default:
			s_uCurrentError = ASURA_PS2_MEMORY_CARD_ERROR_NO_CARD;
	}
}

u_int Asura_PS2_MemoryCard_ErrorSystem::GetError(void)
{
	u_int uCurrentFrameStamp = Asura_Timers::GetFrameNumber();
	if(uCurrentFrameStamp == s_uErrorFrameStamp + 1 || 
	   uCurrentFrameStamp == s_uErrorFrameStamp)
	{
		return s_uCurrentError;
	}
	else
	{
		return ASURA_PS2_MEMORY_CARD_SUCCEED;
	}

}

void Asura_PS2_MemoryCard_ErrorSystem::ProcessError(const int iFunction, const int iError)
{
	s_uErrorFrameStamp = Asura_Timers::GetFrameNumber();
	switch(iFunction)
	{
		case sceMcFuncNoCardInfo:
			ProcessCardInfoError(iError);
		break;
		case sceMcFuncNoOpen:
			ProcessOpenError(iError);
		break;
		case sceMcFuncNoClose:
			ProcessCloseError(iError);
		break;
		case sceMcFuncNoSeek:
			ProcessSeekError(iError);
		break;
		case sceMcFuncNoRead:
			ProcessReadError(iError);
		break;
		case sceMcFuncNoWrite:
			ProcessWriteError(iError);
		break;
		case sceMcFuncNoFlush:
			ProcessFlushError(iError);
		break;
		case sceMcFuncNoMkdir:
			ProcessMkDirError(iError);
		break;
		case sceMcFuncNoChDir:
			ProcessChDirError(iError);
		break;
		case sceMcFuncNoGetDir:
			ProcessGetDirError(iError);
		break;
		case sceMcFuncNoFileInfo:
			ProcessFileInfoError(iError);
		break;
		case sceMcFuncNoDelete:
			ProcessDeleteError(iError);
		break;
		case sceMcFuncNoFormat:
			ProcessFormatError(iError);
		break;
		case sceMcFuncNoUnformat:
			ProcessUnformatError(iError);
		break;
		case sceMcFuncNoEntSpace:
			ProcessEntSpaceError(iError);
		break;
		case sceMcFuncNoRename:
			ProcessRenameError(iError);
		break;
		case sceMcFuncChgPrior:
			ProcessChgPriorError(iError);
		break;
		default:
			Asura_Assert(0, "Tried to handle error for unknown function");
	}
}


