#include "sane_option_trans.h"
#include <Windows.h>
#include <sane/sane_option_definitions.h>

namespace sane_opt_trans
{
	static struct
	{
		int twain_id;
		const char* opt_val;
	}
	g_color_mode_map[] = {{COLOR_BW, OPTION_VALUE_YSMS_HB}
						, {COLOR_GRAY, OPTION_VALUE_YSMS_256JHD}
						, {COLOR_RGB, OPTION_VALUE_YSMS_24WCS}
						, {COLOR_AUTO_MATCH, OPTION_VALUE_YSMS_YSZDSB}
					},
	g_multiout_map[] = { {MULTI_OUT_NONE, "\346\227\240"}
						, {MULTI_OUT_ALL, OPTION_VALUE_DLSCLX_CS_HD_HB}
						, {MULTI_OUT_COLOR_GRAY, OPTION_VALUE_DLSCLX_CS_HD}
						, {MULTI_OUT_COLOR_BW, OPTION_VALUE_DLSCLX_CS_HB}
						, {MULTI_OUT_GRAY_BW, OPTION_VALUE_DLSCLX_HD_HB}
						},
	g_enhance_map[] = { {ENHANCE_NONE, OPTION_VALUE_HDHHBTX_CSYZQ_BCS}
						, {ENHANCE_RED, OPTION_VALUE_HDHHBTX_CSYZQ_HSZQ}
						, {ENHANCE_GREEN, OPTION_VALUE_HDHHBTX_CSYZQ_LSZQ}
						, {ENHANCE_BLUE, OPTION_VALUE_HDHHBTX_CSYZQ_LANSEZENGQIANG}
						},
	g_filter_map[] = { {FILTER_NONE, OPTION_VALUE_HDHHBTX_CSYZQ_BCS}
					, {FILTER_RED, OPTION_VALUE_HDHHBTX_CSYZQ_CHS}
					, {FILTER_GREEN, OPTION_VALUE_HDHHBTX_CSYZQ_CLS}
					, {FILTER_BLUE, OPTION_VALUE_HDHHBTX_CSYZQ_CHULANSE}
					},
	g_auto_color_map[] = { {0, OPTION_VALUE_YSMS_HB}
						, {1, OPTION_VALUE_YSMS_256JHD}
						},
	g_sharpen_map[] = { {SHARPEN_NONE, OPTION_VALUE_RHYMH_W}
						, {SHARPEN_SHARPEN, OPTION_VALUE_RHYMH_RH}
						, {SHARPEN_SHARPEN_MORE, OPTION_VALUE_RHYMH_JYBRH}
						, {SHARPEN_BLUR, OPTION_VALUE_RHYMH_MH}
						, {SHARPEN_BLUR_MORE, OPTION_VALUE_RHYMH_JYBMH}
						},
	g_paper_map[] = { {PAPER_LETTER, OPTION_VALUE_ZZCC_Letter}
					, {PAPER_LEGAL, OPTION_VALUE_ZZCC_LEGAL}
					//, {PAPER_8K, OPTION_VALUE_ZZCC_8K}
					//, {PAPER_16K, OPTION_VALUE_ZZCC_16K}
					, {PAPER_A3, OPTION_VALUE_ZZCC_A3}
					, {PAPER_A4, OPTION_VALUE_ZZCC_A4}
					, {PAPER_A5, OPTION_VALUE_ZZCC_A5}
					, {PAPER_A6, OPTION_VALUE_ZZCC_A6}
					, {PAPER_B4, OPTION_VALUE_ZZCC_B4}
					, {PAPER_B5, OPTION_VALUE_ZZCC_B5}
					, {PAPER_B6, OPTION_VALUE_ZZCC_B6}
					, {PAPER_STATEMENT, OPTION_VALUE_ZZCC_PPYSCC}
					, {PAPER_MAXSIZE, OPTION_VALUE_ZZCC_ZDSMCC}
					, {PAPER_MAXSIZE_CROP, OPTION_VALUE_ZZCC_ZDSMCCZDCQ}
					, {PAPER_DOUBLE_LETTER, OPTION_VALUE_ZZCC_DoubleLetter}
					, {PAPER_TRIPPLE, OPTION_VALUE_ZZCC_SLSJ}
				}
		;
#define VALUE_FROM_TWAIN(arr, val)					\
		for (int i = 0; i < _countof(arr); ++i)		\
		{											\
			if (arr[i].twain_id == val)				\
				return arr[i].opt_val;				\
		}
#define VALUE_TO_TWAIN(arr, val)					\
		for (int i = 0; i < _countof(arr); ++i)		\
		{											\
			if (strcmp(arr[i].opt_val, val) == 0)	\
				return arr[i].twain_id;				\
		}

	const char* color_mode_from_twain(int val)
	{
		VALUE_FROM_TWAIN(g_color_mode_map, val);

		return OPTION_VALUE_YSMS_YSZDSB;
	}
	int color_mode_to_twain(const char* val)
	{
		VALUE_TO_TWAIN(g_color_mode_map, val);

		return COLOR_AUTO_MATCH;
	}

	const char* multiout_value_from_twain(int val)
	{
		VALUE_FROM_TWAIN(g_multiout_map, val);

		return NULL;
	}
	int multiout_value_to_twain(const char* val)
	{
		VALUE_TO_TWAIN(g_multiout_map, val);

		return -1;
	}

