/*
 * (c) Copyright Ascensio System SIA 2010-2023
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */
#include "OfficeFileFormatChecker.h"

#include "../DesktopEditor/common/Directory.h"
#include "../DesktopEditor/xml/include/xmlutils.h"
#include "../OOXML/Base/Base.h"
#include "../OfficeUtils/src/OfficeUtils.h"

//#define FILE_FORMAT_CHECKER_WITH_MACRO
 
#if defined FILE_FORMAT_CHECKER_WITH_MACRO
	#include "../MsBinaryFile/PptFile/Main/PPTFormatLib.h"
 #endif

#include "3dParty/pole/pole.h"
#include <algorithm>
#include <limits>

#include "OfficeFileFormatDefines.h"

#define MIN_SIZE_BUFFER 4096
#define MAX_SIZE_BUFFER 102400

std::string ReadStringFromOle(POLE::Stream *stream, unsigned int max_size)
{
	std::string result;

	if (!stream)
		return result;

	_UINT32 cch = 0;
	if (4 != stream->read((BYTE *)&cch, 4))
		return result;

	unsigned char *stringBytes = new unsigned char[max_size];
	if (!stringBytes)
		return result;

	if (cch > max_size)
	{
		// error ... skip to 0
		unsigned int pos_orinal = (unsigned int)stream->tell();
		unsigned int pos = 0;

		stream->read(stringBytes, max_size);

		while (pos < max_size)
		{
			if (stringBytes[pos] == 0)
				break;
			pos++;
		}
		stream->seek(pos_orinal + pos - 1);
	}
	else
	{
		if (cch > 0)
		{
			// dont read the terminating zero
			cch = (_UINT32)stream->read(stringBytes, cch);
			result = std::string((char *)stringBytes, cch);
		}
	}
	RELEASEARRAYOBJECTS(stringBytes);
	// skip the terminating zero of the Unicode string
	stream->seek(stream->tell() + 2);

	return result;
}
bool COfficeFileFormatChecker::isRtfFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	if ((5 <= dwBytes) && ('{' == pBuffer[0] && '\\' == pBuffer[1] && 'r' == pBuffer[2] && 't' == pBuffer[3] && 'f' == pBuffer[4]))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isMultiPartsHtmlFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	const char *contentTypeFormatLine1 = "Content-Type: multipart/related";
	const char *contentTypeFormatLine2 = "Content-Type: text/html"; // может быть и вне заданого буфера (todooo)

	std::string xml_string((char *)pBuffer, dwBytes);

	if ((std::string::npos != xml_string.find(contentTypeFormatLine1)) && (std::string::npos != xml_string.find(contentTypeFormatLine2)))
	{
		return true;
	}
	return false;
}

bool COfficeFileFormatChecker::iXmlFile(const std::wstring &fileName)
{
	XmlUtils::CXmlLiteReader oReader;
	if (!oReader.FromFile(fileName))
		return false;
	if (!oReader.ReadNextNode())
		return false;

	std::wstring name = oReader.GetNameNoNS();

	if (name == L"svg")
	{
		nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_SVG;
	}
	else if (name == L"html")
	{
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML;
	}
	else
	{
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_XML;
	}

	return true;
}

bool COfficeFileFormatChecker::isHtmlFormatFile(unsigned char *pBuffer, int dwBytes, bool testCloseTag)
{
	if (pBuffer == NULL || dwBytes < 4)
		return false;

	bool tagOpen = false;

	if (testCloseTag && dwBytes > 5)
	{
		for (int i = 0; i < dwBytes - 6; i++)
		{
			if ((0x3C == pBuffer[i]) && (0x2F == pBuffer[i + 1]) && (0x48 == pBuffer[i + 2] || 0x68 == pBuffer[i + 2]) && (0x54 == pBuffer[i + 3] || 0x74 == pBuffer[i + 3]) &&
				(0x4d == pBuffer[i + 4] || 0x6d == pBuffer[i + 4]) && (0x4c == pBuffer[i + 5] || 0x6c == pBuffer[i + 5]))
			{
				return true;
			}
			else if (
				(0x3C == pBuffer[i]) && (0x2F == pBuffer[i + 1]) && (0x62 == pBuffer[i + 2]) && (0x6f == pBuffer[i + 3]) && (0x64 == pBuffer[i + 4]) && (0x79 == pBuffer[i + 5]) &&
				(0x3e == pBuffer[i + 6]))
			{ //</body>
				return true;
			}
		}
	}
	else if (dwBytes > 3)
	{
		for (int i = 0; i < dwBytes - 4 && i < 100; i++)
		{
			if (0x3C == pBuffer[i])
				tagOpen = true;
			else if (0x3E == pBuffer[i])
				tagOpen = false;
			else if (
				tagOpen && (0x48 == pBuffer[i] || 0x68 == pBuffer[i]) && (0x54 == pBuffer[i + 1] || 0x74 == pBuffer[i + 1]) && (0x4d == pBuffer[i + 2] || 0x6d == pBuffer[i + 2]) &&
				(0x4c == pBuffer[i + 3] || 0x6c == pBuffer[i + 3]))
			{
				return true;
			}
		}
	}
	return false;
}

