/**
 * 	\file: 	main.cpp
 *
 *  \brief 	ARM side main routine for DSP Hello World application.
 *  		The ARM sets itself up, sends a message to the DSP,
 *  		and then waits for a return message before exiting.
 *
 *     o  0
 *     | /       Copyright (c) 2005-2010
 *    (CL)---o   Critical Link, LLC
 *      \
 *       O
 */

#include "dspapp.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ipc_inbound.h"
#include "ipc_outbound.h"

using namespace MityDSP;

enum MsgCommand {
	eReadFromARM,
	eWriteToARM,
	eReadFromDSP,
	eWriteToDSP
};

enum MsgTypes {
	eGlobalFixture,
	eLibrary,
	eGlobalUser,
	eGlobalSerialPort,
	eGlobalScannerJog,
	eFeature,
	eFeatureData,
	eFeatureDataSource,
	eFeatureExpressions,
	eFeatureFixture,
	eFeatureMeasurement,
	eFeatureSegmentList,
	eGlobalDigitalInputs,
	eGlobalDigitalOutputs,
	eGlobalFactory,
	eDebugText
};

typedef struct {
	MsgTypes type;
	MsgCommand command;
} Header;

typedef struct {
	Header header;
	char 	textMessage[100]; // 100 bytes for now
} DebugText;

typedef struct {
	Header header;
	char 	fixtureName[33];
	int	fixtureID;
	int	fixtureTencoderpe;
	int	fixtureURR;
	int	fixtureHomeMethod;
	int	fixtureZeroMethod;
	int	fixtureMotion;
	int	fixtureDirection;
	int	fixtureOrientation;
	double	fixtureLinearTravel;
	double	fixtureRotaryTravel;
	int	motorPresent;
	int	motorPort;
	int	motorRotation;
	double	motorGearRatioIn;
	double	motorGearRationOut;
	int	motorType;
	int	motorMaxSpeed;
	int	motorStepsPerRevolution;
	char	motorAcceleration[16]; // todo
	int	encoderPresent;
	int	encoderPort;
	int	encoderRotation;
	double	encoderGearRatioIn;
	double	encoderGearRationOut;
	int	encoderResolution;
	int	encoderIndexPresent;
	int	encoderIndexInput;
	int	encoderIndexIsHome;
	int	encoderIndexIsEndOfTravel;
	int	encoderQuadratureMode;
	int	homeSensorPresent;
	int	homeSensorInput;
	int	homeSensorType;
	int	homeSensorDirection;
	int	endOfTravelSensorPresent;
	int	endOfTravelSensorInput;
	int	endOfTravelSensorType;
	int	endOfTravelSensorDirection;
	char 	inputMapping[5]; // todo
	char 	outputMapping[8]; // todo
	double	pulleyDiam;
	int	pulleyUnits;
} GlobalFixture_str ;

typedef struct {
	Header header;
	int	SerialNumber;
	double	AnalogCalMinValue;
	double	AnalogCalMaxValue;
	double	AnalogCalGain;
	double	AnalogOffset;
	int	LowPowerScannerType;
	int	LowPowerValue;
	int	CalibrationUnits;
	double	CalibrationSmallPart;
	double	CalibrationLargePart;
	double	CalibrationmValue;
	double	CalibrationbValue;
	char	CalibrationDate[20];
} GlobalFactory_str ;

typedef struct {
	Header header;
	int	DigInputID;
	int	ActivationType;
	int	FunctionID;
} GlobalDigitalInputs_str ;

typedef struct {
	Header header;
	int	DigOutputID;
	int	Polarity;
	int	Latched;
	int	ServerID;
} GlobalDigitalOutputs_str ;

typedef struct {
	Header header;
	int	SerialPortID;
	int	BaudRate;
	int	ParityBits;
	int	DataBits;
	int	StopBits;
	int	FlowControl;
	int	ProtocolFlag;
	int	DataFlag;
} GlobalSerialPort_str ;

typedef struct {
	Header header;
	int	FeatureID;
	int	LibraryToFeatureKey;
	char 	Name[16];
	int	AdvanceMode;
	int	AdvanceDelay;
	double	SizeOffset;
	double	PositionOffset;
	int	URRUnits;
	int	URRResolution;
	int	URRRounding;
	int	DataSourceExpressionType;
	int	DataSource_op;
	int	Sequence;
	double	ToleranceRejectPlus;
	double	ToleranceRejectMinus;
	double	ToleranceWarningPlus;
	double	ToleranceWarningMinus;
	double	ToleranceNominal;
	bool	ToleranceRejectEnablePlus;
	bool	ToleranceRejectEnableMinus;
	bool	ToleranceWarningEnablePlus;
	bool	ToleranceWarningEnableMinus;
	int	UseFixtureToCollectData;
	int	UseFixtureForAutoPositioning;
	double	UserSingleMasterSize;
} Feature_str ;

