#include "HGOCRHanvon.hpp"
#include "HGOCRRetImpl.hpp"
#include "../base/HGUtility.h"
#include "../base/HGInfo.h"
#include "../imgfmt/HGBmp.h"
#include "../imgfmt/HGJpeg.h"

//HGUInt HGOCRHanvon::m_refCount = 0;
//HGOCRHanvon* HGOCRHanvon::m_OCR = NULL;

HGOCRHanvon::HGOCRHanvon()
{
	m_dll = NULL;
	m_ocrHandle = NULL;
	m_imageList.clear();
	m_func = NULL;
	m_param = NULL;
	//m_FuncRet = 0;
}

HGOCRHanvon::~HGOCRHanvon()
{

}

HGResult HGOCRHanvon::Init()
{
	if (NULL != m_ocrHandle)
	{
		return HGBASE_ERR_FAIL;
	}

	assert(NULL == m_dll);

	HGChar moduleName[256];
	HGBase_GetModuleName((void *)HGImgProc_CreateOCRMgr, moduleName, 256);
	HGChar dllPath[256];
	HGBase_GetFilePath(moduleName, dllPath, 256);

#if defined(HG_CMP_MSC)
	strcat(dllPath, "hanwangOCRdetect.dll");
#else
	strcat(dllPath, "libhwocrdetect.so");
#endif
	HGResult ret = HGBase_CreateDll(dllPath, &m_dll);
	if (HGBASE_ERR_OK != ret)
	{
		return ret;
	}

	if (0 != HWOCR_SDKInitialize(&m_ocrHandle))
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::Init: HWOCR_SDKInitialize fail");
		HGBase_DestroyDll(m_dll);
		m_dll = NULL;
		return HGIMGPROC_ERR_OCRINIT;
	}

	//if (0 == m_refCount)
	//{
		//HWOCR_InitPdf();
	//}
	//++m_refCount;

	return HGBASE_ERR_OK;
}

HGResult HGOCRHanvon::Deinit()
{
	if (NULL == m_ocrHandle)
	{
		return HGBASE_ERR_FAIL;
	}

	ClearImageList();

	//assert(0 != m_refCount);
	//--m_refCount;
	//if (0 == m_refCount)
	//{
		//HWOCR_ExitPdf();
	//}

	HWOCR_SDKExit(m_ocrHandle);
	m_ocrHandle = NULL;

	HGBase_DestroyDll(m_dll);
	m_dll = NULL;
	return HGBASE_ERR_OK;
}

HGResult HGOCRHanvon::ImageOCR(HGImage image, class HGOCRRetImpl **ocrRet)
{
	if (NULL == image || NULL == ocrRet)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGChar tmpFileName[256];
	HGBase_GetTmpFileName("bmp", tmpFileName, 256);
	HGResult ret = HGImgFmt_SaveBmpImage(image, NULL, tmpFileName);
	if (HGBASE_ERR_OK != ret)
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageOCR: HGImgFmt_SaveBmpImage fail %s", tmpFileName);
		return ret;
	}

	char* rst = NULL;
	int len = 0;
	int rc = HWOCR_RecognizeFile2Str((unsigned char*)tmpFileName, m_ocrHandle, &rst, &len);
	HGBase_DeleteFile(tmpFileName);
	if (0 != rc)
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageOCR: HWOCR_RecognizeFile2Str fail in=%s", tmpFileName);
		return HGIMGPROC_ERR_OCR;
	}

	assert(NULL != rst && len > 0);

	std::vector<std::string> blockInfo;
	blockInfo.push_back(rst);
	HWOCR_FreeStrRst(&rst);

	*ocrRet = new HGOCRRetImpl(blockInfo);
	return HGBASE_ERR_OK;
}

HGResult HGOCRHanvon::ImageOCRToFile(HGImage image, HGUInt outType, const HGChar *outFileName)
{
	if (NULL == image || outType > HGIMGPROC_OCROUTTYPE_OFD || NULL == outFileName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (0 == outType)
		outType = GetOutTypeByFileName(outFileName);

	int fileType = -1;
	if (HGIMGPROC_OCROUTTYPE_RTF == outType)
		fileType = FILE_RTF;
	else if (HGIMGPROC_OCROUTTYPE_XLS == outType)
		fileType = FILE_XLS;
	else if (HGIMGPROC_OCROUTTYPE_TXT == outType)
		fileType = FILE_TXT;
	else if (HGIMGPROC_OCROUTTYPE_PDF == outType)
		fileType = FILE_PDF;
	else if (HGIMGPROC_OCROUTTYPE_OFD == outType)
		fileType = FILE_OFD;
	if (-1 == fileType)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGChar tmpFileName[256];
	HGBase_GetTmpFileName("bmp", tmpFileName, 256);
	HGResult ret = HGImgFmt_SaveBmpImage(image, NULL, tmpFileName);
	if (HGBASE_ERR_OK != ret)
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageOCRToFile: HGImgFmt_SaveBmpImage fail %s", tmpFileName);
		return ret;
	}

	HGChar tmpDir[256];
	HGBase_GetTmpFileName(NULL, tmpDir, 256);
	ret = HGBase_CreateDir(tmpDir);
	if (HGBASE_ERR_OK != ret)
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageOCRToFile: HGBase_CreateDir fail %s", tmpDir);
		HGBase_DeleteFile(tmpFileName);
		return ret;
	}

	int rc = HWOCR_RecognizeFile((unsigned char*)tmpFileName, (unsigned char*)outFileName, fileType, m_ocrHandle, NULL, tmpDir);
	HGBase_DeleteDir(tmpDir);
	HGBase_DeleteFile(tmpFileName);
	if (0 != rc)
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageOCR: HWOCR_RecognizeFile fail in=%s, out=%s, tmpdir=%s", 
			tmpFileName, outFileName, tmpDir);
		return HGIMGPROC_ERR_OCR;
	}

	return HGBASE_ERR_OK;
}