bool COfficeFileFormatChecker::isBinaryDoctFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	if ((4 <= dwBytes) && ('D' == pBuffer[0] && 'O' == pBuffer[1] && 'C' == pBuffer[2] && 'Y' == pBuffer[3]))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isBinaryXlstFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	if ((4 <= dwBytes) && ('X' == pBuffer[0] && 'L' == pBuffer[1] && 'S' == pBuffer[2] && 'Y' == pBuffer[3]))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isBinaryPpttFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	if ((4 <= dwBytes) && ('P' == pBuffer[0] && 'P' == pBuffer[1] && 'T' == pBuffer[2] && 'Y' == pBuffer[3]))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isBinaryVsdtFormatFile(unsigned char* pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	if ((4 <= dwBytes) && ('V' == pBuffer[0] && 'S' == pBuffer[1] && 'D' == pBuffer[2] && 'Y' == pBuffer[3]))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isPdfFormatFile(unsigned char *pBuffer, int dwBytes, std::wstring &documentID)
{
	if (pBuffer == NULL)
		return false;

	documentID.clear();

	if (dwBytes < 5 || (pBuffer[0] == 'P' && pBuffer[1] == 'K'))
		return false;

	pBuffer[dwBytes - 1] = '\0';

	char *pFirst = strstr((char *)pBuffer, "%PDF-");

	if (NULL == pFirst)
	{
		char* pData = (char*)pBuffer;
		for (int i = 0; i < dwBytes - 5; ++i)
		{
			int nPDF = strncmp(&pData[i], "%PDF-", 5);
			if (!nPDF)
			{
				pFirst = (char*)pBuffer + i;
				break;
			}
		}
		if (NULL == pFirst)
		{
			//skip special
			_UINT16 sz = pBuffer[0] + (pBuffer[1] << 8);
			if (sz < dwBytes - 8)
			{
				pFirst = strstr((char*)(pBuffer + sz), "%PDF-");
			}
		}
	}
	if (NULL != pFirst)
	{
		pFirst = strstr((char *)pBuffer, "%DocumentID ");
		if (NULL != pFirst)
		{
			pFirst += 12;
			char *pLast = strstr(pFirst, " ");
			if (NULL != pLast)
			{
				std::string s(pFirst, pLast - pFirst);
				documentID = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pFirst, (LONG)(pLast - pFirst));
			}
		}
		return true;
	}

	return false;
}
bool COfficeFileFormatChecker::isPdfOformFormatFile(unsigned char *pBuffer, int dwBytes)
{
	pBuffer[dwBytes - 1] = 0;
	char* pFirst = strstr((char*)pBuffer, "%\315\312\322\251\015");

	if (!pFirst || pFirst - (char*)pBuffer + 6 >= dwBytes)
		return false;

	pFirst += 6;

	if (strncmp(pFirst, "1 0 obj\012<<\012", 11) != 0 || pFirst - (char*)pBuffer + 11 >= dwBytes)
		return false;

	pFirst += 11;

	char* pStream = strstr(pFirst, "stream\015\012");
	char* pMeta = strstr(pFirst, g_format_oform_pdf_meta_tag);
	if (!pStream || !pMeta || pStream < pMeta)
		return false;

	pMeta += strlen(g_format_oform_pdf_meta_tag) + 3;

	char* pMetaLast = strstr(pMeta, " ");
	if (!pMetaLast)
		return false;

	pMeta = pMetaLast + 1;
	pMetaLast = strstr(pMeta, " ");
	if (!pMetaLast)
		return false;

	return true;
}
bool COfficeFileFormatChecker::isOleObjectFile(POLE::Storage *storage)
{
	if (storage == NULL)
		return false;

	POLE::Stream streamOle(storage, L"Ole");

	if (false == streamOle.fail())
	{
		std::string UserType, ClipboardFormat, Program;

		POLE::Stream streamCompObject(storage, L"CompObj");
		if (false == streamCompObject.fail() && streamCompObject.size() >= 28)
		{
			streamCompObject.seek(28); // skip Header

			unsigned int sz_obj = (unsigned int)(streamCompObject.size() - streamCompObject.tell());

			if (sz_obj > 4)
			{
				UserType = ReadStringFromOle(&streamCompObject, sz_obj);

				sz_obj = (unsigned int)(streamCompObject.size() - streamCompObject.tell());
				if (sz_obj > 4)
					ClipboardFormat = ReadStringFromOle(&streamCompObject, sz_obj);

				sz_obj = (unsigned int)(streamCompObject.size() - streamCompObject.tell());
				if (sz_obj > 4)
					Program = ReadStringFromOle(&streamCompObject, sz_obj);
			}
			POLE::Stream streamPackage(storage, L"Package");
			if (false == streamPackage.fail())
			{
				nFileType = AVS_OFFICESTUDIO_FILE_OTHER_PACKAGE_IN_OLE;
			}
			else if (std::string::npos != Program.find("Excel") || std::string::npos != UserType.find("Excel"))
			{
				if (isXlsFormatFile(storage))
				{
					nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS;
				}
			}
			else if (std::string::npos != Program.find("Word") || std::string::npos != UserType.find("Word"))
			{
				if (isDocFormatFile(storage))
				{
					//nFileType inside
				}
			}
			else if (std::string::npos != Program.find("PowerPoint") || std::string::npos != UserType.find("PowerPoint"))
			{
				if (isPptFormatFile(storage))
				{
					nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT;
				}
			}

			return true;
		}
		else
		{
			POLE::Stream streamLinkInfo(storage, L"LinkInfo");
			if (false == streamLinkInfo.fail())
			{
				short cch = 0;
				if (2 == streamLinkInfo.read((BYTE *)&cch, 2))
				{
					unsigned char *str = new unsigned char[cch];
					cch = (short)streamLinkInfo.read(str, cch);

					ClipboardFormat = std::string((char *)str, cch);
					RELEASEARRAYOBJECTS(str);

					streamLinkInfo.seek(streamLinkInfo.tell() + 6);
					// skip ...
				}
				return true;
			}
		}
	}
	return false;
}
bool COfficeFileFormatChecker::isDocFormatFile(POLE::Storage *storage)
{
	if (storage == NULL)
		return false;

	POLE::Stream stream(storage, L"WordDocument");

	unsigned char buffer[64];
	memset(buffer, 0, 64);

	if (stream.read(buffer, 64) > 0)
	{
		// ms office 2007 encrypted contains stream WordDocument !!
		std::list<std::wstring> entries = storage->entries(L"DataSpaces");
		if (entries.size() > 0)
			return false;

		if ((buffer[0] == 0xEC && buffer[1] == 0xA5) || // word 1997-2003
			(buffer[0] == 0xDC && buffer[1] == 0xA5) || // word 1995
			(buffer[0] == 0xDB && buffer[1] == 0xA5))	// word 2.0
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC;
		}
		else if (isHtmlFormatFile(buffer, 64, false))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML_IN_CONTAINER;
			return true;
		}
		if (storage->isDirectory(L"Macros"))
		{
			bMacroEnabled = true;
		}
		return true;
	}

	return false;
}
bool COfficeFileFormatChecker::isVbaProjectFile(POLE::Storage *storage)
{
	if (storage == NULL)
		return false;

	unsigned char buffer[10];

	POLE::Stream stream(storage, L"PROJECT");
	if (stream.read(buffer, 10) < 1)
	{
		return false;
	}
	if (false == storage->isDirectory(L"VBA"))
	{
		return false;
	}
	POLE::Stream stream2(storage, L"VBA/dir");
	if (stream2.read(buffer, 10) < 1)
	{
		return false;
	}
	return true;
}
bool COfficeFileFormatChecker::isHwpFile(POLE::Storage* storage)
{
	if (storage == NULL)
		return false;

	unsigned char buffer[17];

	POLE::Stream stream(storage, L"FileHeader");

	static constexpr const char* hwpFormatLine = "HWP Document File";

	if (17 == stream.read(buffer, 17) && NULL != strstr((char*)buffer, hwpFormatLine))
		return true;

	return false;
}

bool COfficeFileFormatChecker::isXlsFormatFile(POLE::Storage *storage)
{
	if (storage == NULL)
		return false;

	unsigned char buffer[10];

	POLE::Stream stream(storage, L"Workbook");

	if (stream.read(buffer, 10) < 1)
	{
		POLE::Stream stream2(storage, L"Book");

		if (stream2.read(buffer, 10) < 1)
		{
			POLE::Stream stream3(storage, L"WORKBOOK");

			if (stream3.read(buffer, 10) < 1)
			{
				POLE::Stream stream4(storage, L"BOOK");

				if (stream4.read(buffer, 10) < 1)
				{
					POLE::Stream stream5(storage, L"book");

					if (stream5.read(buffer, 10) < 1)
						return false;
				}
			}
		}
	}
	if (storage->isDirectory(L"_VBA_PROJECT_CUR"))
	{
		bMacroEnabled = true;
	}
	return true;
}
bool COfficeFileFormatChecker::isDocFlatFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL || dwBytes < 2)
		return false;

	if ((pBuffer[0] == 0xEC && pBuffer[1] == 0xA5) || (pBuffer[0] == 0xDC && pBuffer[1] == 0xA5) || (pBuffer[0] == 0xDB && pBuffer[1] == 0xA5))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isXlsFlatFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL || dwBytes < 2)
		return false;

	// BOF started
	if ((pBuffer[1] == 0x08 && pBuffer[0] == 0x09) || (pBuffer[1] == 0x04 && pBuffer[0] == 0x09) || (pBuffer[1] == 0x02 && pBuffer[0] == 0x09) ||
		(pBuffer[2] == 0x04 && pBuffer[0] == 0x09 && pBuffer[1] == 0x00 && pBuffer[3] == 0x00))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isPptFormatFile(POLE::Storage *storage)
{
	if (storage == NULL)
		return false;

	POLE::Stream stream(storage, L"PowerPoint Document");

	unsigned char buffer[10];
	if (stream.read(buffer, 10) < 1)
		return false;

	return true;
}