typedef struct {
	Header header;
	int	FeatureToDataKey;
	int	LibraryToDataKey;
	char 	Label[16];
	int	DisplayLine;
	int	SerialPortSelected;
	int	UseAsLimits;
} FeatureData_str ;

typedef struct {
	Header header;
	int	FeatureToDataKey;
	int	LibraryToDataKey;
	int	TermType;
	double	TermConstanst;
	int	TermFeatureID;
	int	TermID;
} FeatureDataSource_str ;

typedef struct {
	Header header;
	int	FeatureToDataKey;
	int	LibraryToDataKey;
	int Segment ;
} FeatureSegmentList_str ;

typedef struct {
	Header header;
	int	FeatureToDataKey;
	int	LibraryToDataKey;
	int	Type;
	int	EdgeCount;
	int	GlassMode;
	int	InternalRefFlag;
	int	LowerRefFlag;
	int	UpperRefFlag;
	int	PartSegmentIndex;
	int	PartModeFlag;
	int	SamplingMode;
	int	AveragingMode;
	int	AveragingPeriod;
	int	GoodScans;
	int	EnterDelayMode;
	int	EnterDelayPeriod;
	char	FormatString[34];
	int	PolledFlag;
} FeatureMeasurement_str ;

typedef struct {
	Header header;
	int	FeatureToDataKey;
	int	LibraryToDataKey;
	int LineOrder;
	char ExpressionText[50];
} FeatureExpressions_str ;

typedef struct {
	Header header;
	int	FeatureToDataKey;
	int	LibraryToDataKey;
	int	FixtureID;
	int	DisableMotorAfterMove;
	int	IDODWALLComputeWall;
	int	MeasurementMode;
	int	UsageMode;
	int	AutomaticShankDiamFlag;
	double	Speed;
	int	StepMode;
	int	ReturnPosition;
	int	NumberOfMeasurementPositions;
	double	TotalDistance;
	double	StartPosition;
	double	ShankDiameter;
} FeatureFixture_str ;

typedef struct {
	Header header;
	int	ScannerJogID;
	double	mOffset;
	double	bOffset;
	double	LowSize;
	double	HighSize;
} GlobalScannerJog_str ;

typedef struct {
	Header header;
	char 	LanguageName[20];
	char 	LanguagePrefix[5];
	char 	Password[8];
	int	PowerUpLocked;
	int	AllowNominalChanges;
	int	AllowRemastering;
	int	AllowLibraryChanges;
	int	AdvancedScreenOperation;
	int	AutoScrollEnable;
	int	AudibleAlarm;
	int	FlipScreen180;
	int	ScannerDoubleDiff;
	int	LatchScanErrors;
	int	IgnoreScanErrors;
	char	IPAddress[20];
	int	ButtonsDefined;
	int	ButtonID_1;
	int	ButtonID_2;
	int	ButtonID_3;
} GlobalUser_str ;

typedef struct {
	Header header;
	int LibraryID;
	char LibraryName[16];
	double   UserDualPointMasterSize1;
	double   UserDualPointMasterSize2;
	double    AlarmDuration;
	int   AlarmEnable;
	int   SQCBatchSize;
	int   SQCBatchClearAtEndOfBatch;
	int   SQCBatchPrintAtEndOfBatch;
	int   FeatureCount;
	int   SerialDOFAutoSendFlag;
	int   SerialDOFAutoSendDelay;
	int   SerialDOFDateTimeFlag;
	int   SerialDOFLabelFlag;
	int   SerialDOFHeaderType;
	int   SerialDOFRequestorType;
	char   SerialDOFRequestorString[5];
	int   SerialDOFSeparatorType;
	char   SerialDOFSeparatorString[5];
	int  SerialDOFTerminatorType;
	char   SerialDOFTerminatorString[5];
	int   SerialDOFDecimalFlag;
	int   SerialDOFSignFlag;
	double   LegacySlideCounterPerInch;
	int   ReportSelected1;
	int   ReportSelected2;
	int   ReportSelected3;
	int   ReportSelected4;
	char   ReportUserTitle[33];
	int   ReportPrinterPort;
	int   ReportDisableHeaderAndFooter;
	int   ReportDisableFormFeed;
	int   URRUnits;
	int   URRResolution;
	int   URRRounding;
} Library_str ;

