#include <comdef.h>

#pragma hdrstop

#include <stdarg.h>
#include <malloc.h>

#pragma intrinsic(memset)

#pragma warning(disable:4290)

/////////////////////////////////////////////////////////////////////////////

void __stdcall
_com_issue_error(HRESULT hr) throw(_com_error)
{
	_com_raise_error(hr, NULL);
}

void __stdcall
_com_issue_errorex(HRESULT hr, IUnknown* punk, REFIID riid) throw(_com_error)
{
	IErrorInfo* perrinfo = NULL;
	if (punk == NULL) {
		goto exeunt;
	}
	ISupportErrorInfo* psei;
	if (FAILED(punk->QueryInterface(__uuidof(ISupportErrorInfo),
			   (void**)&psei))) {
		goto exeunt;
	}
	HRESULT hrSupportsErrorInfo;
	hrSupportsErrorInfo = psei->InterfaceSupportsErrorInfo(riid);
	psei->Release();
	if (hrSupportsErrorInfo != S_OK) {
		goto exeunt;
	}
	if (GetErrorInfo(0, &perrinfo) != S_OK) {
		perrinfo = NULL;
	}
exeunt:
	_com_raise_error(hr, perrinfo);
}

/////////////////////////////////////////////////////////////////////////////

#define VT_OPTIONAL	0x0800

struct FLOAT_ARG  { BYTE floatBits[sizeof(float)]; };
struct DOUBLE_ARG { BYTE doubleBits[sizeof(double)]; };

/////////////////////////////////////////////////////////////////////////////