std::wstring COfficeFileFormatChecker::getDocumentID(const std::wstring &_fileName)
{
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(_WIN64)
	std::wstring fileName = CorrectPathW(_fileName);
#else
	std::wstring fileName = _fileName;
#endif
	std::wstring documentID;

	POLE::Storage storage(fileName.c_str());
	if (storage.open())
	{
		if (isMS_OFFICECRYPTOFormatFile(&storage, documentID))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_OFFCRYPTO;
		}
		else if (isMS_MITCRYPTOFormatFile(&storage, documentID))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_MITCRYPTO;
		}
	}
	else
	{
		if (false == isOpenOfficeFormatFile(fileName, documentID))
		{
			NSFile::CFileBinary file;
			if (!file.OpenFile(fileName))
				return documentID;

			unsigned char *buffer = new unsigned char[4096]; // enaf !!
			if (!buffer)
			{
				file.CloseFile();
				return documentID;
			}

			DWORD dwReadBytes = 0;
			file.ReadFile(buffer, MIN_SIZE_BUFFER, dwReadBytes);
			file.CloseFile();

			if (isPdfFormatFile(buffer, (int)dwReadBytes, documentID))
			{
				nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF;
			}
		}
	}
	sDocumentID = documentID;

	return documentID;
}

bool COfficeFileFormatChecker::isMS_OFFCRYPTOFormatFile(const std::wstring &_fileName, std::wstring &documentID)
{
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(_WIN64)
	std::wstring fileName = CorrectPathW(_fileName);
#else
	std::wstring fileName = _fileName;
#endif

	POLE::Storage storage(fileName.c_str());
	if (storage.open())
	{
		if (isMS_OFFICECRYPTOFormatFile(&storage, documentID))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_OFFCRYPTO;
			return true;
		}
		if (isMS_MITCRYPTOFormatFile(&storage, documentID))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_MITCRYPTO;
			return true;
		}
	}
	return false;
}
bool COfficeFileFormatChecker::isMS_OFFICECRYPTOFormatFile(POLE::Storage *storage, std::wstring &documentID)
{
	if (storage == NULL)
		return false;

	documentID.clear();

	bool result = false;
	std::list<std::wstring> entries = storage->entries(L"DataSpaces");
	if (/*false == entries.empty() && */ storage->exists(L"EncryptionInfo"))
	{
		result = true;
	}

	if (result)
	{
		POLE::Stream stream(storage, L"DocumentID");

		std::string sData;
		sData.resize(stream.size());
		if (stream.read((BYTE *)sData.c_str(), stream.size()) > 0)
		{
			documentID = UTF8_TO_U(sData);
		}
	}
	return result;
}

