#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
#include "../wrapper/hg_log.h"
#include "../hgdev/scanner_manager.h"
#include <iostream>

#if defined(WIN32) || defined(_WIN64)
#include <fileapi.h>
#else
#include <sys/vfs.h>
#include <string.h>
#endif
#include <math.h>


#define MAKE_VERSION(a, b, c, d)	\
	((((unsigned long long)(a) & 0x0ffff) << 48)			\
	| (((unsigned long long)(b) & 0x0ffff) << 32)			\
	| (((unsigned long long)(c) & 0x0ffff) << 16)			\
	| (((unsigned long long)(d) & 0x0ffff) << 0))

std::string g_scanner_path = "";
static std::string g_sane_name = "";
static std::string g_sane_ver = "";

namespace err_map
{
	struct
	{
		int sane;
		int scanner;
	}g_err_map[] =
	{ {SANE_STATUS_GOOD, SCANNER_ERR_OK}
		, {SANE_STATUS_UNSUPPORTED, SCANNER_ERR_DEVICE_NOT_SUPPORT}
		, {SANE_STATUS_CANCELLED, SCANNER_ERR_USER_CANCELED}
		, {SANE_STATUS_DEVICE_BUSY, SCANNER_ERR_DEVICE_BUSY}
		, {SANE_STATUS_INVAL, SCANNER_ERR_INVALID_PARAMETER}
		, {SANE_STATUS_EOF, SCANNER_ERR_NO_DATA}
		, {SANE_STATUS_JAMMED, SCANNER_ERR_DEVICE_PAPER_JAMMED}
		, {SANE_STATUS_NO_DOCS, SCANNER_ERR_DEVICE_NO_PAPER}
		, {SANE_STATUS_COVER_OPEN, SCANNER_ERR_DEVICE_COVER_OPENNED}
		, {SANE_STATUS_IO_ERROR, SCANNER_ERR_IO}
		, {SANE_STATUS_NO_MEM, SCANNER_ERR_INSUFFICIENT_MEMORY}
		, {SANE_STATUS_ACCESS_DENIED, SCANNER_ERR_ACCESS_DENIED}
	};

