#include "s2t_api.h"

#include "../../../sdk/include/sane/sane_option_definitions.h"
#include "scanned_img.h"

// 标准TWAIN属性值与SANE属性值之间的转换
//
// FIXED ME: all values should come from SANE but not static columns here !!!
//
namespace s2t
{
	enum Language	// copy from <twain/twpp/enums.hpp>
	{
		English = 2,
		ChineseSimplified = 41,
		ChineseTraditional = 43,
	};
	enum Filter		// copy from <twain/twpp/enums.hpp>
	{
		Red = 0,
		Green = 1,
		Blue = 2,
		None = 3,
	};

	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_LETTER, OPTION_VALUE_ZZCC_LetterHX}
						, {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_A4, OPTION_VALUE_ZZCC_A4HX}
					, {PAPER_A5, OPTION_VALUE_ZZCC_A5HX}
					, {PAPER_A6, OPTION_VALUE_ZZCC_A6HX}
					, {PAPER_B4, OPTION_VALUE_ZZCC_B4}
					, {PAPER_B5, OPTION_VALUE_ZZCC_B5}
					, {PAPER_B6, OPTION_VALUE_ZZCC_B6}
					, {PAPER_B5, OPTION_VALUE_ZZCC_B5HX}
					, {PAPER_B6, OPTION_VALUE_ZZCC_B6HX}
					, {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}
					},
		g_power[] = { {SANE_POWER_MINUTES_5, OPTION_VALUE_XMSJ_WFZ}
					, {SANE_POWER_MINUTES_10, OPTION_VALUE_XMSJ_SFZ}
					, {SANE_POWER_MINUTES_30, OPTION_VALUE_XMSJ_BXS}
					, {SANE_POWER_MINUTES_60, OPTION_VALUE_XMSJ_YXS}
					, {SANE_POWER_MINUTES_120, OPTION_VALUE_XMSJ_LXS}
					, {SANE_POWER_MINUTES_240, OPTION_VALUE_XMSJ_SXS}
					},
	g_language[] = { {Language::ChineseSimplified, "\344\270\255\346\226\207\357\274\210\347\256\200\344\275\223\357\274\211"}
						, {Language::ChineseTraditional, "\344\270\255\346\226\207\357\274\210\347\271\201\344\275\223\357\274\211"}
						, {Language::English, "\350\213\261\350\257\255"}
					}
	;


#define TO_TWAIN(a, s)	\
	for(auto& v: a)		\
	{					\
		if(strcmp(v.opt_val, local_trans::to_default_language(s)) == 0)	\
			return v.twain_id;											\
	}
