#include "RdParam.h"

//==============================================================================
//
// Title:		ZScan
// Purpose:		A short description of the application.
//
// Created on:	5/6/2014 at 12:45:37 PM by Arnaud Madur.
// Copyright:	LBNL. All Rights Reserved.
//
//==============================================================================

//==============================================================================
// Include files

#include <ansi_c.h>
#include <cvirte.h>		
#include <userint.h>
#include "ZScan.h"
#include "toolbox.h"
#include "Utilities.h"
#include "Hp3458.h"

//==============================================================================
// Constants
#define PRMFILE "w:\\LCLS-II\\data\\ZScan.prm"
#define UNDPRMFILE "w:\\LCLS-II\\data\\Und.prm"
//==============================================================================
// Types

//==============================================================================
// Static global variables

//==============================================================================
// Static functions

//==============================================================================
// Global variables
static int panelHandle_SC;
static int panelHandle_PM;
static int menuHandle;
FILE *fpl;	// pointer to log file


//==============================================================================
// Global functions

/// HIFN The main entry-point function.
int main (int argc, char *argv[])
{
	int error = 0;
	char und_prm_file[FILENAME] = UNDPRMFILE;
	char param_file[FILENAME] = PRMFILE;
	char log_file[FILENAME];
	char buffer[LINE];
	int i, j, ln;
	FILE *fpi;

	// initialize and load resources 
	nullChk (InitCVIRTE (0, argv, 0));
	errChk (panelHandle_SC = LoadPanel (0, "ZScan.uir", SCAN_PANEL));  // Main panel
	errChk (panelHandle_PM = LoadPanel (0, "RdParam.uir", PRM_PANEL)); // Parameter panel

	errChk (menuHandle= LoadMenuBar (SCAN_PANEL, "ZScan.uir", MENUBAR));  //Loads menu bar


	
	// Read in undulator name and data directory
	fpi = fopen (und_prm_file, "r");
	fgets (und_name, LINE, fpi);
	fgets (buffer, LINE, fpi);
	sscanf (buffer, "%d", &und_nmbr);
	fgets (und_dir, FILENAME, fpi);
	fclose (fpi);
	SetCtrlVal (panelHandle_SC, SCAN_PANEL_STR_ID, und_name);
	SetCtrlVal (panelHandle_SC, SCAN_PANEL_STR_DIR, und_dir);
	
	// Create data file name
	ln = strlen (und_dir);
	ln--;	// last character is EOL - don't copy
	for (i = 0; i < ln; i++)
		und_file[i] = und_dir[i];
	ln = strlen (und_name);
	ln--;	// last character is EOL - don't copy
	for (j = 0; j < ln; j++, i++)
		und_file[i] = und_name[j];
	und_file[i] = '\0'; 
	sprintf (buffer, "%d", und_nmbr);
	strcat (und_file, buffer);
	strcat (und_file, ".dat");

	// Read parameters
	RdParamFile (param_file);
	
	// Allocate vectors
	Vx = (double *) calloc (num_pnts, sizeof(double));
	Vy = (double *) calloc (num_pnts, sizeof(double));
	Bx = (double *) calloc (num_pnts, sizeof(double));
	By = (double *) calloc (num_pnts, sizeof(double));
	z = (double *) calloc (num_pnts, sizeof(double));

	// display the main panel
	errChk (DisplayPanel (panelHandle_SC));
	
	// Setup parameter panel and display
	SetCtrlVal (panelHandle_PM, PRM_PANEL_ST_ID, und_name);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_ST_DATA_DIR, und_dir);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_GPIB_1, GPIBDVM[0]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_GPIB_2, GPIBDVM[1]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_GPIB_3, GPIBDVM[2]); 
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_VS_DVM1, DCV[0]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_VS_DVM2, DCV[1]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_VS_DVM3, DCV[2]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_SC_V, Sc_V);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_SC_STRT, Sc_strt);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_SC_STP, Sc_stp);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_X1, HP_x[0]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Y1, HP_y[0]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Z1, HP_z[0]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_X2, HP_x[1]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Y2, HP_y[1]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Z2, HP_z[1]);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_N_TR_SPC, trig_spc);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_ST_HP_NM, HP_name);
	SetCtrlVal (panelHandle_PM, PRM_PANEL_ST_HP_FL, HP_cal_file);
	errChk (DisplayPanel (panelHandle_PM));
	
	// Open log file
	ln = strlen (und_dir);
	ln--;	// last character is EOL - don't copy
	for (i = 0; i < ln; i++)
		log_file[i] = und_dir[i];
	ln = strlen (und_name);
	ln--;	// last character is EOL - don't copy
	for (j = 0; j < ln; j++, i++) 
		log_file[i] = und_name[j];
	log_file[i] = '\0';
	strcat (log_file, ".log");
	fpl = fopen (log_file, "a");
	
	// Initialize HP3458s
	hp3458_init (0, GPIBDVM[0], &hp3458_ID[0]);	//Bx
	hp3458_init (0, GPIBDVM[1], &hp3458_ID[1]);	//By
	hp3458_init (0, GPIBDVM[2], &hp3458_ID[2]);	//By

	errChk (RunUserInterface ());