	static int sane_2_scanner(int sane)
	{
		for (size_t i = 0; i < _countof(g_err_map); ++i)
		{
			if (g_err_map[i].sane == sane)
				return g_err_map[i].scanner;
		}

		return sane;
	}
	static int scanner_2_sane(int scanner)
	{
		for (size_t i = 0; i < _countof(g_err_map); ++i)
		{
			if (g_err_map[i].scanner == scanner)
				return g_err_map[i].sane;
		}

		return scanner;
	}
}
extern "C"
{
	scanner_err hg_scanner_initialize(sane_callback callback, void* reserve)
	{
		std::string	name(""),
					pe(hg_log::pe_path(&name)),
					path(PATH_SEPARATOR),
					scanner(g_scanner_path),
					sane(hg_log::get_module_full_path((g_sane_name + DLL_EXTESION).c_str()));
#if defined(WIN32) || defined(_WIN64)
		size_t pos = g_scanner_path.rfind('\\');
		if (pos++ != std::string::npos)
			g_scanner_path.erase(pos);
#else
		size_t	pos = 0;
		g_scanner_path = hg_log::get_module_full_path((std::string(GET_BACKEND_NAME) + ".so").c_str());
		scanner = g_scanner_path;
		pos = g_scanner_path.rfind('/');
		if (pos++ != std::string::npos)
			g_scanner_path.erase(pos);
#endif
		hg_log::init();
		VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Module device: [%u.%u.%u.%u] - %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER, scanner.c_str());
		VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Module  sane : [%s] - %s\n", g_sane_ver.c_str(), sane.c_str());
		VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Module  exe  : %s\n", (pe + path + name).c_str());

		hg_scanner_mgr::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
		hg_scanner_mgr::set_exe_name(pe.c_str(), name.c_str());
		hg_scanner_mgr::instance(callback);

		return SCANNER_ERR_OK;
	}
	void hg_scanner_uninitialize(void)
	{
		hg_scanner_mgr::clear();
		hg_log::unint();
	}

	unsigned long long hg_scanner_get_version(void)
	{
		return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
	}

	scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only)
	{
		return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only);
	}

	scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc)
	{
		return hg_scanner_mgr::instance()->hg_scanner_open(h, name, shared, user, pwd, check, rsc);
	}

	scanner_err hg_scanner_close(scanner_handle h, bool force)
	{
		return hg_scanner_mgr::instance()->hg_scanner_close(h, force);
	}

	scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, param_no, data, len);
	}

	scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_set_parameter(h, param_no, data, len);
	}

	scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num)
	{
		return hg_scanner_mgr::instance()->hg_scanner_start(h, async_event, num);
	}

	scanner_err hg_scanner_stop(scanner_handle h)
	{
		return hg_scanner_mgr::instance()->hg_scanner_stop(h);
	}

	scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_get_img_info(h, bmi, len);
	}

	scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_read_img_data(h, data, len);
	}


	scanner_err hg_scanner_get_status(scanner_handle h, int setstutas)
	{
		return hg_scanner_mgr::instance()->hg_scanner_get_status(h, setstutas);
	}

	scanner_err hg_scanner_reset(scanner_handle h)
	{
		return hg_scanner_mgr::instance()->hg_scanner_reset(h);
	}

	scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_control(h, code, data, len);
	}

	void hg_scanner_set_sane_info(const char* name, const char* ver)
	{
		g_sane_name = name;
		g_sane_ver = ver;
	}
	const char* hg_scanner_err_name(int err)
	{
		RETURN_IF(err, SANE_STATUS_GOOD);
		RETURN_IF(err, SANE_STATUS_UNSUPPORTED);
		RETURN_IF(err, SANE_STATUS_CANCELLED);
		RETURN_IF(err, SANE_STATUS_DEVICE_BUSY);
		RETURN_IF(err, SANE_STATUS_INVAL);
		RETURN_IF(err, SANE_STATUS_EOF);
		RETURN_IF(err, SANE_STATUS_JAMMED);
		RETURN_IF(err, SANE_STATUS_NO_DOCS);
		RETURN_IF(err, SANE_STATUS_COVER_OPEN);
		RETURN_IF(err, SANE_STATUS_IO_ERROR);
		RETURN_IF(err, SANE_STATUS_NO_MEM);
		RETURN_IF(err, SANE_STATUS_ACCESS_DENIED);
		RETURN_IF(err, SCANNER_ERR_INVALID_PARAMETER);
		RETURN_IF(err, SCANNER_ERR_USER_CANCELED);
		RETURN_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
		RETURN_IF(err, SCANNER_ERR_ACCESS_DENIED);
		RETURN_IF(err, SCANNER_ERR_IO_PENDING);
		RETURN_IF(err, SCANNER_ERR_NOT_EXACT);
		RETURN_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
		RETURN_IF(err, SCANNER_ERR_NOT_OPEN);
		RETURN_IF(err, SCANNER_ERR_NOT_START);
		RETURN_IF(err, SCANNER_ERR_NOT_ANY_MORE);
		RETURN_IF(err, SCANNER_ERR_NO_DATA);
		RETURN_IF(err, SCANNER_ERR_HAS_DATA_YET);
		RETURN_IF(err, SCANNER_ERR_OUT_OF_RANGE);
		RETURN_IF(err, SCANNER_ERR_IO);
		RETURN_IF(err, SCANNER_ERR_TIMEOUT);
		RETURN_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
		RETURN_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
		RETURN_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
		RETURN_IF(err, SCANNER_ERR_DATA_DAMAGED);
		RETURN_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
		RETURN_IF(err, SCANNER_ERR_USB_INIT_FAILED);
		RETURN_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
		RETURN_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
		RETURN_IF(err, SCANNER_ERR_DEVICE_BUSY);
		RETURN_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
		RETURN_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
		RETURN_IF(err, SCANNER_ERR_DEVICE_STOPPED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
		RETURN_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
		RETURN_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
		RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
		RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
		RETURN_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
		RETURN_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
		RETURN_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
		RETURN_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);

		// NOTE: multi-thread unsafe here
		static char	g_unk_err[80] = { 0 };
		sprintf(g_unk_err, "\346\234\252\347\237\245\351\224\231\350\257\257\357\274\2320x%X", err);

		return g_unk_err;
	}
	const char* hg_scanner_err_description(int err)
	{
		if (err < 0x100)
			err = err_map::sane_2_scanner(err);

		RETURN_DESC_IF(err, SCANNER_ERR_OK);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
		RETURN_DESC_IF(err, SCANNER_ERR_USER_CANCELED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
		RETURN_DESC_IF(err, SCANNER_ERR_INVALID_PARAMETER);
		RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
		RETURN_DESC_IF(err, SCANNER_ERR_IO);
		RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);

		RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
		RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
		RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
		RETURN_DESC_IF(err, SCANNER_ERR_IO_PENDING);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_EXACT);
		RETURN_DESC_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_OPEN);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_START);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_ANY_MORE);
		RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
		RETURN_DESC_IF(err, SCANNER_ERR_HAS_DATA_YET);
		RETURN_DESC_IF(err, SCANNER_ERR_OUT_OF_RANGE);
		RETURN_DESC_IF(err, SCANNER_ERR_IO);
		RETURN_DESC_IF(err, SCANNER_ERR_TIMEOUT);
		RETURN_DESC_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_DATA_DAMAGED);
		RETURN_DESC_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
		RETURN_DESC_IF(err, SCANNER_ERR_USB_INIT_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STOPPED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);

		// NOTE: multi-thread unsafe here
		static char	g_unk_err[80] = { 0 };
		sprintf(g_unk_err, "\346\234\252\347\237\245\351\224\231\350\257\257\357\274\2320x%X", err);

		return g_unk_err;
	}
	bool hg_scanner_log_is_enable(int level)
	{
		return hg_log::is_log_level_enabled(level);
	}
	void hg_scanner_log(const char* info)
	{
		hg_log::log(info);
	}

	char* get_file_path(const char* name, char* buf)
	{
		std::string	fp(hg_log::get_module_full_path(name));

		if (fp.empty())
			*buf = 0;
		else
			strcpy(buf, fp.c_str());

		return buf;
	}

	int get_disk_space(const char* path, unsigned long long* total, unsigned long long* avail, unsigned long long* block)
	{
		int	ret = SCANNER_ERR_OK;

#if defined(WIN32) || defined(_WIN64)
		ULARGE_INTEGER	av = { 0 },
						all = { 0 };
		if (GetDiskFreeSpaceExA(path, &av, &all, NULL))
		{
			if (total)
				*total = all.QuadPart;
			if (avail)
				*avail = av.QuadPart;
			if (block)
			{
				DWORD	sec = 0,
						clu = 0;
				std::string root(path);
				size_t		pos = root.find(":\\");
				if (pos != std::string::npos)
					root.erase(pos + 2);
				if (GetDiskFreeSpaceA(root.c_str(), &clu, &sec, NULL, NULL))
				{
					*block = clu * sec;
				}
			}
		}
		else
			ret = GetLastError();
#else
		struct statfs   fs = { 0 };
		
		ret = statfs(path, &fs);
		if (ret == 0)
		{
			VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "    Total: %lld, Free: %lld, Avail: %lld, block size: %lld\n",
				fs.f_blocks, fs.f_bfree, fs.f_bavail, fs.f_bsize);
			if (total)
				*total = fs.f_blocks * fs.f_bsize;
			if (avail)
				*avail = fs.f_bavail * fs.f_bsize;
			if (block)
				*block = fs.f_bsize;
		}
#endif
		return ret;
	}

	const char* hg_scanner_image_statu_name(int img_statu)
	{
		RETURN_IF(img_statu, SANE_Image_Statu_OK);
		RETURN_IF(img_statu, SANE_Image_Statu_Blank);
		RETURN_IF(img_statu, SANE_Image_Statu_Double);
		RETURN_IF(img_statu, SANE_Image_Statu_Jammed);

		// NOTE: multi-thread unsafe here
		static char	g_unk_statu[80] = { 0 };
		sprintf(g_unk_statu, "Unknowned image statu: 0x%X", img_statu);

		return g_unk_statu;
	}
}


#if defined(WIN32) || defined(_WIN64)

BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
{
	if (reason == DLL_PROCESS_ATTACH)
	{
		if (g_scanner_path.empty())
		{
			char	path[MAX_PATH] = { 0 };

			GetModuleFileNameA(inst, path, _countof(path) - 1);
		//	if (strrchr(path, '\\'))
			{
		//		strrchr(path, '\\')[1] = 0;
				g_scanner_path = path;
			}
		}
	}

	return TRUE;
}
#endif