typedef union {
	Header header;
	DebugText debugMsg;
	Library_str library;
	GlobalFixture_str globalFixture;
	GlobalUser_str globalUser;
	GlobalScannerJog_str globalScannerJog;
	FeatureFixture_str featureFixture;
	FeatureExpressions_str featureExpressions;
	FeatureMeasurement_str featureMeasurement;
	FeatureSegmentList_str featureSegmentList;
	FeatureDataSource_str featureDataSource;
	FeatureData_str featureData;
	Feature_str feature;
	GlobalFactory_str globalFactory;
	GlobalDigitalInputs_str globalDigitalInputs;
	GlobalDigitalOutputs_str globalDigitalOutputs;
	GlobalSerialPort_str globalSerialPort;
} allTypes;

allTypes  messageA2D;   // message data between DSP and ARM
Library_str library;	// message one this side.

// Forward declarations
int handleInboundMessage(void *Buffer, uint16_t Length, void *UserArg);
int handleInboundMessageBM(void *Buffer, uint16_t Length, void *UserArg);

volatile bool gbDone = false;

int main(int argc, char* argv[])
{
	// tcDspApp class for booting and loading the DSP
	tcDspApp* 		lpDspApp = NULL;
	// Used to setup handling of inbound messages from DSP
	tcIPCInbound* 	lpMessageInbound  = NULL;
	// Used to send messages to the DSP
	tcIPCOutbound* 	lpMessageOutbound  = NULL;
	// Message to send to the DSP
	char			lpMessage[] = "Hello DSP";
	// Pointer to buffer obtained from dsplink
	char*			lpMessageBuffer = NULL;
	// Message from standard input
	char 			lpUsrMsg[180] = {0};

	// Check application usage
	if (argc < 2)
	{
		fprintf(stderr, "usage: HelloWorld dsp_image.out\n");
		return -1;
	}

	// Create the DspApp object
	lpDspApp = new tcDspApp();
	if (lpDspApp != NULL) {
		fprintf(stderr, "DSP app was created\n");
	} else {
		fprintf(stderr, "DSP app was not created\n");
	}

	// Load the DSP.out file
	fprintf(stderr, "Loading file %s\n", argv[1]);
	int retCode;
	retCode = lpDspApp->LoadApp(argv[1], true, argc>2?1:0);

	fprintf(stderr, "Return code from Load App = %d\n", retCode);
	fprintf(stderr, "Starting application.\n");

	// Create the object to handle incoming messages from the DSP
	lpMessageInbound =  new tcIPCInbound((char*)"GPPMSGQ1");

	if (NULL != lpMessageInbound)
	{
		// Register the callback for handling messages from the DSP
		lpMessageInbound->Register(handleInboundMessageBM, (void*)NULL);

		// Intialize the inbound controller to create the thread that handles the callbacks
		lpMessageInbound->Initialize();
	} else {
		fprintf(stderr, "lpMessageInBound was null for some reason\n");
	}

	// Create the object used to send messages to the DSP
	lpMessageOutbound = new tcIPCOutbound((char*)"DSPMSGQ0");

	// Wait for the DSP to finish initialization (really just waiting for first message, which indicates DSP set up ok)
	while(false == gbDone) {
		sleep(3); //fprintf(stderr, "waiting for DSP\n");
	}

	// Reset bool in preparation for next received message from DSP
	gbDone = false;

	// Get a buffer for a message to the DSP
	lpMessageBuffer = (char*)lpMessageOutbound->GetBuffer(sizeof(messageA2D));

	allTypes messageA2D;
	messageA2D.library.header.command = eWriteToDSP;
	messageA2D.library.header.type = eLibrary;
	messageA2D.library.FeatureCount = 0;
	messageA2D.library.SQCBatchSize = 9;

 	// Copy the message to the dsplink buffer
	memcpy(lpMessageBuffer, &messageA2D, sizeof(messageA2D));
	// Send the message to the DSP
	fprintf(stderr, "Sending a message to the DSP.\n");
	lpMessageOutbound->SendMessage(lpMessageBuffer);

/* original sample code....
 * 	// Copy the message to the dsplink buffer
	strcpy(lpMessageBuffer, lpMessage);

	// Send the message to the DSP
	fprintf(stderr, "Sending a message to the DSP.\n");
	lpMessageOutbound->SendMessage(lpMessageBuffer);
****************** */
	// Wait for a message to be received from the DSP or for user to quit
	fprintf(stderr, "Waiting for DSP response \n");
	int counter=0; // lets send a few messages back and forth and then quit
	while (gbDone == false ) {
		counter++;
//		fprintf(stderr, "after first one looping %d\n", counter);
	}
	gbDone = false; // reset flag

	// send the Library msg back to the DSP, it will send it back to us automatically.
	fprintf(stderr, "after second one looping %d\n", counter);
	// Create the object used to send messages to the DSP
	lpMessageOutbound = new tcIPCOutbound((char*)"DSPMSGQ0");
	if (NULL != lpMessageOutbound)
	{
		fprintf(stderr, "\n");
	}
	// Get a buffer for a message to the DSP
	lpMessageBuffer = (char*)lpMessageOutbound->GetBuffer(sizeof(messageA2D));
	if (lpMessageBuffer) {
		memcpy(lpMessageBuffer, &library, sizeof(messageA2D));
		lpMessageOutbound->SendMessage(lpMessageBuffer);
	} else {
		fprintf(stderr, "did not get 2nd message buffer for some reason\n");
		gbDone = true;
	}
	while (gbDone == false ) {
		counter++;
	}
	gbDone = false; // reset flag

	fprintf(stderr, "after third one looping %d\n", counter);
	// send the Library msg back to the DSP, it will send it back to us automatically.
	// Get a buffer for a message to the DSP
	lpMessageBuffer = (char*)lpMessageOutbound->GetBuffer(sizeof(messageA2D));
	if (lpMessageBuffer) {
		memcpy(lpMessageBuffer, &library, sizeof(messageA2D));
		lpMessageOutbound->SendMessage(lpMessageBuffer);
	} else {
		fprintf(stderr, "did not get 3rd message buffer for some reason\n");
		gbDone = true;
	}
	while (gbDone == false ) {
		counter++;
		//fprintf(stderr, "after third one looping %d\n", counter);
	}
	gbDone = false; // reset flag

	// Wait for a message to be received from the DSP or for user to quit
	fprintf(stderr, "Waiting for DSP response (type \'q\' to quit)...\n");
	while(gbDone == false && lpUsrMsg[0] != 'q')
	{
		fgets(lpUsrMsg, 180, stdin);
	}

	/*int counter=0;
	while(counter++ < 2000) {
		sleep(3);
		fprintf(stderr, "waiting sending serial messages via DSP? %d\n", i);
	}*/

	fprintf(stderr, "Exiting application.\n");

	// Stop the DSP application from running
	lpDspApp->StopApp();

	// Cleanup
	// Commented out because deletes throw Assert errors.
	//delete lpDspApp;
	//delete lpMessageInbound;
	//delete lpMessageOutbound;

	return 0;
}