static HRESULT
_com_invoke_helper(IDispatch* pDispatch,
				   DISPID dwDispID,
				   WORD wFlags,
				   VARTYPE vtRet,
				   void* pvRet,
				   const wchar_t* pwParamInfo,
				   va_list argList,
				   IErrorInfo** pperrinfo) throw()
{
	*pperrinfo = NULL;

	if (pDispatch == NULL) {
		return E_POINTER;
	}

	DISPPARAMS dispparams;
	VARIANT* rgvarg;
	rgvarg = NULL;
	memset(&dispparams, 0, sizeof dispparams);

	// determine number of arguments
	if (pwParamInfo != NULL) {
		dispparams.cArgs = lstrlenW(pwParamInfo);
	}

	DISPID dispidNamed;
	dispidNamed = DISPID_PROPERTYPUT;
	if (wFlags & (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF)) {
		if (dispparams.cArgs <= 0) {
			return E_INVALIDARG;
		}
		dispparams.cNamedArgs = 1;
		dispparams.rgdispidNamedArgs = &dispidNamed;
	}

	if (dispparams.cArgs != 0) {
		// allocate memory for all VARIANT parameters
		rgvarg = (VARIANT*)_alloca(dispparams.cArgs * sizeof(VARIANT));
		memset(rgvarg, 0, sizeof(VARIANT) * dispparams.cArgs);
		dispparams.rgvarg = rgvarg;

		// get ready to walk vararg list
		const wchar_t* pw = pwParamInfo;
		VARIANT* pArg;
		pArg = rgvarg + dispparams.cArgs - 1;   // params go in opposite order

		while (*pw != 0) {
			pArg->vt = *pw & ~VT_OPTIONAL; // set the variant type
			switch (pArg->vt) {
			case VT_I2:
#ifdef _MAC
				pArg->iVal = (short)va_arg(argList, int);
#else
				pArg->iVal = va_arg(argList, short);
#endif
				break;
			case VT_I4:
				pArg->lVal = va_arg(argList, long);
				break;
			case VT_R4:
				// Note: All float arguments to vararg functions are passed
				//  as doubles instead.  That's why they are passed as VT_R8
				//  instead of VT_R4.
				pArg->vt = VT_R8;
				*(DOUBLE_ARG*)&pArg->dblVal = va_arg(argList, DOUBLE_ARG);
				break;
			case VT_R8:
				*(DOUBLE_ARG*)&pArg->dblVal = va_arg(argList, DOUBLE_ARG);
				break;
			case VT_DATE:
				*(DOUBLE_ARG*)&pArg->date = va_arg(argList, DOUBLE_ARG);
				break;
			case VT_CY:
				pArg->cyVal = *va_arg(argList, CY*);
				break;
			case VT_BSTR:
				pArg->bstrVal = va_arg(argList, BSTR);
				break;
			case VT_DISPATCH:
				pArg->pdispVal = va_arg(argList, LPDISPATCH);
				break;
			case VT_ERROR:
				pArg->scode = va_arg(argList, SCODE);
				break;
			case VT_BOOL:
#ifdef _MAC
				V_BOOL(pArg) = (VARIANT_BOOL)va_arg(argList, int)
									? VARIANT_TRUE : VARIANT_FALSE;
#else
				V_BOOL(pArg) = va_arg(argList, VARIANT_BOOL)
									? VARIANT_TRUE : VARIANT_FALSE;
#endif
				break;
			case VT_VARIANT:
				*pArg = *va_arg(argList, VARIANT*);
				break;
			case VT_UNKNOWN:
				pArg->punkVal = va_arg(argList, LPUNKNOWN);
				break;
			case VT_DECIMAL:
				pArg->decVal = *va_arg(argList, DECIMAL*);
				pArg->vt = VT_DECIMAL;
				break;
			case VT_UI1:
#ifdef _MAC
				pArg->bVal = (BYTE)va_arg(argList, int);
#else
				pArg->bVal = va_arg(argList, BYTE);
#endif
				break;

			case VT_I2|VT_BYREF:
				pArg->piVal = va_arg(argList, short*);
				break;
			case VT_I4|VT_BYREF:
				pArg->plVal = va_arg(argList, long*);
				break;
			case VT_R4|VT_BYREF:
				pArg->pfltVal = va_arg(argList, float*);
				break;
			case VT_R8|VT_BYREF:
				pArg->pdblVal = va_arg(argList, double*);
				break;
			case VT_DATE|VT_BYREF:
				pArg->pdate = va_arg(argList, DATE*);
				break;
			case VT_CY|VT_BYREF:
				pArg->pcyVal = va_arg(argList, CY*);
				break;
			case VT_BSTR|VT_BYREF:
				pArg->pbstrVal = va_arg(argList, BSTR*);
				break;
			case VT_DISPATCH|VT_BYREF:
				pArg->ppdispVal = va_arg(argList, LPDISPATCH*);
				break;
			case VT_ERROR|VT_BYREF:
				pArg->pscode = va_arg(argList, SCODE*);
				break;
			case VT_BOOL|VT_BYREF:
				pArg->pboolVal = va_arg(argList, VARIANT_BOOL*);
				break;
			case VT_VARIANT|VT_BYREF:
				pArg->pvarVal = va_arg(argList, VARIANT*);
				break;
			case VT_UNKNOWN|VT_BYREF:
				pArg->ppunkVal = va_arg(argList, LPUNKNOWN*);
				break;
			case VT_DECIMAL|VT_BYREF:
				pArg->pdecVal = va_arg(argList, DECIMAL*);
				break;
			case VT_UI1|VT_BYREF:
				pArg->pbVal = va_arg(argList, BYTE*);
				break;

			default:
				// M00REVIEW - For safearrays, should be able to type-check
				// against the base VT_* type.(?)
				if (pArg->vt & VT_ARRAY) {
					if (pArg->vt & VT_BYREF) {
						pArg->pparray = va_arg(argList, LPSAFEARRAY*);
					} else {
						pArg->parray = va_arg(argList, LPSAFEARRAY);
					}
					break;
				}
				// unknown type!
				return E_INVALIDARG;
			}

			--pArg; // get ready to fill next argument
			++pw;
		}

		// Check for missing optional unnamed args at the end of the arglist,
		// and remove them from the DISPPARAMS.  This permits calling servers
		// which modify their action depending on the actual number of args.
		// E.g. Excel95 Application.Workbooks returns a Workbooks* if called
		// with no args, a Workbook* if called with one arg - this shouldn't
		// be necessary, but Excel95 doesn't appear to check for missing
		// args indicated by VT_ERROR/DISP_E_PARAMNOTFOUND.
		pArg = rgvarg + dispparams.cNamedArgs;
		pw = pwParamInfo + dispparams.cArgs - dispparams.cNamedArgs - 1;
		unsigned int cMissingArgs = 0;

		// Count the number of missing arguments
		while (pw >= pwParamInfo) {
			// Optional args must be VARIANT or VARIANT*
			if ((*pw & ~VT_BYREF) != (VT_VARIANT|VT_OPTIONAL)) {
				break;
			}

			VARIANT* pVar;
			pVar = (*pw & VT_BYREF) ? pArg->pvarVal : pArg;
			if (V_VT(pVar) != VT_ERROR ||
				V_ERROR(pVar) != DISP_E_PARAMNOTFOUND)
			{
				break;
			}

			++cMissingArgs;
			++pArg;
			--pw;
		}

		// Move the named args up next to the remaining unnamed args and
		// adjust the DISPPARAMS struct.
		if (cMissingArgs > 0) {
			for (unsigned int c = 0; c < dispparams.cNamedArgs; ++c) {
				rgvarg[c + cMissingArgs] = rgvarg[c];
			}
			dispparams.cArgs -= cMissingArgs;
			dispparams.rgvarg += cMissingArgs;
		}
	}

	// initialize return value
	VARIANT* pvarResult;
	VARIANT vaResult;
	VariantInit(&vaResult);
	pvarResult = (vtRet != VT_EMPTY) ? &vaResult : NULL;

	// initialize EXCEPINFO struct
	EXCEPINFO excepInfo;
	memset(&excepInfo, 0, sizeof excepInfo);

	UINT nArgErr;
	nArgErr = (UINT)-1;  // initialize to invalid arg

	// make the call
	HRESULT hr = pDispatch->Invoke(dwDispID, __uuidof(NULL), 0, wFlags,
								   &dispparams, pvarResult, &excepInfo,
								   &nArgErr);

	// throw exception on failure
	if (FAILED(hr)) {
		VariantClear(&vaResult);
		if (hr != DISP_E_EXCEPTION) {
			// non-exception error code
			// M00REVIEW - Is this all?  What about looking for IErrorInfo?
			//			 - Only if IID is passed in, I'd think
			return hr;
		}

		// make sure excepInfo is filled in
		if (excepInfo.pfnDeferredFillIn != NULL) {
			excepInfo.pfnDeferredFillIn(&excepInfo);
		}

		// allocate new error info, and fill it
		ICreateErrorInfo *pcerrinfo = NULL;
		if (SUCCEEDED(CreateErrorInfo(&pcerrinfo))) {
			// Set up ErrInfo object
			// M00REVIEW - Use IID if decide to pass that in
			pcerrinfo->SetGUID(__uuidof(IDispatch));
			pcerrinfo->SetDescription(excepInfo.bstrDescription);
			pcerrinfo->SetHelpContext(excepInfo.dwHelpContext);
			pcerrinfo->SetHelpFile(excepInfo.bstrHelpFile);
			pcerrinfo->SetSource(excepInfo.bstrSource);

			if (FAILED(pcerrinfo->QueryInterface(__uuidof(IErrorInfo),
												 (void**)pperrinfo))) {
				*pperrinfo = NULL;
			}
		}

		if (excepInfo.wCode != 0) {
            hr = _com_error::WCodeToHRESULT(excepInfo.wCode);
		} else {
			hr = excepInfo.scode;
		}
		return hr;
	}

	if (vtRet != VT_EMPTY) {
		// convert return value unless already correct
		if (vtRet != VT_VARIANT && vtRet != vaResult.vt) {
			hr = VariantChangeType(&vaResult, &vaResult, 0, vtRet);
			if (FAILED(hr)) {
				VariantClear(&vaResult);
				return hr;
			}
		}

		// copy return value into return spot!
		switch (vtRet) {
		case VT_I2:
			*(short*)pvRet = vaResult.iVal;
			break;
		case VT_I4:
			*(long*)pvRet = vaResult.lVal;
			break;
		case VT_R4:
			*(FLOAT_ARG*)pvRet = *(FLOAT_ARG*)&vaResult.fltVal;
			break;
		case VT_R8:
			*(DOUBLE_ARG*)pvRet = *(DOUBLE_ARG*)&vaResult.dblVal;
			break;
		case VT_DATE:
			*(DOUBLE_ARG*)pvRet = *(DOUBLE_ARG*)&vaResult.date;
			break;
		case VT_CY:
			*(CY*)pvRet = vaResult.cyVal;
			break;
		case VT_BSTR:
			*(BSTR*)pvRet = vaResult.bstrVal;
			break;
		case VT_DISPATCH:
			*(LPDISPATCH*)pvRet = vaResult.pdispVal;
			break;
		case VT_ERROR:
			*(SCODE*)pvRet = vaResult.scode;
			break;
		case VT_BOOL:
			*(VARIANT_BOOL*)pvRet = V_BOOL(&vaResult);
			break;
		case VT_VARIANT:
			*(VARIANT*)pvRet = vaResult;
			break;
		case VT_UNKNOWN:
			*(LPUNKNOWN*)pvRet = vaResult.punkVal;
			break;
		case VT_DECIMAL:
			*(DECIMAL*)pvRet = vaResult.decVal;
			break;
		case VT_UI1:
			*(BYTE*)pvRet = vaResult.bVal;
			break;

		default:
			if ((vtRet & (VT_ARRAY|VT_BYREF)) == VT_ARRAY) {
				// M00REVIEW - type-check against the base VT_* type?
				*(LPSAFEARRAY*)pvRet = vaResult.parray;
				break;
			}
			// invalid return type!
			VariantClear(&vaResult);
			return E_INVALIDARG;
		}
	}
	return hr;
}

