#include <iostream>
#include <fstream>
using namespace std;

// This is an example program that shows how to issue commands to
// a remote computer and receive the results programmatically.
//
// The current reason for this is to help coordinate programs running
// on a Linux desktop and a VxWorks system without having to write
// an entire client server system and have the server always running
// on the VxWorks machine.
//
// The main idea with this method is to create a couple of pipes
// that can be used to redirect the stdin and stdout of the 
// remote shell process (telnet, rsh, ssh, ...whatever) to this
// program so they can be read and written to by read() and write().
//
// This is accomplished by first setting creating the pipe, then
// forking this process into 2 processes, then having the "child"
// fork replace his stdin, stdout pipes with the newly created ones,
// and finally having the child "exec" itself into the remote
// shell program. Since the remote shell will inherit its stdin
// and stdout streams from the fork, it will use the pipes we setup
// for that purpose. Cool huh?

#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <time.h>

#define _DBG_ cout<<__FILE__<<":"<<__LINE__<<" "
#define _DBG__ _DBG_<<endl;

char buffer[8192];

int Read_Response(int pipe_fd[]) {
	bzero(buffer, 8192);
	int rv = read(pipe_fd[0], buffer, 8192);
	if(rv>0){
		cout<<"====================================================="<<endl;
		cout << buffer <<endl;
	}

	return 0;
}

bool Check_Return(char input[]) {
	string feedback = buffer;
	string::size_type loc = feedback.find(input, 0);
	if (loc !=string::npos) {
		cout <<  "Found <" << input << "> in return. Move compelete." << endl;
		return true;
	}
	else return false;
}