HGResult HGOCRHanvon::ImageTextDirectOCR(HGImage image, HGUInt* direct)
{
	if (NULL == image || NULL == direct)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGChar tmpFileName[256];
	HGBase_GetTmpFileName("bmp", tmpFileName, 256);
	HGResult ret = HGImgFmt_SaveBmpImage(image, NULL, tmpFileName);
	if (HGBASE_ERR_OK != ret)
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageTextDirectOCR: HGImgFmt_SaveBmpImage fail %s", tmpFileName);
		return ret;
	}

	int dire = -1;
	int rc = HWOCR_GetFileDirect((unsigned char*)tmpFileName, m_ocrHandle, &dire);
	HGBase_DeleteFile(tmpFileName);
	if (0 != rc)
	{
		return HGIMGPROC_ERR_OCR;
	}

	if (ROT0 == dire)
		*direct = HGIMGPROC_OCRTEXTDIRECT_ORI;
	else if (ROT90 == dire)
		*direct = HGIMGPROC_OCRTEXTDIRECT_RIGHT;
	else if (ROT180 == dire)
		*direct = HGIMGPROC_OCRTEXTDIRECT_180;
	else if (ROT270 == dire)
		*direct = HGIMGPROC_OCRTEXTDIRECT_LEFT;

	return HGBASE_ERR_OK;
}

HGResult HGOCRHanvon::AddToImageList(HGImage image)
{
	if (NULL == image)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGChar tmpFileName[256] = {0};
	HGBase_GetTmpFileName("jpg", tmpFileName, 256);
	HGResult ret = HGImgFmt_SaveJpegImage(image, NULL, tmpFileName);
	if (HGBASE_ERR_OK != ret)
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::AddToImageList: HGImgFmt_SaveJpegImage fail %s", tmpFileName);
		return ret;
	}

	m_imageList.push_back(tmpFileName);
	return HGBASE_ERR_OK;
}

HGResult HGOCRHanvon::ClearImageList()
{
	for (int i = 0; i < (int)m_imageList.size(); ++i)
	{
		HGBase_DeleteFile(m_imageList[i].c_str());
	}

	m_imageList.clear();
	return HGBASE_ERR_OK;
}

HGResult HGOCRHanvon::ImageListOCRToFile(HGUInt outType, const HGChar* outFileName, HGImageListOcrFunc func, HGPointer param)
{
	if (m_imageList.empty())
	{
		return HGBASE_ERR_FAIL;
	}

	if (outType > HGIMGPROC_OCROUTTYPE_OFD || NULL == outFileName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (0 == outType)
		outType = GetOutTypeByFileName(outFileName);

	int fileType = -1;
	if (HGIMGPROC_OCROUTTYPE_RTF == outType)
		fileType = FILE_RTF;
	else if (HGIMGPROC_OCROUTTYPE_XLS == outType)
		fileType = FILE_XLS;
	else if (HGIMGPROC_OCROUTTYPE_TXT == outType)
		fileType = FILE_TXT;
	else if (HGIMGPROC_OCROUTTYPE_PDF == outType)
		fileType = FILE_PDF;
	else if (HGIMGPROC_OCROUTTYPE_OFD == outType)
		fileType = FILE_OFD;
	if (-1 == fileType)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	//m_OCR = this;
	m_func = func;
	m_param = param;

	HGChar** ppImageFiles = new HGChar* [m_imageList.size() + 1];
	for (int i = 0; i < (int)m_imageList.size(); ++i)
		ppImageFiles[i] = (HGChar *)m_imageList[i].c_str();
	ppImageFiles[m_imageList.size()] = NULL;

	HGChar tmpDir[256];
	HGBase_GetTmpFileName(NULL, tmpDir, 256);
	HGResult ret = HGBase_CreateDir(tmpDir);
	if (HGBASE_ERR_OK == ret)
	{
#if defined(HG_CMP_MSC)
		int rc = HWOCR_RecognizeFileBatch(ppImageFiles, (unsigned char*)outFileName, fileType, m_ocrHandle, NULL, tmpDir, RecogProgress, IsCanceled);
#else
		int rc = HWOCR_RecognizeFileBatch(ppImageFiles, (unsigned char*)outFileName, fileType, m_ocrHandle, NULL, tmpDir);
#endif
		if (0 != rc)
		{
			HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageListOCRToFile: HWOCR_RecognizeFileBatch fail out=%s, tmpdir=%s", 
				outFileName, tmpDir);
			ret = HGIMGPROC_ERR_OCR;
		}

		HGBase_DeleteDir(tmpDir);
	}
	else
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HGOCRHanvon::ImageListOCRToFile: HGBase_CreateDir fail %s", tmpDir);
	}

	delete[] ppImageFiles;
	m_param = NULL;
	m_func = NULL;
	//m_OCR = NULL;

	// 不管成功与否都清空
	for (int i = 0; i < (int)m_imageList.size(); ++i)
	{
		HGBase_DeleteFile(m_imageList[i].c_str());
	}
	m_imageList.clear();

	return ret;
}