/////////////////////////////////////////////////////////////////////////////

HRESULT __cdecl
_com_dispatch_raw_method(IDispatch* pDispatch,
						 DISPID dwDispID,
						 WORD wFlags,
						 VARTYPE vtRet,
						 void* pvRet,
						 const wchar_t* pwParamInfo,
						 ...) throw()
{
	va_list argList;
	va_start(argList, pwParamInfo);

	IErrorInfo* perrinfo;
	HRESULT hr = _com_invoke_helper(pDispatch,
									dwDispID,
									wFlags,
									vtRet,
									pvRet,
									pwParamInfo,
									argList,
									&perrinfo);
	if (FAILED(hr)) {
		SetErrorInfo(0, perrinfo);
	}

	va_end(argList);
	return hr;
}

HRESULT __cdecl
_com_dispatch_method(IDispatch* pDispatch,
					 DISPID dwDispID,
					 WORD wFlags,
					 VARTYPE vtRet,
					 void* pvRet,
					 const wchar_t* pwParamInfo,
					 ...) throw(_com_error)
{
	va_list argList;
	va_start(argList, pwParamInfo);

	IErrorInfo* perrinfo;
	HRESULT hr = _com_invoke_helper(pDispatch,
									dwDispID,
									wFlags,
									vtRet,
									pvRet,
									pwParamInfo,
									argList,
									&perrinfo);
	if (FAILED(hr)) {
		_com_raise_error(hr, perrinfo);
	}

	va_end(argList);
	return hr;
}