	const char* filter_enhance_value_from_twain(int val, bool filter)
	{
		if (filter)
		{
			for (int i = 0; i < _countof(g_filter_map); ++i)
			{
				if (g_filter_map[i].twain_id == val)
					return g_filter_map[i].opt_val;
			}
		}
		else
		{
			for (int i = 0; i < _countof(g_enhance_map); ++i)
			{
				if (g_enhance_map[i].twain_id == val)
					return g_enhance_map[i].opt_val;
			}
		}

		return OPTION_VALUE_HDHHBTX_CSYZQ_BCS;
	}
	int filter_enhance_value_to_twain(const char* val, bool* is_filter)
	{
		bool type = false;

		if (!is_filter)
			is_filter = &type;

		*is_filter = true;
		for (int i = 0; i < _countof(g_filter_map); ++i)
		{
			if (strcmp(g_filter_map[i].opt_val, val) == 0)
				return g_filter_map[i].twain_id;
		}
		*is_filter = false;
		for (int i = 0; i < _countof(g_enhance_map); ++i)
		{
			if (strcmp(g_enhance_map[i].opt_val, val) == 0)
				return g_enhance_map[i].twain_id;
		}

		return ENHANCE_NONE;
	}

	const char* text_direction_from_twain(float val)
	{
		while (val < .0f)
			val += 360.0f;
		while (val > 360.0f)
			val -= 360.0f;

		if (60.0f < val && val < 120.0f)
			return OPTION_VALUE_WGFX_90;
		else if (150.0f < val && val < 210.0f)
			return OPTION_VALUE_WGFX_180;
		else if (240.0f < val && val < 300.0f)
			return OPTION_VALUE_WGFX__90;
		else if (330.0f < val || val < 30.0f)
			return OPTION_VALUE_WGFX_0;
		else
			return OPTION_VALUE_WGFX_ZDWBFXSB;
	}
	float text_direction_to_twain(const char* val)
	{
		if (strcmp(val, OPTION_VALUE_WGFX_90) == 0)
			return 90.0f;
		else if (strcmp(val, OPTION_VALUE_WGFX_180) == 0)
			return 180.0f;
		else if (strcmp(val, OPTION_VALUE_WGFX__90) == 0)
			return 270.0f;
		else if (strcmp(val, OPTION_VALUE_WGFX_0) == 0)
			return .0f;
		else
			return AUTO_MATIC_ROTATE;
	}

	struct
	{
		const char* normal;
		const char* lateral;
	}g_lateral_map[] = 
	{ {OPTION_VALUE_ZZCC_A4, OPTION_VALUE_ZZCC_A4HX}
	, {OPTION_VALUE_ZZCC_16K, OPTION_VALUE_ZZCC_16KHX}
	, {OPTION_VALUE_ZZCC_A5, OPTION_VALUE_ZZCC_A5HX}
	, {OPTION_VALUE_ZZCC_A6, OPTION_VALUE_ZZCC_A6HX}
	, {OPTION_VALUE_ZZCC_B5, OPTION_VALUE_ZZCC_B5HX}
	, {OPTION_VALUE_ZZCC_B6, OPTION_VALUE_ZZCC_B6HX}
	, {OPTION_VALUE_ZZCC_Letter, OPTION_VALUE_ZZCC_LetterHX}
	};

	const char* paper_from_twain(int val)
	{
		VALUE_FROM_TWAIN(g_paper_map, val);

		return NULL;
	}
	int paper_to_twain(const char* val)
	{
		VALUE_TO_TWAIN(g_paper_map, val);

		return -1;
	}
	const char* switch_paper_lateral(const char* val)
	{
		for (int i = 0; i < _countof(g_lateral_map); ++i)
		{
			if (strcmp(g_lateral_map[i].normal, val) == 0)
				return g_lateral_map[i].lateral;
			else if (strcmp(g_lateral_map[i].lateral, val) == 0)
				return g_lateral_map[i].normal;
		}

		return NULL;
	}
	bool is_paper_lateral(const char* val)
	{
		for (int i = 0; i < _countof(g_lateral_map); ++i)
		{
			if (strcmp(g_lateral_map[i].lateral, val) == 0)
				return true;
		}

		return false;
	}

	const char* auto_color_type_from_twain(int val)
	{
		VALUE_FROM_TWAIN(g_color_mode_map, val);

		return OPTION_VALUE_YSMS_24WCS;
	}
	int auto_color_type_to_twain(const char* val)
	{
		VALUE_TO_TWAIN(g_color_mode_map, val);

		return -1;
	}

	const char* sharpen_from_twain(int val)
	{
		VALUE_FROM_TWAIN(g_sharpen_map, val);

		return OPTION_VALUE_RHYMH_W;
	}
	int sharpen_to_twain(const char* val)
	{
		VALUE_TO_TWAIN(g_sharpen_map, val);

		return SHARPEN_NONE;
	}

	struct {
		int	twain;
		int	sane;
	}
	g_compression_map[] = { {0, SANE_COMPRESSION_NONE}
						, {5, SANE_COMPRESSION_GROUP4}
						}
	;
#define INT_FROM_TWAIN(arr, val)					\
		for (int i = 0; i < _countof(arr); ++i)		\
		{											\
			if (arr[i].twain == val)				\
				return arr[i].sane;					\
		}
#define INT_TO_TWAIN(arr, val)						\
		for (int i = 0; i < _countof(arr); ++i)		\
		{											\
			if (arr[i].sane == val)					\
				return arr[i].twain;				\
		}

	int compression_from_twain(int val)
	{
		INT_FROM_TWAIN(g_compression_map, val);

		return SANE_COMPRESSION_NONE;
	}
	int compression_to_twain(int val)
	{
		INT_TO_TWAIN(g_compression_map, val);

		return 0;
	}
	std::vector<int> support_image_types(void)
	{
		std::vector<int>	it;

		it.push_back(SANE_IMAGE_TYPE_BMP);
		it.push_back(SANE_IMAGE_TYPE_TIFF);
		it.push_back(SANE_IMAGE_TYPE_JFIF);

		return it;
	}
}