Error:
	/* clean up */
	if (panelHandle_SC > 0)
		DiscardPanel (panelHandle_SC);
	if (panelHandle_PM > 0)
		DiscardPanel (panelHandle_PM);
	
	fclose (fpl);
	
	// Deallocate vectors
	free (Vx);
	free (Vy);
	free (Bx);
	free (By);
	free (z);
	
	return 0;
}

//==============================================================================
// UI callback function prototypes

/// HIFN Exit when the user dismisses the panel.
//
// Callback functions for main panel
//

int CVICALLBACK panelCB (int panel, int event, void *callbackData,
		int eventData1, int eventData2)
{
	if (event == EVENT_CLOSE)
		QuitUserInterface (0);
	return 0;
}

int CVICALLBACK Rd_Param (int panel, int control, int event,
						  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			// Initializing panel values not necessary - set values are saved 
			DisplayPanel (panelHandle_PM); // display the panel and run the user interface
			
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Log_Entry (int panel, int control, int event,
						   void *callbackData, int eventData1, int eventData2)
{
	char buffer[LINE];
	
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_SC, SCAN_PANEL_STR_LOG, buffer);
			fprintf (fpl, "%s\n", buffer);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Move_probe (int panel, int control, int event,
							void *callbackData, int eventData1, int eventData2)
{
	float x, y, z;
	switch (event)
	{
		case EVENT_COMMIT:
			// Read x, y, z values
			GetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_X, &x);	// Get specified x
			GetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_Y, &y);	// Get specified y
			GetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_Z, &z);	// Get specified z
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_LED_MOVE, 1);	// Turn on Move LED
			// Execute move
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_LED_MOVE, 0);	// Turn off Move LED
			// Set x, y, z values
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_X, x);	// Record x
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_Y, y);	// Record y
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_Z, z);	// Record z
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK TimedFunctions (int panel, int control, int event,
								void *callbackData, int eventData1, int eventData2)
{
	double Vx, Vy, Bx, By;

	switch (event)
	{
		case EVENT_TIMER_TICK:
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_LED_TEMP, 1);	// Turn on Temp. LED
			// Sample temperatures
			// Display temperatures
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_RM_TEMP, RmTemp);
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_U_TEMP1, Temp[0]);
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_U_TEMP2, Temp[1]);
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_U_TEMP3, Temp[2]);
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_U_TEMP4, Temp[3]);
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_U_TEMP5, Temp[4]);
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_U_TEMP6, Temp[5]);
			// Sample Bx and By
			// Measure votages	
			hp3458_get_voltage(hp3458_ID[0], &Vx);
			hp3458_get_voltage(hp3458_ID[1], &Vy);
			// Convert to B
			ProbeInterpolate (Vx, &Bx, HP_cal_Vx, HP_cal_Bx, NCAL);
			ProbeInterpolate (Vy, &By, HP_cal_Vy, HP_cal_By, NCAL);
			// Display Bx and By
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_BX, Bx);
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_NUM_BX, Bx);
			
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_LED_TEMP, 0);	// Turn off Temp. LED
			break;
	}
	return 0;
}