int main(int narg, char *argv[])
{
	//char *const args[]={"ls",NULL};
	//execv("/bin/sh", args);
	//return 0;
	// Create 2 pipes
	int fdA[2];
	int fdB[2];
	pipe(fdA);
	pipe(fdB);
	
	// The following splits us into 2 identical processes except there
	// is a parent child relationship between the two. The "child" will
	// have pid==0 while the parent will not. 
	pid_t pid = fork();
	
	// Make fdB[0] non-blocking so we can read from it without getting stuck
	fcntl(fdB[0], F_SETFL, O_NONBLOCK);
	
	if(pid==0){
		// The child replaces his stdin with fdA and his stdout with fdB
		close(fdA[1]); // This will never be used by this fork
		close(fdB[0]); // This will never be used by this fork

		dup2(fdA[0], STDIN_FILENO);
		dup2(fdB[1], STDOUT_FILENO);
		close(fdA[0]); // close one of the file descriptors (stdin  is still open)
		close(fdB[1]); // close one of the file descriptors (stdout is still open)
		

		// Now, exec this fork into a shell process. The first argument of execl
		// is the actual program to run. The second argument starts the "argv"
		// list passed into the program which usually contains the name of the
		// program as invoked in the shell as the 0-th argument. 

		char *const args[]={NULL};
		execl("/usr/bin/telnet", "telnet", "192.168.1.2", 0);
	}else{
		close(fdA[0]); // This will never be used by this fork
		close(fdB[1]); // This will never be used by this fork

		// Write a command to the remote shell
		sleep(1);

		// determining cathode plane number and orientation
		char plane[128], rotation[128];
		cout << "Please enter the cathode plane number (enter 999 for no cathode, rock scan): " << endl;
		cin >> plane;
		cout << "Please enter the clockwise rotation from vertical (with FDC1 at top) in degrees: " << endl;
		cin >> rotation;

		// Moving laser to home position
		cout << "Moving laser to home position..." << endl;
		const char *cmd = "Laser_Home()\n";
		_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;

		// Determining if home by checking X and Y overtravel flags
		bool overtravelX = false, overtravelY = false;
		char xhome[] = "\"PNLN\"",  yhome[] = "\"PNLN\"";
		for (int i=0; i<450; i++) {  // shouldn't take more than 450 seconds to get home
			if (overtravelX == false) {
				// Sending command to query status of X limit switch
				cmd = "VS4Command(\"AX QA\")\n";
				_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;
				Read_Response(fdB);

				// setting overtravelX boolean according to response of query
				overtravelX = Check_Return(xhome);

			} else if (overtravelY == false) {
				// Sending command to query status of Y limit switch
				cmd = "VS4Command(\"AY QA\")\n";
				_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;
				Read_Response(fdB);

				// setting overtravelY boolean according to response of query
				overtravelY = Check_Return(yhome);
			} else break;

			sleep(1);
		}

		// Warn user if laser doesn't reach home
		if (overtravelX == false || overtravelY == false) {
			cout << "ERROR: Waited at least 450 seconds for laser" << endl;
			cout << "ERROR: to arrive at home and it never did." << endl;
			return -1;
		} else cout << "Now in home position." << endl;

		// Figuring out filename for data file, will be "plane### ###deg.txt year-month-day hour:minute:second"
		char date_s[128], time_s[128], filename[512], filepath[512], filenameroot[512], basename[512];
		const char* path = "/home/laser/FLATNESS/flatness_data/";
		time_t t = time(0);
		tm time = *localtime(&t);
		sprintf(date_s, "%d_%02d_%02d", time.tm_year+1900, time.tm_mon+1, time.tm_mday);
		sprintf(time_s, "%02d_%02d_%02d", time.tm_hour, time.tm_min, time.tm_sec);
		sprintf(basename, "plane%s %sdeg %s %s", &plane, &rotation, &date_s, &time_s);
		sprintf(filename, "%s.txt", basename);
		sprintf(filenameroot, "%s.root", basename);
		sprintf(filepath, "%s%s", path, &filename);
		cout << "Saving data to " << filepath << endl;
cerr<<__FILE__<<":"<<__LINE__<<" If the program hangs here, you must reboot the computer!"<<endl;
		// Declaring some variables
		ifstream ilaser("/dev/ttyS0");
		ofstream olaser("/dev/ttyS0");
		olaser<<"S27."<<endl;  // Set sampling rate of laser
		//olaser<<"H1.S330.V1234."<<endl;
		ilaser.close();
		ofstream data(filepath);
		string line;
		
//		ilaser.open("/dev/ttyUSB0");
//		ilaser<<line;  // first line available from laser is sometimes misread, so we ignore it
//		ilaser.close();
		
		// These 'done' chars are parts of the returned strings from vxworks
		// that are unique enough to determine when a move is complete
//		char xdone[] = "Now at position";
		char xdone[] = "NLN\"";
		char xhome2[] = "Writing command to VS4 : \"AX RA\" (5 bytes)\nreturn message: \"MNLN\"";
		char yhome2[] = "Writing command to VS4 : \"AY RA\" (5 bytes)\nreturn message: \"MNLN\"";
		char ytop[] = "Writing command to VS4 : \"AY RA\" (5 bytes)\nreturn message: \"PNLN\"";
		//char ydone[] = "NLN\"";
		char ydone[] = "Now at position";
		bool x_move_done = false;
		bool y_move_done = false;
		overtravelX = false;
		overtravelY = false;

		// Move laser 3 inches up to be close to active area
		cout<<"Moving laser up to active area ..."<<endl;
		cmd = "Laser_MoveRelative(\"0\", \"-2\");\n";
		_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;
//18 13/16
		// Wait for move to finish
		for (int j=0; j<20; j++) {
			// Sending command to query status of Y limit switch
			cmd = "VS4Command(\"AY RA\")\n";
			_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;
			Read_Response(fdB);

			y_move_done = Check_Return(ydone);
			cout << "move_y = " << y_move_done << endl;
			if (y_move_done) break;

			sleep(1);
		}
		y_move_done= false;
		sleep(3);

		// performing snake scan, -1 inch vertical moves between long horizontal passes
		for (int i=0; i<42; i++) {
			x_move_done = false;
			overtravelX = false;
			
			//Move one inch in negative Y direction
			cmd = "Laser_MoveRelative(\"0\", \"-1\");\n";
			_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;

			// Get status of switch, should take less than 20 seconds
			for (int j=0; j<20; j++) {
				// Sending command to query status of Y limit switch
				cmd = "VS4Command(\"AY RA\")\n";
				_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;
				Read_Response(fdB);

				// break away if vertical limit is hit
				overtravelY = Check_Return(ytop);
				cout << "overtravelY = " << overtravelY << endl;
				if (overtravelY && (i!=0)) break;

				// break away because move has completed
				y_move_done = Check_Return(ydone);
				cout << "move_y = " << y_move_done << endl;
				if (y_move_done) break;

				sleep(1);
			}

			sleep(1);

			// break away if vertical limit is hit
			if (overtravelY) break;

			// Warn user if move doesn't complete
			if (!y_move_done) {
				cout << "ERROR: Waited twenty seconds for one inch horizontal move to complete and it never did." << endl;
				return -1;
			}

			// Send command to begin horizontal motion
			cmd = "Laser_MoveHorizontal();\n";
			_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;

			ilaser.open("/dev/ttyS0");
			getline(ilaser, line);  //first line available from laser is sometimes misread, so we ignore it
			while (overtravelX == false) {
				// send data from laser to command line and save in file
				if (i!=0){
					getline(ilaser, line);
					cout << line << endl;
					data << line << endl;
				}

				// Sending command to query status of Y limit switch
				cmd = "VS4Command(\"AX RA\")\n";
				_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;
				Read_Response(fdB);

				overtravelX = Check_Return(xdone);
				//cout << "overtravelX = " << overtravelX << endl;
			}
			ilaser.close();
			olaser.close();
			// inform that horizontal pass is complete
			if (i!=0){
				cout << "horizontal pass " << i << " complete" << endl;
				data << "horizontal pass " << i << " complete" << endl;
			}
			sleep(2);
		}

		// Warn user if vertical limit is never hit
		if (!overtravelY) {
			cout << "ERROR: Did 43 1 inch horizontal moves without hitting limit." << endl;
//			return -1;
		}

		// End telnet session
		execl("exit", 0);

//		cmd = "exit\n";
//		_DBG_<<"write():"<<write(fdA[1], cmd, strlen(cmd))<<endl;

		char sys_command[512];
		sprintf(sys_command, "cd /home/laser/FLATNESS/flatness_data ; /home/laser/bin/snake_mktree \"%s\"", &filename);
		system(sys_command);
		sprintf(sys_command, "cd /home/laser/FLATNESS/flatness_data ; /usr/local/root/PRO/bin/root -q -l '../macros/fdc_3Dplots.C(\"%s\")'",&filenameroot);
		system(sys_command);
		sprintf(sys_command, "cd /home/laser/FLATNESS/flatness_data ; /usr/local/root/PRO/bin/root -q -l '../macros/fdc_mean.C(\"%s\")'", &filenameroot);
		system(sys_command);
		sprintf(sys_command, "cd /home/laser/FLATNESS/flatness_data ; /usr/local/root/PRO/bin/root -q -l '../macros/fdc_rms.C(\"%s\")'", &filenameroot);
		system(sys_command);

		cout<<endl;
		cout<<endl;
		cout<<"Scan complete. Output files can be found in:"<<endl;
		cout<<"    \"/home/laser/FLATNESS/flatness_data/images/"<<basename<<"\""<<endl;
		cout<<endl;
		cout<<"Please refer questions/comments to davidl@jlab.org  x5567"<<endl;
		cout<<endl;
	}

	return 0;
}