/*max@home*/
#ifdef __cplusplus
extern "C" {
#endif

#ifdef NOTE
ConvertOneValue2Enum()
		potrebbe essere fonte di errore se DCItemSize[one_value.ItemType] > DCItemSize[TW_INT8] e si utilizzano i bit piu significativi di one_value.Item
																			ConvertEnumeration2Range()
																				potrebbe restituire valori di StepSize non appropriati se
																			enumeration.ItemType e TW_FIX32
																			potrebbe restituire valori MinValue non corretti se DCItemSize[xxx.ItemType] > DCItemSize[TW_INT8] e si utilizzano i bit piu significativi di xxx.Item
																																						   ConvertEnum2OneValue ritorna(ovviamente) solo il valore corrente
#endif

#include <assert.h>
#include <string.h>

#include "ttwain_capability.h"
#include "ttwain_conversion.h"
#include "ttwain_error.h"
#include "ttwain_state.h"

#include "ttwain_global_def.h"

#define CASE \
	break;   \
	case
#define DEFAULT \
	break;      \
	default
																																						   /*---------------------------------------------------------------------------*/
																																						   static const size_t DCItemSize[13] =
	{
		sizeof(TW_INT8),
		sizeof(TW_INT16),
		sizeof(TW_INT32),
		sizeof(TW_UINT8),
		sizeof(TW_UINT16),
		sizeof(TW_UINT32),
		sizeof(TW_BOOL),
		sizeof(TW_FIX32),
		sizeof(TW_FRAME),
		sizeof(TW_STR32),
		sizeof(TW_STR64),
		sizeof(TW_STR128),
		sizeof(TW_STR255),
}; /* see twain.h */

/*---------------------------------------------------------------------------*/
#define TWON_TWON(TYPE1, TYPE2) (((TYPE1) << 8) | (TYPE2))
/*---------------------------------------------------------------------------*/
static int ConvertOneValue2Range(TW_ONEVALUE one_value, TW_RANGE *range);
static int ConvertEnumeration2Range(TW_ENUMERATION enumeration, TW_RANGE *range);
static int ConvertOneValue2Enum(TW_ONEVALUE one_value, TW_ENUMERATION *tw_enum);
static int ConvertEnum2OneValue(TW_ENUMERATION tw_enum, TW_ONEVALUE *one_value);
static int ConvertEnum2Array(TW_ENUMERATION tw_enum, TW_ARRAY *array);

static TUINT32 GetContainerSize(int nFormat, unsigned twty, TW_UINT32 nItems);
static int TTWAIN_GetCapability(TW_INT16 msgType, TW_UINT16 cap_id, TW_UINT16 conType, void *data,
								TUINT32 *cont_size);
/*------------------------------------------------------------------------*/
int TTWAIN_GetCap(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
				  TUINT32 *cont_size)
{
	return TTWAIN_GetCapability(MSG_GET, cap_id, conType, data, cont_size);
}
/*------------------------------------------------------------------------*/
int TTWAIN_GetCapCurrent(TW_UINT16 cap_id, TW_UINT16 conType, void *data,
						 TUINT32 *cont_size)
{
	return TTWAIN_GetCapability(MSG_GETCURRENT, cap_id, conType, data, cont_size);
}
/*------------------------------------------------------------------------*/
int TTWAIN_GetCapQuery(TW_UINT16 cap_id, TW_UINT16 *pattern)
{
	int rc;
	TW_ONEVALUE data;
	rc = TTWAIN_GetCapability(MSG_QUERYSUPPORT, cap_id, TWON_ONEVALUE, &data, 0);
	if (!rc)
		return FALSE;
	*pattern = (TW_UINT16)data.Item;
	return TRUE;
}
/*------------------------------------------------------------------------*/
static int TTWAIN_GetCapability(TW_INT16 msgType, TW_UINT16 cap_id, TW_UINT16 conType, void *data,
								TUINT32 *cont_size)
{
	TW_CAPABILITY cap;
	void *pv;
	TW_ENUMERATION *my_enum;
	TW_ARRAY *my_array;
	TW_ONEVALUE *my_one;
	TW_RANGE *my_range;
	TUINT32 size = 0;

	if (!data && !cont_size)
		return FALSE;

	if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
		TTWAIN_ErrorBox("Attempt to get capability value below State 4.");
		return FALSE;
	}
	/* Fill in capability structure */
	cap.Cap = cap_id;			   /* capability id */
	cap.ConType = TWON_DONTCARE16; /* favorite type of container (should be ignored...) */
	cap.hContainer = NULL;

	if (TTWAIN_DS(DG_CONTROL, DAT_CAPABILITY, msgType, (TW_MEMREF)&cap) != TWRC_SUCCESS)
		return FALSE;

	if (!cap.hContainer)
		return FALSE;

	if (msgType == MSG_QUERYSUPPORT) {
	}

	pv = GLOBAL_LOCK(cap.hContainer);
	my_enum = (TW_ENUMERATION *)pv;
	my_array = (TW_ARRAY *)pv;
	my_one = (TW_ONEVALUE *)pv;
	my_range = (TW_RANGE *)pv;

	if (cont_size) {
		switch (TWON_TWON(cap.ConType, conType)) {
			CASE TWON_TWON(TWON_ENUMERATION, TWON_ENUMERATION) :
																	 *cont_size = GetContainerSize(TWON_ENUMERATION, my_enum->ItemType, my_enum->NumItems);
			CASE TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION) :
																  *cont_size = GetContainerSize(TWON_ENUMERATION, my_one->ItemType, 1);
			CASE TWON_TWON(TWON_ARRAY, TWON_ARRAY) :
														 *cont_size = GetContainerSize(TWON_ARRAY, my_array->ItemType, my_array->NumItems);
			CASE TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE) :
															   *cont_size = GetContainerSize(TWON_ONEVALUE, my_one->ItemType, 1);
			CASE TWON_TWON(TWON_ENUMERATION, TWON_ARRAY) :
															   *cont_size = GetContainerSize(TWON_ARRAY, my_enum->ItemType, my_enum->NumItems);
		DEFAULT:
			/*      tmsg_error("Unable to convert type %d to %d (cap 0x%x)\n", cap.ConType, conType,cap_id);*/
			assert(0);
			GLOBAL_UNLOCK(cap.hContainer);
			GLOBAL_FREE(cap.hContainer);
			return FALSE;
		}
		GLOBAL_UNLOCK(cap.hContainer);
		GLOBAL_FREE(cap.hContainer);
		return TRUE;
	}

	switch (TWON_TWON(cap.ConType, conType)) {
		CASE TWON_TWON(TWON_ENUMERATION, TWON_ENUMERATION) : size = GetContainerSize(cap.ConType, my_enum->ItemType, my_enum->NumItems);
		memcpy(data, my_enum, size);

		CASE TWON_TWON(TWON_ENUMERATION, TWON_RANGE) : ConvertEnumeration2Range(*my_enum, (TW_RANGE *)data);

		CASE TWON_TWON(TWON_ENUMERATION, TWON_ONEVALUE) : ConvertEnum2OneValue(*my_enum, (TW_ONEVALUE *)data);

		CASE TWON_TWON(TWON_ARRAY, TWON_ARRAY) : size = GetContainerSize(cap.ConType, my_array->ItemType, my_array->NumItems);
		memcpy(data, my_array, size);

		CASE TWON_TWON(TWON_ONEVALUE, TWON_ONEVALUE) : memcpy(data, my_one, sizeof(TW_ONEVALUE));

		CASE TWON_TWON(TWON_ONEVALUE, TWON_RANGE) : ConvertOneValue2Range(*my_one, (TW_RANGE *)data);

		CASE TWON_TWON(TWON_ONEVALUE, TWON_ENUMERATION) : ConvertOneValue2Enum(*my_one, (TW_ENUMERATION *)data);

		CASE TWON_TWON(TWON_RANGE, TWON_RANGE) : memcpy(data, my_range, sizeof(TW_RANGE));

		CASE TWON_TWON(TWON_ENUMERATION, TWON_ARRAY) : ConvertEnum2Array(*my_enum, (TW_ARRAY *)data);

	DEFAULT:
		assert(0);
		GLOBAL_UNLOCK(cap.hContainer);
		GLOBAL_FREE(cap.hContainer);
		return FALSE;
	}
	GLOBAL_UNLOCK(cap.hContainer);
	GLOBAL_FREE(cap.hContainer);
	return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