int HGOCRHanvon::HWOCR_SDKInitialize(void** ppstOcrHandle)
{
	typedef int (*Func)(void**);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_SDKInitialize", (HGPointer *)&func);
	if (NULL == func)
	{
		return -1;
	}

	return func(ppstOcrHandle);
}

void HGOCRHanvon::HWOCR_SDKExit(void* pstOcrHandle)
{
	typedef void (*Func)(void*);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_SDKExit", (HGPointer*)&func);
	if (NULL == func)
	{
		return;
	}

	func(pstOcrHandle);
}

void HGOCRHanvon::HWOCR_InitPdf()
{
	typedef void (*Func)();
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_InitPdf", (HGPointer*)&func);
	if (NULL == func)
	{
		return;
	}

	func();
}

void HGOCRHanvon::HWOCR_ExitPdf()
{
	typedef void (*Func)();
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_ExitPdf", (HGPointer*)&func);
	if (NULL == func)
	{
		return;
	}

	func();
}

int HGOCRHanvon::HWOCR_RecognizeFile2Str(unsigned char* ImgFile, void* pstHandle, char** ppRst, int* pnLen)
{
	typedef int (*Func)(unsigned char*, void*, char**, int*);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_RecognizeFile2Str", (HGPointer*)&func);
	if (NULL == func)
	{
		return -1;
	}

	return func(ImgFile, pstHandle, ppRst, pnLen);
}

void HGOCRHanvon::HWOCR_FreeStrRst(char** ppRst)
{
	typedef void (*Func)(char**);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_FreeStrRst", (HGPointer*)&func);
	if (NULL == func)
	{
		return;
	}

	func(ppRst);
}

int HGOCRHanvon::HWOCR_RecognizeFile(unsigned char* ImgFile, unsigned char* OutFile, int nFileType, void* pstHandle, char* pLibDir, char* pTmpDir)
{
	typedef int (*Func)(unsigned char*, unsigned char*, int, void*, char*, char*);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_RecognizeFile", (HGPointer*)&func);
	if (NULL == func)
	{
		return -1;
	}

	return func(ImgFile, OutFile, nFileType, pstHandle, pLibDir, pTmpDir);
}

int HGOCRHanvon::HWOCR_GetFileDirect(unsigned char* ImgFile, void* pstHandle, int* pDirect)
{
	typedef int (*Func)(unsigned char*, void *, int *);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_GetFileDirect", (HGPointer*)&func);
	if (NULL == func)
	{
		return -1;
	}

	return func(ImgFile, pstHandle, pDirect);
}

#if defined(HG_CMP_MSC)
int HGOCRHanvon::HWOCR_RecognizeFileBatch(char** ppImageFiles, unsigned char* OutFile, int nFileType, void* pstHandle, char* pLibDir, char* pTmpDir,
	HWOCR_RecogProgress aFuncRecogProgress, HWOCR_IsCanceled aFuncIsCanceled)
{
	typedef int (*Func)(char**, unsigned char*, int, void*, char*, char*, HWOCR_RecogProgress, HWOCR_IsCanceled);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_RecognizeFileBatch", (HGPointer*)&func);
	if (NULL == func)
	{
		return -1;
	}

	return func(ppImageFiles, OutFile, nFileType, pstHandle, pLibDir, pTmpDir, aFuncRecogProgress, aFuncIsCanceled);
}
#else
int HGOCRHanvon::HWOCR_RecognizeFileBatch(char** ppImageFiles, unsigned char* OutFile, int nFileType, void* pstHandle, char* pLibDir, char* pTmpDir)
{
	typedef int (*Func)(char**, unsigned char*, int, void*, char*, char*);
	Func func = NULL;
	HGBase_GetDllProcAddress(m_dll, "HWOCR_RecognizeFileBatch", (HGPointer*)&func);
	if (NULL == func)
	{
		return -1;
	}

	return func(ppImageFiles, OutFile, nFileType, pstHandle, pLibDir, pTmpDir);
}
#endif

#if defined(HG_CMP_MSC)
int HGOCRHanvon::RecogProgress(int nPercent)
{
	return 0;
}

int HGOCRHanvon::IsCanceled()
{
	return 0;
}
#endif