int CVICALLBACK DoScan (int panel, int control, int event,
						void *callbackData, int eventData1, int eventData2)
{
	int	i;
	
	switch (event)
	{
		case EVENT_COMMIT:
			// Allocate voltage vectors
			SuspendTimerCallbacks ();	// Turn off timer
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_LED_SCAN, 1);	// Turn on scan LED
			// Do reference measurement before scan
			// Set triggering
			// Do reference measurement #1
			RefMeas (0);
			// Move to start location
			// Setup triggering
			hp3458_setup_triggered_voltage_samples (hp3458_ID[0], DCV[0], int_tm, num_pnts);	// Bx
			hp3458_setup_triggered_voltage_samples (hp3458_ID[1], DCV[1], int_tm, num_pnts);	// By
			// Start scan triggers
			hp3458_start_triggered_voltage_samples (hp3458_ID[0]); 	// Bx
			hp3458_start_triggered_voltage_samples (hp3458_ID[1]); 	// By
			// Start motion
			// Retrieve data
			hp3458_collect_triggered_voltage_samples (hp3458_ID[0], num_pnts, Vx);	// Bx
			hp3458_collect_triggered_voltage_samples (hp3458_ID[1], num_pnts, Vy);	// By
			// Convert to Bx, By
			for (i = 0; i < num_pnts; i++) {
				ProbeInterpolate (Vx[i], &Bx[i], HP_cal_Vx, HP_cal_Bx, NCAL);
				ProbeInterpolate (Vy[i], &By[i], HP_cal_Vy, HP_cal_By, NCAL);
			}
			// Do reference measurement after scan
			RefMeas (1);
			// Plot data
			PlotXY (panelHandle_SC, SCAN_PANEL_GRAPH_BX, z, Bx, num_pnts, VAL_DOUBLE, VAL_DOUBLE, 
					VAL_THIN_LINE, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
			PlotXY (panelHandle_SC, SCAN_PANEL_GRAPH_BY, z, By, num_pnts, VAL_DOUBLE, VAL_DOUBLE, 
					VAL_THIN_LINE, VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
			// Write to data file
			WriteDataFile (und_file);
			// Write to log
			LogRecord (und_name, fpl);
			
			SetCtrlVal (panelHandle_SC, SCAN_PANEL_LED_SCAN, 0);	// Turn off scan LED
			ResumeTimerCallbacks ();

			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Quit (int panel, int control, int event,
					  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			QuitUserInterface (0);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}
//	*******************************************************************************
//
//	Callback functions for Parameter Panel
//
//	*******************************************************************************

int CVICALLBACK Get_und (int panel, int control, int event,
						 void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_ST_ID, und_name);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Data_dir (int panel, int control, int event,
						  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_ST_DATA_DIR, und_dir);
			break;
		case EVENT_RIGHT_CLICK:
			DirSelectPopup ("w:\\LCLS-II\\data", "Select Directory", 1, 1, und_dir);
			break;
	}
	return 0;
}

int CVICALLBACK Get_GPIB1 (int panel, int control, int event,
						   void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_GPIB_1, &GPIBDVM[0]);
			hp3458_init (0, GPIBDVM[0], &hp3458_ID[0]);	//Bx
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_GPIB2 (int panel, int control, int event,
						   void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_GPIB_2, &GPIBDVM[1]);
			hp3458_init (0, GPIBDVM[1], &hp3458_ID[1]);	//By			 
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_GPIB3 (int panel, int control, int event,
						   void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_GPIB_3, &GPIBDVM[1]);
			hp3458_init (0, GPIBDVM[2], &hp3458_ID[2]);	//Bz			 
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_VScale1 (int panel, int control, int event,
							 void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_VS_DVM1, &DCV[0]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_VScale2 (int panel, int control, int event,
							 void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_VS_DVM2, &DCV[1]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_VScale3 (int panel, int control, int event,
							 void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_VS_DVM3, &DCV[2]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_Int_Tm (int panel, int control, int event,
							void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_INT_TM, &int_tm);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_Vel (int panel, int control, int event,
						 void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_SC_V, &Sc_V);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_Strt (int panel, int control, int event,
						  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_SC_STRT, &Sc_strt);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_Stp (int panel, int control, int event,
						 void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_SC_STP, &Sc_stp);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_Trig (int panel, int control, int event,
						  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_TR_SPC, &trig_spc);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_Trig (int panel, int control, int event,
						  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_TR_SPC, &trig_spc);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}


int CVICALLBACK Get_Trig_axis (int panel, int control, int event,
						  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_TR_AXIS, &trig_axis);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_File (int panel, int control, int event,
						  void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_ST_HP_FL, HP_cal_file);
			break;
		case EVENT_RIGHT_CLICK:
			FileSelectPopup ("w:\\LCLS-II\\data\\HP calibration", "*.*", "", "", 
							 VAL_LOAD_BUTTON, 0, 0, 1, 0, HP_cal_file);
			SetCtrlVal (panelHandle_PM, PRM_PANEL_ST_HP_FL, HP_cal_file);
			break;
	}
	return 0;
}

int CVICALLBACK SaveQuit (int panel, int control, int event,
					  void *callbackData, int eventData1, int eventData2)
{
	double dz1, dt;
	
	switch (event)
	{
		case EVENT_COMMIT:
			// Check compatibility between velocity, sample spacing and integration time
			dt = int_tm/LINECYCLE;
			dz1 = Sc_V*dt;
			// Allow maximum sampling interval = 0.5*(trigger spacing)
			if (dz1 > trig_spc/2.0) // Don't save and quit until it is OK
				MessagePopup ("Parameter Check", 
							  "Incompatibility:scan velocity, integration time, and sample spacing.");
			else {   // Save and quit
				
				num_pnts = (Sc_stp - Sc_strt)/trig_spc + 1;
				HidePanel (panelHandle_PM);
				RdCalFile (HP_cal_file);  // Read HP calibration time
			}
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_x1 (int panel, int control, int event,
						void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_X1, &HP_x[0]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_y1 (int panel, int control, int event,
						void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Y1, &HP_y[0]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_z1 (int panel, int control, int event,
						void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Z1, &HP_z[0]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_x2 (int panel, int control, int event,
						void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_X2, &HP_x[1]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_y2 (int panel, int control, int event,
						void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Y2, &HP_y[1]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK Get_z2 (int panel, int control, int event,
						void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle_PM, PRM_PANEL_N_HP_Z2, &HP_z[1]);
			break;
		case EVENT_RIGHT_CLICK:

			break;
	}
	return 0;
}

int CVICALLBACK ClearGraphs (int panel, int control, int event,
							 void *callbackData, int eventData1, int eventData2)
{
	switch (event)
	{
		case EVENT_COMMIT:

			break;
	}
	return 0;
}