// Support.cpp : 夔樂 擬辨 ヅ煎斜極縑 渠フ 霞殮薄擊 薑曖ベ棲棻.
//

#include "stdafx.h"
#include "Encrypt.h"
#include <string.h>

#ifdef _DEBUG
#	pragma comment( lib, "TheMola_d.lib" )
#	pragma comment( lib, "TheMola4File_d.lib" )
#else
#	pragma comment( lib, "TheMOLA.lib" )
#	pragma comment( lib, "TheMola4File.lib" )
#endif

CHAR s_pszSourcePath[128] = { 0, };
CHAR s_pszTargetPath[128] = { 0, };

FileListLoader::SECTION_TYPE 
Test_ParseSection(PVOID pPassingPtr,AttrTag tag)
{
	if( tag.IsMatch( "[SECTOR]" ) )
	{
		printf( "Section!\n" );
		return FileListLoader::eSECTION_TYPE::SECTION_COLUMNS;
	}

	return FileListLoader::eSECTION_TYPE::SECTION_ERROR;
}

BOOL 
Test_ParseSectionData(PVOID pPassingPtr, AttrValueName valueName, AttrValue value)
{
	if( valueName.IsMatch( "SOURCE_PATH" ) )
	{
		_snprintf( s_pszSourcePath, sizeof(s_pszSourcePath), "%s", value.ToString() );
		return TRUE;
	}
	else if( valueName.IsMatch( "TARGET_PATH" ) )
	{
		_snprintf( s_pszTargetPath, sizeof(s_pszTargetPath), "%s", value.ToString() );
		return TRUE;
	}
	else if( valueName.IsMatch( "OKFF" ) )
	{
		DWORD dwValue;
		value.GetValue( dwValue );
		printf( "Section value %u!\n", dwValue );
		return TRUE;
	}

	return FALSE;
}

VOID 
Encryption::LoadScriptList()
{
	FileListLoader loader;

	loader.SectionCallbackAlloc( &Test_ParseSection, NULL );
	loader.SectionDataCallbackAlloc( &Test_ParseSectionData, NULL );

	loader.Load( "ScriptList.txt", FALSE );

	m_FileInfo.dwLineCount = loader.GetLineCount();
	DWORD dwReadedCount = 0;

	m_FileInfo.pList = (SFiles*)malloc( m_FileInfo.dwLineCount*sizeof(SFiles) );
	SFiles* pListT = m_FileInfo.pList;

	for( DWORD i=0 ; i<m_FileInfo.dwLineCount ; ++i )
	{
		BOOL bValid = TRUE;
		if( !(bValid && loader.ReadValue( pListT->byValue )) )
			bValid = FALSE;

		if( !(bValid && loader.ReadString( pListT->pFileName, sizeof(pListT->pFileName) ) ) )
			bValid = FALSE;

		if( !(bValid && loader.ReadValue( pListT->bLoad ) ) )
			bValid = FALSE;

		if( !bValid )
		{
			dwReadedCount = i;
			break;
		}

		pListT++;
	}

	loader.Close();
}

BOOL
Encryption::OpenNrewrite(FileHandleInfo* p_FHI, 
						 SFiles* pListT, 
						 CHAR* pSrcBuffer, 
						 DWORD dwSize)
{
	if( !pListT )
		return FALSE;

	CHAR pszFullPath[MAX_PATH] = {0, };
	CHAR pszDirPath[128] = {0, };

	_snprintf( pszFullPath, MAX_PATH, "%s\\%s", m_FolderPath, pListT->pFileName );
	DeleteFile( pszFullPath );

	HANDLE hFILE = _OpenFile( pszFullPath, OF_CREATE);
	if( hFILE == INVALID_HANDLE_VALUE )
	{
		_MessageOut( pListT, RC_CONVERT_DECODE_SUCCESS, TRUE);
		return FALSE;
	}

	p_FHI->hFILE = hFILE;
	p_FHI->dwFileSize = dwSize;
	p_FHI->pSTREAM = pSrcBuffer;

	DWORD dwWritten = 0;
	WriteFile( hFILE, p_FHI->pSTREAM, p_FHI->dwFileSize, &dwWritten, NULL );
	FlushFileBuffers( hFILE );
	CloseHandle( hFILE );

	return TRUE;
}

BOOL
Encryption::OpenNread( FileHandleInfo* p_FHI, SFiles* pListT )
{
	if( !pListT )
		return FALSE;

	CHAR pszFullPath[MAX_PATH] = {0, };
	CHAR pszDirPath[128] = {0, };
	CHAR szEncrypted[5] = {0, };

	_snprintf( pszFullPath, MAX_PATH, "%s\\%s", m_FolderPath, pListT->pFileName );
	HANDLE hFILE = _OpenFile( pszFullPath, OF_READWRITE);
	if( hFILE == INVALID_HANDLE_VALUE )
	{
		_MessageOut( pListT, RC_CONVERT_DONT_OPEN_FILE, TRUE); // TRUE 縑楝
		return FALSE;
	}

	p_FHI->hFILE = hFILE;
	DWORD dwFileSize = GetFileSize( hFILE, NULL );
	p_FHI->dwFileSize = dwFileSize;
	p_FHI->pSTREAM = (CHAR*)malloc( dwFileSize );

	DWORD dwReaded;

	if( !ReadFile( hFILE, p_FHI->pSTREAM, dwFileSize, &dwReaded, NULL ) )
	{
		_MessageOut( pListT, RC_CONVERT_DONT_READ_FILE, TRUE); 
//		MSGOUT( "Can't Read File\n" );
		return FALSE;
	}

	strncpy(szEncrypted, p_FHI->pSTREAM, 4);
	szEncrypted[4] = 0;
	if( strcmp( szEncrypted, "WzCF") == 0 )
	{
		CloseHandle( p_FHI->hFILE);
		free( p_FHI->pSTREAM);
		_MessageOut( pListT, RC_CONVERT_CONVERTED, TRUE);

		return FALSE;
	}

	return TRUE;
}