bool COfficeFileFormatChecker::isMS_MITCRYPTOFormatFile(POLE::Storage *storage, std::wstring &documentID)
{
	if (storage == NULL)
		return false;

	documentID.clear();

	bool result = false;
	std::list<std::wstring> entries = storage->entries(L"DataSpaces");
	if (false == entries.empty() && false == storage->exists(L"EncryptionInfo") && storage->exists(L"EncryptedPackage"))
	{
		result = true;
	}

	return result;
}
bool COfficeFileFormatChecker::isVbaProjectFile(const std::wstring &_fileName)
{
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(_WIN64)
	std::wstring fileName = CorrectPathW(_fileName);
#else
	std::wstring fileName = _fileName;
#endif
	POLE::Storage storage(fileName.c_str());
	if (storage.open())
	{
		if (isVbaProjectFile(&storage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT;
			return true;
		}
	}
	return false;
}
bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
{
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(_WIN64)
	std::wstring fileName = CorrectPathW(_fileName);
#else
	std::wstring fileName = _fileName;
#endif

	// приоритет как оказывается важен
	// Metamorphic Manual for windows 28415.doc
	POLE::Storage storage(fileName.c_str());
	if (storage.open())
	{
		if (isOleObjectFile(&storage))
		{
			if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
				return true;
			return false;
		}
		else if (isDocFormatFile(&storage))
		{
			// nFileType внутри
			return true;
		}
		else if (isXlsFormatFile(&storage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS;
			return true;
		}
		else if (isPptFormatFile(&storage))
		{
			// #if defined FILE_FORMAT_CHECKER_WITH_MACRO
			//			COfficePPTFile pptFile;
			//
			//			bMacroEnabled = true;
			//			long nResult = pptFile.OpenFile(fileName, L"", bMacroEnabled);
			//			if (nResult != S_OK)
			//			{
			//				return false;
			//			}
			//			pptFile.CloseFile();
			// #endif
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT;
			return true;
		}
		else if (isMS_OFFICECRYPTOFormatFile(&storage, sDocumentID))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_OFFCRYPTO;
			return true;
		}
		else if (isMS_MITCRYPTOFormatFile(&storage, sDocumentID))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_MITCRYPTO;
			return true;
		}
		else if (isVbaProjectFile(&storage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT;
			return true;
		}
		else if (isHwpFile(&storage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP;
			return true;
		}
	}
	NSFile::CFileBinary file;
	if (!file.OpenFile(fileName))
		return false;

	unsigned char* bufferDetect = new unsigned char[4096]; // enaf !!
	if (!bufferDetect)
	{
		file.CloseFile();
		return false;
	}

	DWORD dwDetectdBytes = 0;
	file.ReadFile(bufferDetect, MIN_SIZE_BUFFER, dwDetectdBytes);

	COfficeUtils OfficeUtils(NULL);
	if (OfficeUtils.IsArchive(fileName) == S_OK && (false == isPdfFormatFile(bufferDetect, dwDetectdBytes, sDocumentID)))
	{
		if (isOOXFormatFile(fileName))
        {
            if (bufferDetect)
                delete[] bufferDetect;
            bufferDetect = NULL;
			return true;
        }
		else if (isOpenOfficeFormatFile(fileName, sDocumentID))
        {
            if (bufferDetect)
                delete[] bufferDetect;
            bufferDetect = NULL;
            return true;
        }
		else if (isOnlyOfficeFormatFile(fileName))
        {
            if (bufferDetect)
                delete[] bufferDetect;
            bufferDetect = NULL;
            return true;
        }
		else if (isXpsFile(fileName))
        {
            if (bufferDetect)
                delete[] bufferDetect;
            bufferDetect = NULL;
            return true;
        }
		else if (isOFDFile(fileName))
		{
			if (bufferDetect)
				delete[] bufferDetect;
			bufferDetect = NULL;
			return true;
		}
		else if (isMacFormatFile(fileName))
		{
			if (bufferDetect)
				delete[] bufferDetect;
			bufferDetect = NULL;
			return true;
		}
		else if (isHwpxFile(fileName))
		{
			if (bufferDetect)
				delete[] bufferDetect;
			bufferDetect = NULL;
			return true;
		}
	}

	//-----------------------------------------------------------------------------------------------
	// others

	bool bEmptyFile = false;
	{
		int sizeRead = (int)dwDetectdBytes;

		bEmptyFile = (dwDetectdBytes < 1);

		if (isBinaryDoctFormatFile(bufferDetect, sizeRead)) // min size - 4
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_WORD;
		}
		else if (isBinaryXlstFormatFile(bufferDetect, sizeRead)) // min size - 4
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_SPREADSHEET;
		}
		else if (isBinaryPpttFormatFile(bufferDetect, sizeRead)) // min size - 4
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_PRESENTATION;
		}
		else if (isBinaryVsdtFormatFile(bufferDetect, sizeRead)) // min size - 4
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_DRAW;
		}
		else if (isOOXFlatFormatFile(bufferDetect, sizeRead))
		{
			// nFileType;
		}
		else if (isRtfFormatFile(bufferDetect, sizeRead)) // min size - 5
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_RTF;
		}
		else if (isPdfFormatFile(bufferDetect, sizeRead, sDocumentID)) // min size - 5
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF;

			if (isPdfOformFormatFile(bufferDetect, sizeRead))
				nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM_PDF;
		}
		else if (isDjvuFormatFile(bufferDetect, sizeRead)) // min size - 8
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU;
		}
		else if (isHtmlFormatFile(bufferDetect, sizeRead, false)) // min size - 4
		{
			long fileSize = file.GetFileSize();
			if (fileSize > MIN_SIZE_BUFFER)
			{
				file.SeekFile(fileSize - MIN_SIZE_BUFFER);
				file.ReadFile(bufferDetect, MIN_SIZE_BUFFER, dwDetectdBytes);
			}
			if (isHtmlFormatFile(bufferDetect, sizeRead, true)) // min size - 6
			{
				nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML;
			}
		}
		else if (isFB2FormatFile(bufferDetect, sizeRead)) // min size - 11
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_FB2;
		}
		else if (isOpenOfficeFlatFormatFile(bufferDetect, sizeRead)) // min size - 78
		{
			// nFileType
		}
		else if (isDocFlatFormatFile(bufferDetect, sizeRead)) // min size - 2
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC_FLAT; // without compaund container
		}
		else if (isXlsFlatFormatFile(bufferDetect, sizeRead)) // min size - 2
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS; // without compaund container
		}
		else if (isMultiPartsHtmlFormatFile(bufferDetect, sizeRead))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_MHT;
		}
		else if (isHwpmlFile(bufferDetect, sizeRead))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPML;
		}
		//------------------------------------------------------------------------------------------------
		file.CloseFile();
	}
	if (bufferDetect)
		delete[] bufferDetect;
	bufferDetect = NULL;

	if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
		return true;
	//------------------------------------------------------------------------------------------------
	if (iXmlFile(fileName))
	{
		// nFileType внутри
		return true;
	}
	//// by Extension

	std::wstring::size_type nExtPos = fileName.rfind(L'.');
	std::wstring sExt = L"unknown";

	if (nExtPos != std::wstring::npos)
		sExt = fileName.substr(nExtPos);

	std::transform(sExt.begin(), sExt.end(), sExt.begin(), tolower);

	if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
		return true;

	if (bEmptyFile)
	{
		if (0 == sExt.compare(L".xlsx"))
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
		else if (0 == sExt.compare(L".docx"))
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX;
		else if (0 == sExt.compare(L".pptx"))
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX;
		else if (0 == sExt.compare(L".vsxd"))
			nFileType = AVS_OFFICESTUDIO_FILE_DRAW_VSDX;
		else if (0 == sExt.compare(L".ods"))
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS;
		else if (0 == sExt.compare(L".odt"))
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT;
		else if (0 == sExt.compare(L".odp"))
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP;
	}
	else if (0 == sExt.compare(L".mht") || 0 == sExt.compare(L".mhtml"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_MHT;
	else if (0 == sExt.compare(L".md"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_MD;
	else if (0 == sExt.compare(L".csv") || 0 == sExt.compare(L".xls") || 0 == sExt.compare(L".xlsx") || 0 == sExt.compare(L".xlsb"))
		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV;
	else if (0 == sExt.compare(L".html") || 0 == sExt.compare(L".htm"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML;
	else if (0 == sExt.compare(L".bin")) // base64 string
		nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_PDF;
	else if (0 == sExt.compare(L".doct")) // случай архива с html viewer
		nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY;
	else if (0 == sExt.compare(L".txt") || 0 == sExt.compare(L".xml") || 0 == sExt.compare(L".rtf")	|| 0 == sExt.compare(L".doc") || 0 == sExt.compare(L".docx"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT;
	else if (0 == sExt.compare(L".pages"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
	else if (0 == sExt.compare(L".numbers"))
		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;
	else if (0 == sExt.compare(L".key"))
		nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;
	else if (0 == sExt.compare(L".hwp"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP;
	else if (0 == sExt.compare(L".hwpx"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX;
	else if (0 == sExt.compare(L".hml"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPML;

	if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
		return true;

	return false;
}
bool COfficeFileFormatChecker::isOOXFormatFile(const std::wstring &fileName, bool unpacked)
{
	COfficeUtils OfficeUtils(NULL);

	ULONG nBufferSize = 0;
	BYTE *pBuffer = NULL;

	HRESULT hresult = S_FALSE;

	if (unpacked)
	{
		if (NSFile::CFileBinary::ReadAllBytes(fileName + FILE_SEPARATOR_STR + L"[Content_Types].xml", &pBuffer, nBufferSize))
			hresult = S_OK;
	}
	else
	{
		hresult = OfficeUtils.LoadFileFromArchive(fileName, L"[Content_Types].xml", &pBuffer, nBufferSize);
	}
	if (hresult == S_OK && pBuffer != NULL)
	{

		const char *docxFormatLine = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
		const char *dotxFormatLine = "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml";
		const char *docmFormatLine = "application/vnd.ms-word.document.macroEnabled.main+xml";
		const char *dotmFormatLine = "application/vnd.ms-word.template.macroEnabledTemplate.main+xml";
		const char *oformFormatLine = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.oform";
		const char *docxfFormatLine = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.docxf";

		const char *xlsxFormatLine = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml";
		const char *xltxFormatLine = "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml";
		const char *xlsmFormatLine = "application/vnd.ms-excel.sheet.macroEnabled.main+xml";
		const char *xltmFormatLine = "application/vnd.ms-excel.template.macroEnabled.main+xml";
		const char *xlsbFormatLine = "application/vnd.ms-excel.sheet.binary.macroEnabled.main";

		const char *pptxFormatLine = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml";
		const char *ppsxFormatLine = "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml";
		const char *potxFormatLine = "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml";
		const char *pptmFormatLine = "application/vnd.ms-powerpoint.presentation.macroEnabled.main+xml";
		const char *ppsmFormatLine = "application/vnd.ms-powerpoint.slideshow.macroEnabled.main+xml";
		const char *potmFormatLine = "application/vnd.ms-powerpoint.template.macroEnabled.main+xml";

		const char *vsdxFormatLine = "application/vnd.ms-visio.drawing.main+xml";
		const char *vssxFormatLine = "application/vnd.ms-visio.stencil.main+xml";
		const char *vstxFormatLine = "application/vnd.ms-visio.template.main+xml";
		const char *vsdmFormatLine = "application/vnd.ms-visio.drawing.macroEnabled.main+xml";
		const char *vssmFormatLine = "application/vnd.ms-visio.stencil.macroEnabled.main+xml";
		const char *vstmFormatLine = "application/vnd.ms-visio.template.macroEnabled.main+xml";

		std::string strContentTypes((char*)pBuffer, nBufferSize);

		if (std::string::npos != strContentTypes.find(oformFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM;
		}
		else if (std::string::npos != strContentTypes.find(docxfFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCXF;
		}
		else if (std::string::npos != strContentTypes.find(docxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX;
		}
		else if (std::string::npos != strContentTypes.find(docmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(dotxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX;
		}
		else if (std::string::npos != strContentTypes.find(dotmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(xlsxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
		}
		else if (std::string::npos != strContentTypes.find(xlsmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(xltxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX;
		}
		else if (std::string::npos != strContentTypes.find(xltmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(xlsbFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(pptxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX;
		}
		else if (std::string::npos != strContentTypes.find(pptmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(ppsmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(ppsxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX;
		}
		else if (std::string::npos != strContentTypes.find(potxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX;
		}
		else if (std::string::npos != strContentTypes.find(potmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(vsdxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DRAW_VSDX;
		}
		else if (std::string::npos != strContentTypes.find(vssxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DRAW_VSSX;
		}
		else if (std::string::npos != strContentTypes.find(vstxFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DRAW_VSTX;
		}
		else if (std::string::npos != strContentTypes.find(vsdmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DRAW_VSDM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(vssmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DRAW_VSSM;
			bMacroEnabled = true;
		}
		else if (std::string::npos != strContentTypes.find(vstmFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DRAW_VSTM;
			bMacroEnabled = true;
		}
		delete []pBuffer;
		pBuffer = NULL;

		if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
			return true;
	}
	return false;
}
bool COfficeFileFormatChecker::isDocFormatFile(const std::wstring &fileName)
{
	POLE::Storage storage(fileName.c_str());
	if (storage.open())
	{
		if (isDocFormatFile(&storage))
		{
			// nFileType внутри;
			return true;
		}
	}
	return false;
}
bool COfficeFileFormatChecker::isXlsFormatFile(const std::wstring &fileName)
{
	POLE::Storage storage(fileName.c_str());
	if (storage.open())
	{
		if (isXlsFormatFile(&storage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS;
			return true;
		}
	}
	return false;
}
bool COfficeFileFormatChecker::isOnlyOfficeFormatFile(const std::wstring &fileName)
{
	COfficeUtils OfficeUtils(NULL);

	ULONG nBufferSize = 128; // ограничим считывание из бинарника
	BYTE *pBuffer = NULL;

	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"Editor.bin", &pBuffer, nBufferSize);
	if (hresult == S_OK && pBuffer != NULL)
	{
		if (isBinaryDoctFormatFile(pBuffer, nBufferSize))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY;
		}
		else if (isBinaryXlstFormatFile(pBuffer, nBufferSize))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY;
		}
		else if (isBinaryPpttFormatFile(pBuffer, nBufferSize))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY;
		}
		else if (isBinaryVsdtFormatFile(pBuffer, nBufferSize))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_VSDY;
		}

		delete[] pBuffer;
		pBuffer = NULL;

		if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
			return true;
	}
	return false;
}

struct TIWAField
{
	size_t m_unStart;
	size_t m_unEnd;
	unsigned m_uIndex;
	unsigned m_unWireType;
	uint64_t m_oValue;
};

bool ReadUVar(BYTE* pBuffer, size_t unEndPos, size_t& unPos, uint64_t& unValue)
{
	std::vector<unsigned char> arBytes;
	arBytes.reserve(8);

	unValue = 0;

	bool bNext = true;
	while (unPos < unEndPos && bNext)
	{
		const unsigned char c = pBuffer[unPos++];
		arBytes.push_back((unsigned char)(c & ~0x80));
		bNext = c & 0x80;
	}

	if (bNext && unPos == unEndPos)
		return false;

	for (std::vector<unsigned char>::const_reverse_iterator it = arBytes.rbegin(); it != arBytes.rend(); ++it)
	{
		if (std::numeric_limits<uint64_t>::max() >> 7 < unValue ||
		    std::numeric_limits<uint64_t>::max() - (unValue << 7) < *it) // overflow
		return false;

		unValue = (unValue << 7) + *it;
	}

	return true;
}

bool ReadIWAField(BYTE* pBuffer, size_t unEndPos, size_t& unPos, TIWAField& oIWAField)
{
	if (NULL == pBuffer || unPos + 2 > unEndPos)
		return false;

	unsigned uSpec;

	uSpec = (unsigned)pBuffer[unPos++];
	oIWAField.m_unWireType = uSpec & 0x7;

	oIWAField.m_unStart = unPos;

	switch (oIWAField.m_unWireType)
	{
		case 0:
		{
			if (!ReadUVar(pBuffer, unEndPos, unPos, oIWAField.m_oValue))
				return false;

			break;
		}
		case 1:
		{
			unPos += 4;
			break;
		}
		case 2:
		{
			uint64_t unLen;
			if (!ReadUVar(pBuffer, unEndPos, unPos, unLen) || unPos + unLen > unEndPos)
				return false;

			oIWAField.m_unStart = unPos;
			unPos += unLen;
			break;
		}
		case 5:
		{
			unPos += 2;
			break;
		}
		default:
			return false;
	}

	oIWAField.m_unEnd = unPos;
	oIWAField.m_uIndex = uSpec >> 3;

	return true;
}

bool DetectIWorkFormat(const std::wstring& fileName, int &nType)
{
	COfficeUtils OfficeUtils(NULL);

	ULONG unSize = 0;
	BYTE* pBuffer = NULL;

	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"Index/Document.iwa", &pBuffer, unSize);

	if (hresult != S_OK || NULL == pBuffer)
		return false;

	#define CLEAR_BUFFER_AND_RETURN(return_value)\
	do{\
		delete[] pBuffer;\
		return return_value;\
	}while(false)

	if (unSize < 13)
		CLEAR_BUFFER_AND_RETURN(false);

	size_t uPos = 6;

	for (; uPos < 12; ++uPos)
	{
		if (0x08 == pBuffer[uPos] && 0x01 == pBuffer[uPos + 1])
		{
			--uPos;
			break;
		}
	}

	if (12 == uPos)
		CLEAR_BUFFER_AND_RETURN(false);

	uint64_t unHeaderLen;
	if (!ReadUVar(pBuffer, unSize, uPos, unHeaderLen))
		CLEAR_BUFFER_AND_RETURN(false);

	const size_t uStartPos = uPos;

	if (unHeaderLen < 8 || unSize < unHeaderLen + uStartPos)
		CLEAR_BUFFER_AND_RETURN(false);

	uPos += 2;

	TIWAField oMessageField;

	if (!ReadIWAField(pBuffer, uStartPos + unHeaderLen, uPos, oMessageField) || 2 != oMessageField.m_unWireType ||
	    2 != oMessageField.m_uIndex)
		CLEAR_BUFFER_AND_RETURN(false);

	size_t uSubPos = oMessageField.m_unStart;
	TIWAField oField;

	if (!ReadIWAField(pBuffer, oMessageField.m_unEnd, uSubPos, oField) || 0 != oField.m_unWireType ||
	    1 != oField.m_uIndex)
		CLEAR_BUFFER_AND_RETURN(false);

	switch (oField.m_oValue)
	{
		case 1:
		{
			uint32_t unDataLen = 0;

			TIWAField oTempField;
			if (ReadIWAField(pBuffer, oMessageField.m_unEnd, uSubPos, oTempField) &&
			    ReadIWAField(pBuffer, oMessageField.m_unEnd, uSubPos, oTempField) && 0 == oTempField.m_unWireType &&
			    3 == oTempField.m_uIndex)
				unDataLen += oTempField.m_oValue;

			size_t unTempPos = uStartPos + unHeaderLen;

			// keynote: presentation ref in 2
			// number: sheet ref in 1
			if (ReadIWAField(pBuffer, uStartPos + unDataLen, unTempPos, oTempField) &&
			    (2 != oTempField.m_unWireType || 1 != oTempField.m_uIndex || oTempField.m_unEnd - oTempField.m_unStart < 2))
			{
				nType = AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;
				CLEAR_BUFFER_AND_RETURN(true);
			}
			else if (ReadIWAField(pBuffer, uStartPos + unDataLen, unTempPos, oTempField) &&
			        (2 != oTempField.m_unWireType || 2 != oTempField.m_uIndex || oTempField.m_unEnd - oTempField.m_unStart < 2))
			{
				nType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;
				CLEAR_BUFFER_AND_RETURN(true);
			}

			break;
		}
		case 10000:
		{
			nType = AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
			CLEAR_BUFFER_AND_RETURN(true);
		}
	}

	CLEAR_BUFFER_AND_RETURN(false);
}

bool COfficeFileFormatChecker::isMacFormatFile(const std::wstring& fileName)
{
	if (DetectIWorkFormat(fileName, nFileType))
		return true;

	std::wstring::size_type nExtPos = fileName.rfind(L'.');
	std::wstring sExt = L"unknown";

	if (nExtPos != std::wstring::npos)
		sExt = fileName.substr(nExtPos);

	std::transform(sExt.begin(), sExt.end(), sExt.begin(), tolower);

	if (0 == sExt.compare(L".pages"))
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
	else if (0 == sExt.compare(L".numbers"))
		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;
	else if (0 == sExt.compare(L".key"))
		nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;
	else
		return false;

	return true;
}

bool COfficeFileFormatChecker::isHwpxFile(const std::wstring &fileName)
{
	COfficeUtils oOfficeUtils;
	
	ULONG unSize = 0;
	BYTE* pBuffer = NULL;

	HRESULT hresult = oOfficeUtils.LoadFileFromArchive(fileName, L"mimetype", &pBuffer, unSize);

	if (hresult != S_OK || NULL == pBuffer)
		return false;

	static constexpr const char* hwpxFormatLine = "application/hwp+zip";
	bool bResult = false;
	
	if (19 <= unSize && NULL != strstr((char *)pBuffer, hwpxFormatLine))
	{
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX;
		bResult = true;
	}

	delete[] pBuffer;
	return bResult;
}

bool COfficeFileFormatChecker::isOpenOfficeFormatFile(const std::wstring &fileName, std::wstring &documentID)
{
	documentID.clear();

	const char *odtFormatLine = "application/vnd.oasis.opendocument.text";
	const char *odsFormatLine = "application/vnd.oasis.opendocument.spreadsheet";
	const char *odpFormatLine = "application/vnd.oasis.opendocument.presentation";
	const char* odgFormatLine = "application/vnd.oasis.opendocument.graphics";
	const char *ottFormatLine = "application/vnd.oasis.opendocument.text-template";
	const char *otsFormatLine = "application/vnd.oasis.opendocument.spreadsheet-template";
	const char *otpFormatLine = "application/vnd.oasis.opendocument.presentation-template";
	const char *epubFormatLine = "application/epub+zip";
	const char *sxwFormatLine = "application/vnd.sun.xml.writer";
	const char *sxcFormatLine = "application/vnd.sun.xml.calc";
	const char *sxiFormatLine = "application/vnd.sun.xml.impress";

	COfficeUtils OfficeUtils(NULL);

	ULONG nBufferSize = 0;
	BYTE *pBuffer = NULL;

	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"documentID", &pBuffer, nBufferSize);
	if (hresult == S_OK && pBuffer != NULL)
	{
		documentID = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8(pBuffer, nBufferSize);

		delete[] pBuffer;
		pBuffer = NULL;
	}

	nBufferSize = 0;
	hresult = OfficeUtils.LoadFileFromArchive(fileName, L"mimetype", &pBuffer, nBufferSize);
	if (hresult == S_OK && pBuffer != NULL)
	{
		if (48 <= nBufferSize && NULL != strstr((char *)pBuffer, ottFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_OTT;
		}
		else if (55 <= nBufferSize && NULL != strstr((char *)pBuffer, otsFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS;
		}
		else if (56 <= nBufferSize && NULL != strstr((char *)pBuffer, otpFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_OTP;
		}
		else if ((39 <= nBufferSize && NULL != strstr((char *)pBuffer, odtFormatLine)) ||
				(30 <= nBufferSize && NULL != strstr((char *)pBuffer, sxwFormatLine)))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT;
		}
		else if ((46 <= nBufferSize && NULL != strstr((char *)pBuffer, odsFormatLine)) || 
				(28 <= nBufferSize && NULL != strstr((char *)pBuffer, sxcFormatLine)))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS;
		}
		else if ((47 <= nBufferSize && NULL != strstr((char *)pBuffer, odpFormatLine)) || 
				(31 <= nBufferSize && NULL != strstr((char *)pBuffer, sxiFormatLine)))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP;
		}
		else if (43 <= nBufferSize && NULL != strstr((char*)pBuffer, odgFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_ODG;
		}
		else if (20 <= nBufferSize && NULL != strstr((char *)pBuffer, epubFormatLine))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_EPUB;
		}

		delete[] pBuffer;
		pBuffer = NULL;

		if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
			return true;
	}
	else
	{
		// если не записан тип смотрим манифест
		nBufferSize = 0;
		HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"META-INF/manifest.xml", &pBuffer, nBufferSize);
		if (hresult == S_OK && pBuffer != NULL)
		{
			std::string xml_string((char *)pBuffer, nBufferSize);

			std::string::size_type nFindMem1 = xml_string.find(odtFormatLine);
			std::string::size_type nFindMem2 = xml_string.find(odsFormatLine);
			std::string::size_type nFindMem3 = xml_string.find(odpFormatLine);

			if (nFindMem1 != std::string::npos && nFindMem2 != std::string::npos)
			{
				if (nFindMem1 < nFindMem2)
					nFindMem2 = std::string::npos;
				else
					nFindMem1 = std::string::npos;
			}
			if (nFindMem1 != std::string::npos && nFindMem3 != std::string::npos)
			{
				if (nFindMem1 < nFindMem3)
					nFindMem3 = std::string::npos;
				else
					nFindMem1 = std::string::npos;
			}
			if (nFindMem2 != std::string::npos && nFindMem3 != std::string::npos)
			{
				if (nFindMem2 < nFindMem3)
					nFindMem3 = std::string::npos;
				else
					nFindMem2 = std::string::npos;
			}

			if (nFindMem1 != std::string::npos)
				nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT;
			else if (nFindMem2 != std::string::npos)
				nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS;
			else if (nFindMem3 != std::string::npos)
				nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP;

			delete[] pBuffer;
			pBuffer = NULL;

			if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
				return true;
		}
	}
	return false;
}

bool COfficeFileFormatChecker::isOpenOfficeFlatFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (dwBytes < 78)
		return false;

	const char *odfFormatLine1 = "office:document";
	const char *odfFormatLine2 = "xmlns:office=\"urn:oasis:names:tc:opendocument:xmlns:office:1.0\"";

	std::string xml_string((char *)pBuffer, dwBytes);

	if ((std::string::npos == xml_string.find(odfFormatLine1)) || (std::string::npos == xml_string.find(odfFormatLine2)))
	{
		return false;
	}

	const char *odtFormatLine = "application/vnd.oasis.opendocument.text";
	const char *odsFormatLine = "application/vnd.oasis.opendocument.spreadsheet";
	const char *odpFormatLine = "application/vnd.oasis.opendocument.presentation";

	if (std::string::npos != xml_string.find(odtFormatLine))
	{
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT_FLAT;
	}
	else if (std::string::npos != xml_string.find(odsFormatLine))
	{
		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS_FLAT;
	}
	else if (std::string::npos != xml_string.find(odpFormatLine))
	{
		nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP_FLAT;
	}

	if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
		return true;

	return false;
}

bool COfficeFileFormatChecker::isHwpmlFile(unsigned char *pBuffer, int dwBytes)
{
	if (NULL == pBuffer || dwBytes < 8)
		return false;

	for (unsigned int unPos = 0; unPos < dwBytes - 8; ++unPos)
	{
		if ('<' != pBuffer[unPos])
			continue;

		if (dwBytes - unPos >= 15 && '!' == pBuffer[unPos + 1] &&
		     0 == memcmp(&pBuffer[unPos], "<!DOCTYPE HWPML", 15))
			return true;

		if (dwBytes - unPos >= 6 && 0 == memcmp(&pBuffer[unPos], "<HWPML", 6))
			return true;
	}

	return false;
}

bool COfficeFileFormatChecker::isOOXFlatFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (dwBytes < 8)
		return false;

	std::string xml_string;
	if (pBuffer[0] == 0xff && pBuffer[1] == 0xfe)
	{ // utf-16- little
		std::wstring xml_wstring = NSFile::CUtf8Converter::GetWStringFromUTF16((unsigned short *)pBuffer, dwBytes / 2);
		xml_string = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(xml_wstring);
	}
	else if (pBuffer[0] == 0xfe && pBuffer[1] == 0xff)
	{ // utf-16- big
	  // swap bytes
		DWORD file_size_round = (dwBytes / 2) * 2;
		for (DWORD i = 0; i < file_size_round; i += 2)
		{
			char v = pBuffer[i];
			pBuffer[i] = pBuffer[i + 1];
			pBuffer[i + 1] = v;
		}
		std::wstring xml_wstring = NSFile::CUtf8Converter::GetWStringFromUTF16((unsigned short *)pBuffer, dwBytes / 2);
		xml_string = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(xml_wstring);
	}
	else
		xml_string = std::string((char *)pBuffer, dwBytes);

	const char *docxFormatLine = "xmlns:w=\"http://schemas.microsoft.com/office/word/2003/wordml\"";
	const char *xlsxFormatLine = "xmlns:ss=\"urn:schemas-microsoft-com:office:spreadsheet\"";
	const char *docxPackage = "progid=\"Word.Document\"";
	const char *xlsxPackage = "progid=\"Excel.Sheet\"";
	const char *pptxPackage = "progid=\"PowerPoint.Show\"";
	const char *packageFormatLine = "xmlns:pkg=\"http://schemas.microsoft.com/office/2006/xmlPackage\"";
	const char* workbookFormatLine = "<Workbook";
	const char* htmlFormatLine = "<html";

	if (std::string::npos != xml_string.find(docxFormatLine))
	{
		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX_FLAT;
	}
	else if (std::string::npos != xml_string.find(xlsxFormatLine) && (	std::string::npos != xml_string.find(workbookFormatLine) ||
																		std::string::npos == xml_string.find(htmlFormatLine)))
	{
		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX_FLAT;
	}
	else if (std::string::npos != xml_string.find(packageFormatLine))
	{
		if (std::string::npos != xml_string.find(docxPackage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX_PACKAGE;
		}
		else if (std::string::npos != xml_string.find(xlsxPackage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX_PACKAGE;
		}
		else if (std::string::npos != xml_string.find(pptxPackage))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX_PACKAGE;
		}
	}

	return nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN;
}
std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
{
	switch (type)
	{
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM:
		return L".oform";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCXF:
		return L".docxf";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX:
		return L".docx";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM:
		return L".docm";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX:
		return L".dotx";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM:
		return L".dotm";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC:
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC_FLAT:
		return L".doc";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT:
		return L".odt";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_RTF:
		return L".rtf";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT:
		return L".txt";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML:
		return L".html";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_MHT:
		return L".mht";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_EPUB:
		return L".epub";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_FB2:
		return L".fb2";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_MOBI:
		return L".mobi";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT_FLAT:
		return L".fodt";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_OTT:
		return L".ott";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES:
		return L".pages";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP:
		return L".hwp";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX:
		return L".hwpx";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPML:
		return L".hml";
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_MD:
		return L".md";

	case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX:
		return L".pptx";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM:
		return L".pptm";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT:
		return L".ppt";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP:
		return L".odp";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX:
		return L".ppsx";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSM:
		return L".ppsm";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX:
		return L".potx";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM:
		return L".potm";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP_FLAT:
		return L".fodp";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_OTP:
		return L".otp";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_ODG:
		return L".odg";
	case AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY:
		return L".key";

	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX:
		return L".xlsx";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM:
		return L".xlsm";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX:
		return L".xltx";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM:
		return L".xltm";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB:
		return L".xlsb";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS:
		return L".xls";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS:
		return L".ods";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV:
		return L".csv";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS_FLAT:
		return L".fods";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS:
		return L".ots";
	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS:
		return L".numbers";

	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF:
	case AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM_PDF:
		return L".pdf";
	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_SWF:
		return L".swf";
	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU:
		return L".djvu";
	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS:
		return L".xps";
	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_OFD:
		return L".ofd";
	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_SVG:
		return L".svg";
	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_HTMLR:
		return L".htmlr";

	case AVS_OFFICESTUDIO_FILE_OTHER_HTMLZIP:
		return L".zip";
	case AVS_OFFICESTUDIO_FILE_OTHER_JSON:
		return L".json";

	case AVS_OFFICESTUDIO_FILE_IMAGE:
	case AVS_OFFICESTUDIO_FILE_IMAGE_JPG:
		return L".jpg";
	case AVS_OFFICESTUDIO_FILE_IMAGE_TIFF:
		return L".tiff";
	case AVS_OFFICESTUDIO_FILE_IMAGE_TGA:
		return L".tga";
	case AVS_OFFICESTUDIO_FILE_IMAGE_GIF:
		return L".gif";
	case AVS_OFFICESTUDIO_FILE_IMAGE_PNG:
		return L".png";
	case AVS_OFFICESTUDIO_FILE_IMAGE_EMF:
		return L".emf";
	case AVS_OFFICESTUDIO_FILE_IMAGE_WMF:
		return L".wmf";
	case AVS_OFFICESTUDIO_FILE_IMAGE_BMP:
		return L".bmp";
	case AVS_OFFICESTUDIO_FILE_IMAGE_CR2:
		return L".cr2";
	case AVS_OFFICESTUDIO_FILE_IMAGE_PCX:
		return L".pcx";
	case AVS_OFFICESTUDIO_FILE_IMAGE_RAS:
		return L".ras";
	case AVS_OFFICESTUDIO_FILE_IMAGE_PSD:
		return L".psd";
	case AVS_OFFICESTUDIO_FILE_IMAGE_ICO:
		return L".ico";

	case AVS_OFFICESTUDIO_FILE_CANVAS_WORD:
	case AVS_OFFICESTUDIO_FILE_CANVAS_SPREADSHEET:
	case AVS_OFFICESTUDIO_FILE_CANVAS_PRESENTATION:
	case AVS_OFFICESTUDIO_FILE_CANVAS_DRAW:
		return L".bin";
	case AVS_OFFICESTUDIO_FILE_OTHER_OLD_DOCUMENT:
	case AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY:
		return L".doct";
	case AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY:
		return L".xlst";
	case AVS_OFFICESTUDIO_FILE_TEAMLAB_VSDY:
		return L".vsdt";
	case AVS_OFFICESTUDIO_FILE_OTHER_OLD_PRESENTATION:
	case AVS_OFFICESTUDIO_FILE_OTHER_OLD_DRAWING:
	case AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY:
		return L".pptt";

	case AVS_OFFICESTUDIO_FILE_DRAW_VSDX:
		return L".vsdx";
	case AVS_OFFICESTUDIO_FILE_DRAW_VSSX:
		return L".vssx";
	case AVS_OFFICESTUDIO_FILE_DRAW_VSTX:
		return L".vstx";
	case AVS_OFFICESTUDIO_FILE_DRAW_VSDM:
		return L".vsdm";
	case AVS_OFFICESTUDIO_FILE_DRAW_VSSM:
		return L".vssm";
	case AVS_OFFICESTUDIO_FILE_DRAW_VSTM:
		return L".vstm";
	}
	return L"";
}

int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring &sExt)
{
	std::wstring ext;
	ext.resize(sExt.size());
	std::transform(sExt.begin(), sExt.end(), ext.begin(), tolower);

	if (L".docx" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX;
	if (L".oform" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM;
	if (L".docxf" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCXF;
	if (L".docm" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM;
	if (L".dotx" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX;
	if (L".dotm" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM;
	if (L".doc" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC;
	if (L".odt" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT;
	if (L".rtf" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_RTF;
	if (L".txt" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT;
	if (L".html" == ext || L".htm" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML;
	if (L".mht" == ext || L".mhtml" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_MHT;
	if (L".epub" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_EPUB;
	if (L".fb2" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_FB2;
	if (L".mobi" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_MOBI;
	if (L".docm" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM;
	if (L".dotx" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX;
	if (L".dotm" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM;
	if (L".fodt" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT_FLAT;
	if (L".ott" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_OTT;
	if (L".pages" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
	if (L".hwp" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP;
	if (L".hwpx" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX;
	if (L".hml" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPML;
	if (L".md" == ext)
		return AVS_OFFICESTUDIO_FILE_DOCUMENT_MD;

	if (L".pptx" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX;
	if (L".pptm" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM;
	if (L".ppsm" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSM;
	if (L".ppt" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT;
	if (L".odp" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP;
	if (L".ppsx" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX;
	if (L".potx" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX;
	if (L".potm" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM;
	if (L".fodp" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP_FLAT;
	if (L".otp" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_OTP;
	if (L".odg" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_ODG;
	if (L".key" == ext)
		return AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;

	if (L".xlsx" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
	if (L".xlsm" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM;
	if (L".xltx" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX;
	if (L".xltm" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM;
	if (L".xlsm" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM;
	if (L".xltx" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX;
	if (L".xltm" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM;
	if (L".xlsb" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB;
	if (L".xls" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS;
	if (L".csv" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV;
	if (L".fods" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS_FLAT;
	if (L".ots" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS;
	if (L".ods" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS;
	if (L".numbers" == ext)
		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;

	if (L".ooxml" == ext)
		return AVS_OFFICESTUDIO_FILE_OTHER_OOXML;
	if (L".odf" == ext)
		return AVS_OFFICESTUDIO_FILE_OTHER_ODF;

	if (L".pdf" == ext)
		return AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF;
	if (L".djvu" == ext)
		return AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU;
	if (L".xps" == ext || L".oxps" == ext)
		return AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS;
	if (L"ofd" == ext)
		return AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_OFD;

	if (L".jpg" == ext || L".jpeg" == ext || L".jpe" == ext || L".jfif" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_JPG;
	if (L".tiff" == ext || L".tif" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_TIFF;
	if (L".tga" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_TGA;
	if (L".gif" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_GIF;
	if (L".png" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_PNG;
	if (L".emf" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_EMF;
	if (L".wmf" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_WMF;
	if (L".bmp" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_BMP;
	if (L".cr2" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_CR2;
	if (L".pcx" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_PCX;
	if (L".ras" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_RAS;
	if (L".psd" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_PSD;
	if (L".ico" == ext)
		return AVS_OFFICESTUDIO_FILE_IMAGE_ICO;

	if (L".doct" == ext)
		return AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY;
	if (L".xlst" == ext)
		return AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY;
	if (L".pptt" == ext)
		return AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY;
	if (L".vsdt" == ext)
		return AVS_OFFICESTUDIO_FILE_TEAMLAB_VSDY;

	if (L".vsdx" == ext)
		return AVS_OFFICESTUDIO_FILE_DRAW_VSDX;
	if (L".vssx" == ext)
		return AVS_OFFICESTUDIO_FILE_DRAW_VSSX;
	if (L".vstx" == ext)
		return AVS_OFFICESTUDIO_FILE_DRAW_VSTX;
	if (L".vsdm" == ext)
		return AVS_OFFICESTUDIO_FILE_DRAW_VSDM;
	if (L".vssm" == ext)
		return AVS_OFFICESTUDIO_FILE_DRAW_VSSM;
	if (L".vstm" == ext)
		return AVS_OFFICESTUDIO_FILE_DRAW_VSTM;
	return 0;
}

std::wstring COfficeFileFormatChecker::GetFormatExtension(const std::wstring &fileName)
{
	if (isOfficeFile(fileName))
		return GetExtensionByType(nFileType);

	return L"";
}

bool COfficeFileFormatChecker::isDjvuFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	if ((8 <= dwBytes) &&
		(0x41 == pBuffer[0] && 0x54 == pBuffer[1] && 0x26 == pBuffer[2] && 0x54 == pBuffer[3] && 0x46 == pBuffer[4] && 0x4f == pBuffer[5] && 0x52 == pBuffer[6] && 0x4d == pBuffer[7]))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isMobiFormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL)
		return false;

	if ((68 <= dwBytes) &&
		(('B' == pBuffer[60] && 'O' == pBuffer[61] && 'O' == pBuffer[62] && 'K' == pBuffer[63] && 'M' == pBuffer[64] && 'O' == pBuffer[65] && 'B' == pBuffer[66] && 'I' == pBuffer[67]) ||
		 ('T' == pBuffer[60] && 'E' == pBuffer[61] && 'X' == pBuffer[62] && 't' == pBuffer[63] && 'R' == pBuffer[64] && 'E' == pBuffer[65] && 'A' == pBuffer[66] && 'd' == pBuffer[67])))
		return true;

	return false;
}
bool COfficeFileFormatChecker::isFB2FormatFile(unsigned char *pBuffer, int dwBytes)
{
	if (pBuffer == NULL || dwBytes < 11)
		return false;

	bool tagOpen = false;
	// FB2 File is XML-file with rootElement - FictionBook
	for (int i = 0; i < dwBytes - 11 && i < 100; i++)
	{
		if (0x3C == pBuffer[i])
			tagOpen = true;
		else if (0x3E == pBuffer[i])
			tagOpen = false;
		else if (
			tagOpen && 0x46 == pBuffer[i] && 0x69 == pBuffer[i + 1] && 0x63 == pBuffer[i + 2] && 0x74 == pBuffer[i + 3] && 0x69 == pBuffer[i + 4] && 0x6F == pBuffer[i + 5] && 0x6E == pBuffer[i + 6] &&
			0x42 == pBuffer[i + 7] && 0x6F == pBuffer[i + 8] && 0x6F == pBuffer[i + 9] && 0x6B == pBuffer[i + 10])
			return true;
	}
	return false;
}
bool COfficeFileFormatChecker::isXpsFile(const std::wstring &fileName)
{
	COfficeUtils OfficeUtils(NULL);

	ULONG nBufferSize = 0;
	BYTE *pBuffer = NULL;

	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"_rels/.rels", &pBuffer, nBufferSize);
	if (hresult == S_OK && pBuffer != NULL)
	{
		// http://schemas.microsoft.com/xps/2005/06/fixedrepresentation
		// http://schemas.openxps.org/oxps/v1.0/fixedrepresentation
		if ((19 <= nBufferSize && NULL != strstr((char *)pBuffer, "fixedrepresentation") && (NULL != strstr((char *)pBuffer, "/xps/")) ||
			(6 <= nBufferSize && NULL != strstr((char *)pBuffer, "/oxps/"))))
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS;
		}

		delete[] pBuffer;
		pBuffer = NULL;

		if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
			return true;
	}
	else
	{
		HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"_rels/.rels/[0].piece", &pBuffer, nBufferSize);
		if (hresult == S_OK && pBuffer != NULL)
		{
			nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS;
			return true;
		}
	}
	return false;
}

bool COfficeFileFormatChecker::isOFDFile(const std::wstring& fileName)
{
	COfficeUtils OfficeUtils(NULL);

	ULONG nBufferSize = 0;
	BYTE *pBuffer = NULL;

	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"OFD.xml", &pBuffer, nBufferSize);
	if (hresult == S_OK && pBuffer != NULL)
	{
		if (19 <= nBufferSize && NULL != strstr((char *)pBuffer, "ofd:OFD"))
			nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_OFD;

		delete[] pBuffer;
		pBuffer = NULL;

		if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
			return true;
	}

	return false;
}