HRESULT __stdcall
_com_dispatch_raw_propget(IDispatch* pDispatch,
						  DISPID dwDispID,
						  VARTYPE vtProp,
						  void* pvProp) throw()
{
	return _com_dispatch_raw_method(pDispatch,
									dwDispID,
									DISPATCH_PROPERTYGET,
									vtProp,
									pvProp,
									NULL);
}

HRESULT __stdcall
_com_dispatch_propget(IDispatch* pDispatch,
					  DISPID dwDispID,
					  VARTYPE vtProp,
					  void* pvProp) throw(_com_error)
{
	return _com_dispatch_method(pDispatch,
								dwDispID,
								DISPATCH_PROPERTYGET,
								vtProp,
								pvProp,
								NULL);
}

HRESULT __cdecl
_com_dispatch_raw_propput(IDispatch* pDispatch,
						  DISPID dwDispID,
						  VARTYPE vtProp,
						  ...) throw()
{
	va_list argList;
	va_start(argList, vtProp);
#ifdef _MAC
	argList -= 2;
#endif

	wchar_t rgwParams[2];
	rgwParams[0] = vtProp;
	rgwParams[1] = 0;

	WORD wFlags = (vtProp == VT_DISPATCH || vtProp == VT_UNKNOWN)
					? DISPATCH_PROPERTYPUTREF : DISPATCH_PROPERTYPUT;

	IErrorInfo* perrinfo;
	HRESULT hr = _com_invoke_helper(pDispatch,
									dwDispID,
									wFlags,
									VT_EMPTY,
									NULL,
									rgwParams,
									argList,
									&perrinfo);
	if (FAILED(hr)) {
		SetErrorInfo(0, perrinfo);
	}

	va_end(argList);
	return hr;
}

HRESULT __cdecl
_com_dispatch_propput(IDispatch* pDispatch,
					  DISPID dwDispID,
					  VARTYPE vtProp,
					  ...) throw(_com_error)
{
	va_list argList;
	va_start(argList, vtProp);
#ifdef _MAC
	argList -= 2;
#endif

	wchar_t rgwParams[2];
	rgwParams[0] = vtProp;
	rgwParams[1] = 0;

	WORD wFlags = (vtProp == VT_DISPATCH || vtProp == VT_UNKNOWN)
					? DISPATCH_PROPERTYPUTREF : DISPATCH_PROPERTYPUT;

	IErrorInfo* perrinfo;
	HRESULT hr = _com_invoke_helper(pDispatch,
									dwDispID,
									wFlags,
									VT_EMPTY,
									NULL,
									rgwParams,
									argList,
									&perrinfo);
	if (FAILED(hr)) {
		_com_raise_error(hr, perrinfo);
	}

	va_end(argList);
	return hr;
}