/**
 *	Handle inbound messages from the DSP.
 *
 *	\param apBuffer		Pointer to the buffer containing the message.
 *	\param anLength 	The length of the message.
 *	\param apUserArg	User defined argument.
 *
 *	\return 0.
 */
int handleInboundMessage(void *apBuffer, uint16_t anLength, void *apUserArg)
{
	fprintf(stderr, "ARM received a message from the DSP:\n");

	// Print the message we received
	fprintf(stderr, "\tDSP Message = \"%s\" len = %d\n", (char *)apBuffer, anLength);

	// Notify the main function that we have received a message from the DSP and are done
	gbDone = true;

	return 0;
}

/**
 *	Handle inbound messages from the DSP.
 *
 *	\param apBuffer		Pointer to the buffer containing the message.
 *	\param anLength 	The length of the message.
 *	\param apUserArg	User defined argument.
 *
 *	\return 0.
 */
int handleInboundMessageBM(void *apBuffer, uint16_t anLength, void *apUserArg)
{
	fprintf(stderr, "handleInboundMessageBM:ARM received a message from the DSP:\n");

	// Print the message we received
	fprintf(stderr, "\tDSP Messagelen = %d\n", anLength);
	allTypes messageA2D;
	memcpy(&messageA2D,  (char *)apBuffer, sizeof(messageA2D));
	switch (messageA2D.header.type) {
	case eLibrary:
		// for fun just print some values recv'd from the DSP
		fprintf(stderr, "messageA2D.library.FeatureCount = %d\n", messageA2D.library.FeatureCount);
		fprintf(stderr, "messageA2D.library.SQCBatchSize = %d\n", messageA2D.library.SQCBatchSize);

		memcpy(&library, &messageA2D, sizeof(messageA2D)); // save a local copy of the library data...
		fprintf(stderr, "after doing memcpy at %d\n", __LINE__);
		break;
	case eDebugText:
		// print message from DSP.
		fprintf(stderr, "Message: %s\n", messageA2D.debugMsg.textMessage );
		break;
	};

	// Notify the main function that we have received a message from the DSP and are done
	gbDone = true;

	fprintf(stderr, "handleInboundMessageBM:leaving ...\n");
	return 0;
}