static int ConvertOneValue2Range(TW_ONEVALUE one_value, TW_RANGE *range)
{
	range->ItemType = one_value.ItemType;
	range->MinValue = one_value.Item;
	range->MaxValue = one_value.Item;
	range->StepSize = 0;
	range->DefaultValue = one_value.Item;
	range->CurrentValue = one_value.Item;
	return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertEnumeration2Range(TW_ENUMERATION enumeration, TW_RANGE *range)
{
	range->ItemType = enumeration.ItemType;
	range->MinValue = enumeration.ItemList[0];
	range->MaxValue = enumeration.ItemList[enumeration.NumItems - 1];
	range->StepSize = (range->MaxValue - range->MinValue) / enumeration.NumItems;
	if (range->MaxValue < range->MinValue) {
		range->MaxValue = range->MinValue;
		range->StepSize = 0;
	}
	range->DefaultValue = enumeration.ItemList[enumeration.DefaultIndex];
	range->CurrentValue = enumeration.ItemList[enumeration.CurrentIndex];
	return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertOneValue2Enum(TW_ONEVALUE one_value, TW_ENUMERATION *tw_enum)
{
	tw_enum->ItemType = one_value.ItemType;
	tw_enum->NumItems = 1;
	tw_enum->CurrentIndex = 0; /* Current value is in ItemList[CurrentIndex] */
	tw_enum->DefaultIndex = 0; /* Powerup value is in ItemList[DefaultIndex] */
	tw_enum->ItemList[0] = (TW_UINT8)one_value.Item;
	return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertEnum2OneValue(TW_ENUMERATION tw_enum, TW_ONEVALUE *one_value)
{
	unsigned char *base;
	TW_UINT32 ofs;
	TW_UINT32 itemSize;

	itemSize = DCItemSize[tw_enum.ItemType];
	base = tw_enum.ItemList;
	ofs = tw_enum.CurrentIndex * itemSize;

	one_value->ItemType = tw_enum.ItemType;
	one_value->Item = 0;
	memcpy(&(one_value->Item), &(base[ofs]), itemSize);
	return TRUE;
}
/*---------------------------------------------------------------------------*/
static int ConvertEnum2Array(TW_ENUMERATION tw_enum, TW_ARRAY *array)
{
	TW_UINT32 itemSize;
	TW_UINT32 listSize;

	itemSize = DCItemSize[tw_enum.ItemType];
	listSize = itemSize * tw_enum.NumItems;
	array->ItemType = tw_enum.ItemType;
	array->NumItems = tw_enum.NumItems;
	memcpy(&(array->ItemList), &(tw_enum.ItemList), listSize);
	return TRUE;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*	      SET CAP							     */
/*---------------------------------------------------------------------------*/
int TTWAIN_SetCap(TW_UINT16 cap_id, TW_UINT16 conType, TW_UINT16 itemType,
				  TW_UINT32 *value)
{
	int rc = FALSE;
	TUINT32 size;
	TW_CAPABILITY *capability = 0;
	TW_HANDLE capabilityH = 0;
	TW_ONEVALUE *container = 0;
	TW_HANDLE containerH = 0;

	size = GetContainerSize(conType, itemType, 1);
	containerH = GLOBAL_ALLOC(GMEM_FIXED, size);
	if (!containerH)
		goto done;
	container = (TW_ONEVALUE *)GLOBAL_LOCK(containerH);

	container->ItemType = itemType;
	container->Item = *value;
	capabilityH = GLOBAL_ALLOC(GMEM_FIXED, sizeof(TW_CAPABILITY));
	if (!capabilityH) {
		GLOBAL_UNLOCK(containerH);
		GLOBAL_FREE(containerH);
		goto done;
	}

	capability = (TW_CAPABILITY *)GLOBAL_LOCK(capabilityH);
	capability->ConType = conType;
	capability->hContainer = containerH;

	if (TTWAIN_GetState() < TWAIN_SOURCE_OPEN) {
		/*TTWAIN_ErrorBox("Setting capability in State < 4.");*/
		TTWAIN_OpenSourceManager(0); /* Bring up to state 4 */
									 /*goto done;*/
	}

	capability->Cap = cap_id; /* capability id */

	rc = (TTWAIN_DS(DG_CONTROL, DAT_CAPABILITY, MSG_SET, (TW_MEMREF)capability) == TWRC_SUCCESS);

done:
	if (containerH) {
		GLOBAL_UNLOCK(containerH);
		GLOBAL_FREE(containerH);
	}

	if (capabilityH) {
		GLOBAL_UNLOCK(capabilityH);
		GLOBAL_FREE(capabilityH);
	}
	return rc;
}
/*---------------------------------------------------------------------------*/
static TUINT32 GetContainerSize(int nFormat, unsigned twty, TW_UINT32 nItems)
{
	TUINT32 size;
	switch (nFormat) {
	case TWON_ONEVALUE:
		size = sizeof(TW_ONEVALUE);
		if (DCItemSize[twty] > sizeof(TW_UINT32)) {
			size += DCItemSize[twty] - sizeof(TW_UINT32);
		}
		break;
	case TWON_RANGE:
		size = sizeof(TW_RANGE);
		break;
	case TWON_ENUMERATION:
		size = sizeof(TW_ENUMERATION) + DCItemSize[twty] * nItems - sizeof(TW_UINT8);
		break;
	case TWON_ARRAY:
		size = sizeof(TW_ARRAY) + DCItemSize[twty] * nItems - sizeof(TW_UINT8);
		break;
	default:
		size = 0;
		break;
	} /* switch */
	return size;
}
/*---------------------------------------------------------------------------*/

#ifdef __cplusplus
}
#endif