#include <mclmcr.h>
#include <mex.h>
#include <string.h>
#include <libfun.h>
#include <ctl.h>
#include <mexhelper.h>

/* Does not work. */

extern void mexFunction (int nresults, mxArray **arrresults, 
		int nargs, const mxArray **arrargs);

static HMCRINSTANCE _mcr_inst = NULL;

const unsigned char __MCC_public_data[] = { "" };
const char *__MCC_name_data = "";
const char *__MCC_root_data = "";
const unsigned char __MCC_session_data[] = { "" };
const char *__MCC_matlabpath_data[] = { "" };
const int __MCC_matlabpath_data_count = 0;
const char *__MCC_classpath_data[] = { "" };
const int __MCC_classpath_data_count = 0;
const char *__MCC_lib_path_data[] = { "" };
const int __MCC_lib_path_data_count = 0;
const char *__MCC_mcr_application_options[] = { "" };
const int __MCC_mcr_application_option_count = 0;
const char *__MCC_mcr_runtime_options[] = { "" };
const int __MCC_mcr_runtime_option_count = 0;

static int mclDefaultPrintHandler(const char *s)
{
    return fwrite(s, sizeof(char), strlen(s), stdout);
}

static int mclDefaultErrorHandler(const char *s)
{
    int written = 0, len = 0;
    len = strlen(s);
    written = fwrite(s, sizeof(char), len, stderr);
    if (len > 0 && s[ len-1 ] != '\n')
        written += fwrite("\n", sizeof(char), 1, stderr);
    return written;
}

int main (int argc, char **argv)
{
	/*if (_mcr_inst == NULL)
	{
		if (!mclmcrInitialize())
			std::cout << "Could not initialize MCR.\n";
		if (!mclInitializeComponentInstance(&_mcr_inst, __MCC_public_data,
				__MCC_name_data,
                __MCC_root_data,
                __MCC_session_data,
                __MCC_matlabpath_data,
                __MCC_matlabpath_data_count,
                __MCC_classpath_data,
                __MCC_classpath_data_count,
                __MCC_lib_path_data,
                __MCC_lib_path_data_count,
                __MCC_mcr_runtime_options,
                __MCC_mcr_runtime_option_count,
                true, NoObjectType, LibTarget, NULL,
                mclDefaultErrorHandler, mclDefaultPrintHandler))
			std::cout << "Could not initialize MCL component data.\n";
	}*/

	libfunInitialize();

	mxArray **args = (mxArray **)malloc(sizeof(mxArray*)*2);
	args[0] = mxCreateDoubleMatrix(3, 3, mxREAL);
	double data[] = {4, 1, 0, 1, 4, 1, 0, 1, 4};
	double *values = mxGetPr(args[0]);
	memcpy(values, data, sizeof(double)*9);
	args[1] = mxCreateDoubleMatrix(1, 3, mxREAL);
	myVector<double> v(3);
	for (int i=0;i<3;i++)
		v[i] = 0.5;
	mexConvert(args[1], v);
	//values = mxGetPr(args[1]);

	mxArray **res = NULL;
	ctl::openLog("stderr", -1);
	ctl::link lnk("./lineq -l pipe");
	ctl::setLink("LinEq", lnk);
	mexFunction(1, res, 2, (const mxArray **)args);

	libfunTerminate();
	return 0;
}