#define FROM_TWAIN(a, t)	\
	for(auto& v: a)			\
	{						\
		if(v.twain_id == t)	\
			return local_trans::from_default_language(v.opt_val);		\
	}

	// 页面 与 双面转换
	bool page_is_duplex(const char* sane_val)
	{
		return strcmp(sane_val, local_trans::from_default_language(OPTION_VALUE_SMYM_SM)) == 0;
	}
	std::string page_from_duplex(bool duplex)
	{
		if (duplex)
			return local_trans::from_default_language(OPTION_VALUE_SMYM_SM);
		else
			return local_trans::from_default_language(OPTION_VALUE_SMYM_DM);
	}

	// 页面 与 丢弃空白页
	bool discard_blank_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		return val == OPTION_VALUE_SMYM_TGKBYFPZ || val == OPTION_VALUE_SMYM_TGKBYTY;
	}
	std::string discard_blank_to_sane(bool discard)
	{
		if (discard)
			return local_trans::from_default_language(OPTION_VALUE_SMYM_TGKBYTY);
		else
			return local_trans::from_default_language(OPTION_VALUE_SMYM_SM);
	}

	// 页面 与 丢弃空白发票
	bool discard_blank_receipt_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		return val == OPTION_VALUE_SMYM_TGKBYFPZ;
	}
	std::string discard_blank_receipt_to_sane(bool discard)
	{
		if (discard)
			return local_trans::from_default_language(OPTION_VALUE_SMYM_TGKBYFPZ);
		else
			return local_trans::from_default_language(OPTION_VALUE_SMYM_SM);
	}

	// 页面 与 对折
	bool fold_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		return val == OPTION_VALUE_SMYM_DZ;
	}
	std::string fold_to_sane(bool fold)
	{
		if (fold)
			return local_trans::from_default_language(OPTION_VALUE_SMYM_DZ);
		else
			return local_trans::from_default_language(OPTION_VALUE_SMYM_SM);
	}

	// 语言
	int language_to_twain(const char* sane_val)
	{
		TO_TWAIN(g_language, sane_val);

		return Language::ChineseSimplified;
	}
	std::string language_from_twain(int twain)
	{
		FROM_TWAIN(g_language, twain);

		FROM_TWAIN(g_language, Language::ChineseSimplified);
	}

	// 位深 与 颜色模式
	int bits_from_sane(const char* color_mode)
	{
		std::string curl(local_trans::to_default_language(color_mode));

		if (curl == OPTION_VALUE_YSMS_HB)
			return 1;
		else if (curl == OPTION_VALUE_YSMS_256JHD)
			return 8;
		else
			return 24;
	}
	std::string bits_to_sane(int bits)
	{
		if(bits == 1)
			return local_trans::from_default_language(OPTION_VALUE_YSMS_HB);
		else if(bits == 8)
			return local_trans::from_default_language(OPTION_VALUE_YSMS_256JHD);
		else
			return local_trans::from_default_language(OPTION_VALUE_YSMS_24WCS);
	}

	// PixelType 与 颜色模式 
	int pixel_type_from_sane(const char* color_mode)
	{
		TO_TWAIN(g_color_mode_map, color_mode);

		return COLOR_RGB;
	}
	std::string pixel_type_to_sane(int pixel)
	{
		FROM_TWAIN(g_color_mode_map, pixel);

		return local_trans::from_default_language(OPTION_VALUE_YSMS_24WCS);
	}

	// 自动颜色匹配 与 颜色模式 
	bool color_mode_is_auto(const char* color_mode)
	{
		return strcmp(color_mode, local_trans::from_default_language(OPTION_VALUE_YSMS_YSZDSB)) == 0;
	}
	std::string color_mode_from_auto(bool auto_mode)
	{
		if (auto_mode)
			return local_trans::from_default_language(OPTION_VALUE_YSMS_YSZDSB);
		else
			return local_trans::from_default_language(OPTION_VALUE_YSMS_24WCS);
	}

	// 支持的尺寸 与 纸张
	int paper_size_from_sane(const char* sane_val)
	{
		TO_TWAIN(g_paper_map, sane_val);

		return PAPER_STATEMENT;
	}
	std::string paper_size_to_sane(int paper)
	{
		FROM_TWAIN(g_paper_map, paper);

		return local_trans::from_default_language(OPTION_VALUE_ZZCC_PPYSCC);
	}

	// 横向 与 纸张
	bool lateral_from_sane(const char* sane_val, bool* support_lateral)
	{
		bool ret = false,
			sup = false;
		std::string val(local_trans::to_default_language(sane_val));

		if (val == OPTION_VALUE_ZZCC_A4)
		{
			sup = true;
		}
		else if (val == OPTION_VALUE_ZZCC_A4HX)
		{
			sup = true;
			ret = true;
		}
		else if (val == OPTION_VALUE_ZZCC_A5)
		{
			sup = true;
		}
		else if (val == OPTION_VALUE_ZZCC_A5HX)
		{
			sup = true;
			ret = true;
		}
		else if (val == OPTION_VALUE_ZZCC_A6)
		{
			sup = true;
		}
		else if (val == OPTION_VALUE_ZZCC_A6HX)
		{
			sup = true;
			ret = true;
		}
		else if (val == OPTION_VALUE_ZZCC_B5)
		{
			sup = true;
		}
		else if (val == OPTION_VALUE_ZZCC_B5HX)
		{
			sup = true;
			ret = true;
		}
		else if (val == OPTION_VALUE_ZZCC_B6)
		{
			sup = true;
		}
		else if (val == OPTION_VALUE_ZZCC_B6HX)
		{
			sup = true;
			ret = true;
		}
		else if (val == OPTION_VALUE_ZZCC_Letter)
		{
			sup = true;
		}
		else if (val == OPTION_VALUE_ZZCC_LetterHX)
		{
			sup = true;
			ret = true;
		}

		if (support_lateral)
			*support_lateral = sup;

		return ret;
	}
	std::string lateral_to_sane(const char* sane_val, bool lateral)	// 如果sane_val不支持横向则返回sane_val，确定是否支持横向请调用lateral_from_sane
	{
		std::string ret(sane_val), val(local_trans::to_default_language(sane_val));

		if (lateral)
		{
		#define TRY_LATERAL(paper)						\
			if(val == OPTION_VALUE_ZZCC_##paper)		\
				ret = local_trans::from_default_language(OPTION_VALUE_ZZCC_##paper##HX);

			TRY_LATERAL(A4)
			else TRY_LATERAL(A5)
			else TRY_LATERAL(A6)
			else TRY_LATERAL(B5)
			else TRY_LATERAL(B6)
			else TRY_LATERAL(Letter)
		}
		else
		{
		#define TRY_NON_LATERAL(paper)						\
			if(val == OPTION_VALUE_ZZCC_##paper##HX)		\
				ret = local_trans::from_default_language(OPTION_VALUE_ZZCC_##paper);

			TRY_NON_LATERAL(A4)
			else TRY_NON_LATERAL(A5)
			else TRY_NON_LATERAL(A6)
			else TRY_NON_LATERAL(B5)
			else TRY_NON_LATERAL(B6)
			else TRY_NON_LATERAL(Letter)
		}

		return std::move(ret);
	}

	// 自动尺寸 与 纸张
	bool auto_size_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		return val == OPTION_VALUE_ZZCC_PPYSCC;
	}
	std::string auto_size_to_sane(bool autos)
	{
		return local_trans::from_default_language(OPTION_VALUE_ZZCC_PPYSCC);	// 因为默认值也为该值，所以固定返回此值。
	}

	// 自动裁切 与 纸张
	bool auto_crop_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		return val == OPTION_VALUE_ZZCC_ZDSMCCZDCQ;
	}
	std::string auto_crop_to_sane(bool autos)
	{
		if(autos)
			return local_trans::from_default_language(OPTION_VALUE_ZZCC_ZDSMCCZDCQ);	
		else
			return local_trans::from_default_language(OPTION_VALUE_ZZCC_PPYSCC);
	}

	// 旋转角度 与 送纸方向
	double rotation_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		if (val == OPTION_VALUE_WGFX_90)
			return 90.0f;
		else if (val == OPTION_VALUE_WGFX_180)
			return 180.0f;
		else if (val == OPTION_VALUE_WGFX__90)
			return 270.0f;
		else if (val == OPTION_VALUE_WGFX_ZDWBFXSB)
			return AUTO_MATIC_ROTATE;
		else
			return .0f;
	}
	std::string rotation_to_sane(double rot)
	{
		if (IS_DOUBLE_EQUAL(rot, 90.0f))
			return local_trans::from_default_language(OPTION_VALUE_WGFX_90);
		if (IS_DOUBLE_EQUAL(rot, 180.0f))
			return local_trans::from_default_language(OPTION_VALUE_WGFX_180);
		if (IS_DOUBLE_EQUAL(rot, 270.0f))
			return local_trans::from_default_language(OPTION_VALUE_WGFX__90);
		if (IS_DOUBLE_EQUAL(rot, AUTO_MATIC_ROTATE))
			return local_trans::from_default_language(OPTION_VALUE_WGFX_ZDWBFXSB);

		return local_trans::from_default_language(OPTION_VALUE_WGFX_0);;
	}
	bool auto_rotation_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		return val == OPTION_VALUE_WGFX_ZDWBFXSB;
	}
	std::string auto_rotation_to_sane(bool autor)
	{
		if (autor)
			return local_trans::from_default_language(OPTION_VALUE_WGFX_ZDWBFXSB);
		else
			return local_trans::from_default_language(OPTION_VALUE_WGFX_0);
	}

	// 滤波 与 除色与增强
	static int filter_to_twain(const char* s, bool filter)
	{
		std::string val(local_trans::to_default_language(s));

		if (filter)
		{
			if (val == OPTION_VALUE_HDHHBTX_CSYZQ_CHS)
				return Filter::Red;
			else if (val == OPTION_VALUE_HDHHBTX_CSYZQ_CLS)
				return Filter::Green;
			else if (val == OPTION_VALUE_HDHHBTX_CSYZQ_CHULANSE)
				return Filter::Blue;
		}
		else
		{
			if (val == OPTION_VALUE_HDHHBTX_CSYZQ_HSZQ)
				return Filter::Red;
			else if (val == OPTION_VALUE_HDHHBTX_CSYZQ_LSZQ)
				return Filter::Green;
			else if (val == OPTION_VALUE_HDHHBTX_CSYZQ_LANSEZENGQIANG)
				return Filter::Blue;
		}

		return Filter::None;
	}
	void filter_from_sane(const std::vector<std::string>& sane/*sane_opts::RANGE_POS*/, std::vector<int>& twain, bool filter/*true - filter; false - enhance*/)
	{
		if (sane.size())
		{
			twain.push_back(filter_to_twain(sane[0].c_str(), filter));
			if (sane.size() >= 2)
			{
				twain.push_back(filter_to_twain(sane[1].c_str(), filter));
			}
		}

		for (int i = sane_opts::RANGE_POS_ENUM_BEGIN; i < sane.size(); ++i)
		{
			int v = filter_to_twain(sane[i].c_str(), filter);
			if (std::find(twain.begin() + 2, twain.end(), v) == twain.end())
				twain.push_back(v);
		}
	}
	std::string filter_to_sane(int filter)
	{
		if (filter == Filter::Red)
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_CHS);
		else if(filter == Filter::Green)
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_CLS);
		else if(filter == Filter::Blue)
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_CHULANSE);
		else
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_BCS);
	}
	std::string enhance_to_sane(int enhance)
	{
		if (enhance == Filter::Red)
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_HSZQ);
		else if (enhance == Filter::Green)
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_LSZQ);
		else if (enhance == Filter::Blue)
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_LANSEZENGQIANG);
		else
			return local_trans::from_default_language(OPTION_VALUE_HDHHBTX_CSYZQ_BCS);
	}

	// 多流输出
	int multi_out_from_sane(const char* sane_val)
	{
		TO_TWAIN(g_multiout_map, sane_val);

		return -1;
	}
	std::string multi_out_to_sane(int mo)
	{
		FROM_TWAIN(g_multiout_map, mo);

		return local_trans::from_default_language(OPTION_VALUE_DLSCLX_CS_HD_HB);
	}

	// 休眠时间兼容老版本协议
	int power_from_sane(const char* sane_val)
	{
		TO_TWAIN(g_power, sane_val);

		return SANE_POWER_NONE;
	}
	std::string power_to_sane(int power)
	{
		FROM_TWAIN(g_power, power);

		return local_trans::from_default_language(OPTION_VALUE_XMSJ_BXM);
	}

	// 背景填充方式 设置凸多边形
	bool convex_from_sane(const char* sane_val)
	{
		std::string val(local_trans::to_default_language(sane_val));

		return val == OPTION_VALUE_BJTCFS_TDBX;
	}
	std::string convex_to_sane(bool convex)
	{
		if (convex)
			return local_trans::from_default_language(OPTION_VALUE_BJTCFS_TDBX);
		else
			return local_trans::from_default_language(OPTION_VALUE_BJTCFS_ADBX);
	}

	// 锐化
	int sharpen_from_sane(const char* sane_val)
	{
		TO_TWAIN(g_sharpen_map, sane_val);

		return SHARPEN_NONE;
	}
	std::string sharpen_to_sane(int sharpen)
	{
		FROM_TWAIN(g_sharpen_map, sharpen);

		return local_trans::from_default_language(OPTION_VALUE_RHYMH_W);
	}
};