//收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收
//	<MAIN LOGIC>
VOID
Encryption::TestUnit_FileList_EnDecode(BOOL bDecrypt/*=FALSE*/) // FALSE : 檣囀萄 TRUE : 蛤囀萄
{
	m_bEncrytion = bDecrypt;

	LoadScriptList();

	if( !bDecrypt )
	{
		SFiles* pListT = m_FileInfo.pList;
		for( DWORD d=0; d < m_FileInfo.dwLineCount; ++d )
		{
			if( pListT->bLoad )
			{
				FileHandleInfo FHI;
				if( OpenNread( &FHI, pListT))
				{
					EnterSect section( m_hSection);

					FileEncoder* pWriter = new FileEncoder();
					pWriter->WriteStart( FHI.hFILE, "data"/*pListT->pFileName*/ );
					pWriter->SetData( (BYTE*)FHI.pSTREAM, FHI.dwFileSize );
					pWriter->WriteEnd();
					free( FHI.pSTREAM );
					delete pWriter;

					_MessageOut( pListT, RC_CONVERT_SUCCESS);
				}
			}
			pListT++;
		}
	}

	if( bDecrypt )
	{
		SFiles* pListT = m_FileInfo.pList;
		for( DWORD d = 0 ; d < m_FileInfo.dwLineCount; ++d, ++pListT )
		{
			if( pListT->bLoad )
			{
				CHAR pszFullPath[MAX_PATH] = {0, };
				CHAR pszDirPath[128] = {0, };

				_snprintf( pszFullPath, MAX_PATH, "%s\\%s",pListT->pFileName );
				HANDLE hFILE = _OpenFile( pszFullPath, OF_READWRITE);
				if( hFILE == INVALID_HANDLE_VALUE )
				{
					_MessageOut( pListT, RC_CONVERT_DONT_OPEN_FILE, TRUE);
					continue;
				}

				CloseHandle( hFILE );

				{
					EnterSect section( m_hSection);

					FileDecoder* pReader = new FileDecoder();
					pReader->ReadStart( pszFullPath, "data"/*pListT->pFileName*/ );
					FileHandleInfo handleInfo;
					handleInfo.dwFileSize = pReader->GetSize();
					handleInfo.pSTREAM = new CHAR[handleInfo.dwFileSize];
					pReader->GetData( (BYTE*)handleInfo.pSTREAM, handleInfo.dwFileSize );
					pReader->ReadEnd();
					delete pReader;

					OpenNrewrite( &handleInfo, pListT, handleInfo.pSTREAM, handleInfo.dwFileSize );           
					free( handleInfo.pSTREAM );
					_MessageOut( pListT, RC_CONVERT_DECODE_SUCCESS);
				}
			}
		}
	}

	printf("Convert End\n");
}

VOID
Encryption::_MessageOut(SFiles* pListT, eRC_CONVERT error, BOOL bError/*FALSE*/) const
{
	static std::string strDecode("Decode");
	static std::string strIncode("Incode");
	DWORD dwError = 0;

	MSGOUT( "%s\tTYPE[%02d]\tFileName : %s, RC_CODE: %d", 
			( m_bEncrytion ? strIncode.c_str() : strDecode.c_str()), 
			pListT->byValue, pListT->pFileName, error );

	m_pResult->AddData( pListT->pFileName, error, m_bEncrytion);
}

HANDLE
Encryption::_OpenFile(const TCHAR *FullPath, DWORD mode) const
{
	OFSTRUCT pOF;

reopen:
	HANDLE hFILE = (HANDLE)(__int64)OpenFile( FullPath, &pOF, mode);
	if( hFILE == INVALID_HANDLE_VALUE )
	{
		if( GetFileAttributes( FullPath) && FILE_ATTRIBUTE_READONLY )	
			if( SetFileAttributes( FullPath, FILE_ATTRIBUTE_NORMAL))
				goto reopen;

		return hFILE;
	}

	return hFILE;
}

//VOID 
//Encryption::_MessageOut(const TCHAR* FileName, BOOL bError = FALSE) const
//{
//	static std::string strDecode("Decode");
//	static std::string strIncode("Incode");
//	DWORD dwError = 0;
//
//	MSGOUT( "%s\tTYPE[%02d]\tFileName : %s\n", 
//			( m_bEncrytion ? strDecode.c_str() : strIncode.c_str()), 
//			pListT->byValue, 
//			FileName );
//
//	if( bError )
//		dwError = GetLastError();
//
//	m_pResult->AddData( pListT->pFileName, dwError, m_bEncrytion);
//}