#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <cmath>
#include <vector>
#include <map>
using namespace std;

#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <curl/curl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <signal.h>


#include <TTree.h>
#include <TH2.h>
#include <TH1.h>
#include <TCanvas.h>
#include <TFile.h>

string SCOPE_URL = "http://169.254.5.220";
int SOCKET_PORT = 4000;
int NCHANNELS = 1;
int MAX_EVENTS = 10;
int TIMEOUT_SECS = 300;
float TIMING_THRESHOLD_FRAC = 0.10; // time is at bin that is 10% of signal amplitude
int REBIN_FACTOR = 1; // set to 1 for no rebinning
bool SAVE_WAVEFORMS = false;
string ROOT_FNAME = "ScopeDAQ.root";
bool QUIT = false;

int   NR_PT = 0;
float XINCR = 0;
float XZERO = 0;
float YMULT = 0;
float YZERO = 0;


enum SCOPE_MODEL_t{
	UNKNOWN,
	TD3034,
	DPO4034B,
	DPO4104,
	NSCOPE_MODELS
};
SCOPE_MODEL_t SCOPE_MODEL = DPO4034B;
string SCOPE_MODEL_ID = "UNKNOWN";

// Data structure used to accumulate data in single buffer
// while downloading waveform
typedef struct{
	char *buff;
	int buff_size;
	int Nbytes;
}DataBuffer_t;

// Parameters used to convert data to physical units.
// This is parsed from the header info returned from
// the scope (which may differ slightly between models).
class ConversionParms{
public:
	unsigned int NR_PT;
	int BYT_NR;
	double YOFF;
	double YMULT;
	double XINCR;
	double XZERO;
	int Ch;
	double V_per_div;
	double s_per_div;
};


// Function declarations
void GetScopeModel(string scopeURL);
void PrintAcquisitionParameters(void);
void Acquire(string scopeURL, int Nchannels, unsigned int Nevents, unsigned int timeout_secs);
void AcquireStart(string scopeURL);
void AcquireStop(string scopeURL);
bool AcquireGetState(string scopeURL);
string TriggerGetState(string scopeURL);
unsigned int SendCommand(string scopeURL, string command, char *buff=NULL, unsigned int buff_size=0);
TH1F* GetWaveform(string scopeURL, int channel);
size_t ReceiveData( char *ptr, size_t size, size_t nmemb, DataBuffer_t *databuffer);
TH1F* TektronixInternalToRootHist(const char *buff, int buff_size, string hname);
void ParseHeader3034(string header, class ConversionParms &parms);
void ParseHeader4104(string header, class ConversionParms &parms);
void ParseCommandLineArguments(int narg, char *argv[]);
void Usage(void);


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


void QuitEarly(int sig){ QUIT = true; }

//-------------------------
// main
//-------------------------
int main(int narg, char *argv[])
{
	signal(SIGINT, &QuitEarly);

	// Parse any command line arguments
	ParseCommandLineArguments(narg, argv);

	// Open ROOT file for output
	TFile *f = new TFile(ROOT_FNAME.c_str(), "RECREATE");

	// Do global init of CURL system
	curl_global_init(CURL_GLOBAL_ALL);

	// Determine model number of scope
	GetScopeModel(SCOPE_URL);
	
	// Print acquistion parameters
	PrintAcquisitionParameters();
	
	// Acquire data
	Acquire(SCOPE_URL, NCHANNELS, MAX_EVENTS, TIMEOUT_SECS);

	// Flush histos to ROOT file and close it
	f->Write();
	f->Close();
	delete f;

	return 0;
}

//-------------------------
// GetScopeModel
//-------------------------
void GetScopeModel(string scopeURL)
{
	char buff[8192];
	bzero(buff, 8192);

	unsigned int Nbytes = SendCommand(scopeURL, ":ID?", buff, 8192);
	if(Nbytes<=0)return;
	SCOPE_MODEL_ID = string(buff);
	
	cout << "-------------------------------------------------------------------------" << endl;
	if(SCOPE_MODEL_ID.find("TEK/TDS 3034") != string::npos){
		SCOPE_MODEL = TD3034;
	}else if(SCOPE_MODEL_ID.find("DPO4034B") != string::npos){
		SCOPE_MODEL = DPO4034B;
		cout << "Found DPO4034B" << endl;
		cout << "  This will try reading via direct socket connection. Only the last part" << endl;
		cout << "of the URL will be used (i.e. the \"http://\" part will be chopped off)." << endl;
		cout << "Please use the \"Utility\" button at the bottom of the scope to make sure" << endl;
		cout << "the port number for the socet is set to " << SOCKET_PORT << "." << endl;
		cout << "IMPORTANT: Make sure the \"Protocol\" under the Socket Server submenu is" << endl;
		cout << "set to \"Terminal\"." << endl;
	}else{
		cout << "Couldn't find scope model in \"" << buff << "\"" << endl;
	}
	cout << "-------------------------------------------------------------------------" << endl;
}

//-------------------------
// PrintAcquisitionParameters
//-------------------------
void PrintAcquisitionParameters(void)
{
	cout<<endl;
	cout<<"ScopeDAQ  - utility for acquiring waveforms from Tektronix"<<endl;
	cout<<"            oscilloscope and saving them into a ROOT file."<<endl;
	cout<<endl;
	cout<<"by: David Lawrence   -   JLab"<<endl;
	cout<<"(for help, re-run with \"-h\" option)"<<endl;
	cout<<endl;
	cout<<"Parameters:"<<endl;
	cout<<"            SCOPE_URL: "<<SCOPE_URL<<endl;
	cout<<"            NCHANNELS: "<<NCHANNELS<<endl;
	cout<<"           MAX_EVENTS: "<<MAX_EVENTS<<endl;
	cout<<"         TIMEOUT_SECS: "<<TIMEOUT_SECS<<endl;
	cout<<"         REBIN_FACTOR: "<<REBIN_FACTOR<<endl;
	cout<<"TIMING_THRESHOLD_FRAC: "<<TIMING_THRESHOLD_FRAC<<endl;
	cout<<"       SAVE_WAVEFORMS: "<<SAVE_WAVEFORMS<<endl;
	cout<<"           ROOT_FNAME: "<<ROOT_FNAME<<endl;
	cout<<"       SCOPE_MODEL_ID: "<<SCOPE_MODEL_ID<<endl;
	cout<<endl;

}

//-------------------------
// Acquire
//-------------------------
void Acquire(string scopeURL, int Nchannels, unsigned int Nevents, unsigned int timeout_secs)
{
	// Send initial parameters for reading waveform
	int buff_size = 8192;
	char buff[8192];
	SendCommand(scopeURL, "!d", buff, buff_size);
	stringstream cmd;
	cmd << ":ACQUIRE:STATE off";
	cmd << ";:ACQUIRE:STOPAFTER SEQUENCE";
	cmd << ";:DATA:SOURCE CH1";
	cmd << ";:DATA:ENCDG ASCII";
	cmd << ";:WFMOUTPRE:BYT_NR 1";
	cmd << ";:HORizontal:RECOrdlength 10000";
	cmd << ";:DATA:START 4901";
	cmd << ";:DATA:STOP  5100";
	cmd << ";:WFMOUTPRE?";
	SendCommand(scopeURL, cmd.str().c_str(), buff, buff_size);
	cout << buff << endl;

	// Split preamble into pieces
	vector<string> svals;
	string item;
	stringstream ss(buff);
	while(getline(ss, item, ';')) svals.push_back(item);
	if(svals.size() < 16){
		cerr << "ERROR: number of items in waveform pramble <16 (=" << svals.size() << ")" << endl;
		cerr << buff << endl;
		return;
	}
	NR_PT = atoi(svals[6].c_str());
	XINCR = atof(svals[9].c_str());
	XZERO = atof(svals[10].c_str());
	YMULT = atof(svals[13].c_str());
	YZERO = atof(svals[14].c_str());;
	
	if(svals[12] == "\"V\"") YMULT*=1000.0; // make values in mV


	// Create a ROOT tree to hold the integrated, pedestal subtracted values
	int Nvals = 1 + NCHANNELS*3;
	float *vals = new float[Nvals]; // 1=eventno *3=(integral+pedestal+time)
	for(int ii=0; ii<Nvals; ii++)vals[ii] = 0.0;
	stringstream varexp;
	varexp<<"eventno/F";
	for(int i=1; i<=NCHANNELS; i++){
		varexp<<":ch"<<i<<"/F:ped"<<i<<"/F:t"<<i<<"/F";
	}
	TTree *tree = new TTree("event","ScopeToDAQ events");
	tree->Branch("T", vals, varexp.str().c_str());
	
	// Complete waveforms are stored in 2D histos. The dimensions are determined
	// by the data format returned by the scope and so the 2-D histos can't be
	// created until the first waveform is read in. We set the pointers to NULL
	// in order to flag that the histo hasn't been created yet.
	TH2F *h2[10];
	for(int i=1; i<=Nchannels; i++){
		h2[i] = NULL;
	}

	cout<<"=========== Acquisition Starting ============"<<endl;

	// Loop over Nevents
	for(unsigned int i=0; i<Nevents; i++){
	
		if(QUIT) break;

		// Tell scope to start accepting triggers
		SendCommand(scopeURL, ":ACQUIRE:STATE on");

		vals[0] = (float)(i+1);
		
		// Wait until a trigger has occurred
		while(true){
			string state = TriggerGetState(scopeURL);
			if(state.find("SAVE") != string::npos)break;
			usleep(100000); // limits rate we ask for trigger state to 10Hz max
		}
		
//		SendCommand(scopeURL, ":ACQUIRE:STATE off");

		// Loop over all channels we need to acquire in the event
		for(int ichan=1; ichan<=Nchannels; ichan++){
			TH1F *h = GetWaveform(scopeURL, ichan);
			if(h){
				// Copy the 1D histo into a 2D histo. To save space, we rebin the
				// 1D histo first and then scale by the rebin factor so that the
				// values are averaged in order to maintain Volts as the units.
				if(REBIN_FACTOR > 1){
					h->Rebin(REBIN_FACTOR);
					h->Scale(1.0/(float)REBIN_FACTOR);
				}

				// If the 2-D histo has not been created, then create it now
				TH2F *hh = h2[ichan];
				if(hh == NULL && SAVE_WAVEFORMS){
					int Nxbins = h->GetNbinsX();
					float Xlo = h->GetBinLowEdge(1);
					float Xhi = h->GetBinLowEdge(Nxbins+1);
					int Nybins = Nevents;
					float Ylo = 0.5;
					float Yhi = (float)Nevents + 0.5;
					char hname[256];
					sprintf(hname, "ch%d", ichan);
					h2[ichan] = hh = new TH2F(hname, hname, Nxbins, Xlo, Xhi, Nybins, Ylo, Yhi);
					hh->SetXTitle("time(ns)");
					hh->SetYTitle("event number");
					hh->SetZTitle("Amplitude (V)");
					hh->SetStats(0);
				}
				
				// Loop over bins in waveform and copy into 2-D histo
				int idx = 1+((ichan-1)*3);
				for(int ibin = 1; ibin<= h->GetNbinsX(); ibin++){
					// Copy to 2-D histo if specified
					if(hh)hh->SetBinContent(ibin, i+1, h->GetBinContent(ibin));
					
					// Integrate value and gather average for pedestal
					float val = h->GetBinContent(ibin);
					vals[idx+0] += val; // Integral
					if(ibin<=20)vals[idx+1] += h->GetBinContent(ibin); // Pedestal
				}
				
				// Calculate pedestal from average of first 100 samples and
				// subtract from integral
				vals[idx+1] /= (float)100.0; // Pedestal
				vals[idx+0] -= vals[idx+1]*h->GetNbinsX();
				
				// Most pulses are negative. Make the integral
				// and pedestal their opposites to have positive values
				vals[idx+0] *= -1.0;
				vals[idx+1] *= -1.0;
				
				// Find signal time by looking for fraction of signal maximum
				float max_val = 0.0; // used to get time
				for(int ibin = 1; ibin<= h->GetNbinsX(); ibin++){
					
					// Find maximum pedestal subtracted (absolute) value
					float val = h->GetBinContent(ibin) - vals[idx+1];
					if(fabs(val) > fabs(max_val))max_val = val;
				}
				float thresh = fabs(max_val)*TIMING_THRESHOLD_FRAC;
				for(int ibin = 1; ibin<= h->GetNbinsX(); ibin++){
					
					// Find maximum pedestal subtracted (absolute) value
					float val = h->GetBinContent(ibin) - vals[idx+1];
					if(fabs(val) >= thresh){
						vals[idx+2] = h->GetBinCenter(ibin);
						break;
					}
				}
				
				delete h;
			}
		}

		cout<<"retrieved "<<Nchannels<<" x "<<(i+1)<<" waveforms ("<<Nchannels*(i+1)<<" total)"<<endl;

		tree->Fill();
		for(int ii=0; ii<Nvals; ii++)vals[ii] = 0.0;
	}
				 
	// Cleanup
	delete[] vals;
}

//-------------------------
// AcquireGetState
//-------------------------
bool AcquireGetState(string scopeURL)
{
	
	// This will connect to the scope and retrieve whether the trigger
	// is running or stopped. It returns true if the scope is accepting
	// triggers. 
	//
	// NOTE: This does not mean a trigger has actually occurred, just whether
	// it is in the "Run" state or the "Stop" state.
	
	char buff[8192];
	unsigned int Nbytes = SendCommand(scopeURL, ":ACQUIRE:STATE?", buff, 8192);
	
	bool run_state = false;
	if(Nbytes>0){
		if(SCOPE_MODEL==TD3034){
			string ret_str(buff);
			size_t pos = ret_str.find("</TEXTAREA>");
			if(pos!=string::npos){
				if(ret_str[pos-1]=='1')run_state=true;
			}
		}else{
			if(buff[0] == '1') run_state=true;
		}
	}

	return run_state;
}

//-------------------------
// TriggerGetState
//-------------------------
string TriggerGetState(string scopeURL)
{
	
	// This will connect to the scope and retrieve whether the trigger
	// is running or stopped. It returns true if the scope is accepting
	// triggers. 
	//
	// NOTE: This does not mean a trigger has actually occurred, just whether
	// it is in the "Run" state or the "Stop" state.
	
	char buff[8192];
	unsigned int Nbytes = SendCommand(scopeURL, "TRIGGER:STATE?", buff, 8192);
	
	string trig_state = "unknown";
	
	if(Nbytes>0){
		if(SCOPE_MODEL==TD3034){
			string ret_str(buff);
			size_t pos = ret_str.find("</TEXTAREA>");
			if(pos!=string::npos){
				size_t pos_end = pos;
				while(pos>0 && ret_str[pos]!='>')pos--;
				size_t pos_start = pos+1;
				string tmp(&ret_str[pos_start], pos_end - pos_start);
				trig_state = tmp;
			}
		}else{
	
			string sbuff(buff);
			if(sbuff.find("ARMED") != string::npos  ) trig_state = "ARMED";
			if(sbuff.find("AUTO") != string::npos   ) trig_state = "AUTO";
			if(sbuff.find("READY") != string::npos  ) trig_state = "READY";
			if(sbuff.find("SAVE") != string::npos   ) trig_state = "SAVE";
			if(sbuff.find("TRIGGER") != string::npos) trig_state = "TRIGGER";
		}
	}

	return trig_state;
}

//-------------------------
// SendCommand
//-------------------------
unsigned int SendCommand(string scopeURL, string command, char *buff, unsigned int buff_size)
{
	if(buff_size==0){
		buff_size = 8192;
		buff = new char[buff_size];
	}

	static bool connected = false;
	static int sockfd;
	if(!connected){
		int portno;
		struct sockaddr_in serv_addr;
		struct hostent *server;

		portno = SOCKET_PORT;

		/* Create a socket point */
		sockfd = socket(AF_INET, SOCK_STREAM, 0);

		if (sockfd < 0) {
			perror("ERROR opening socket");
			return 0;
		}

		string ip_only = scopeURL.substr(7);
		server = gethostbyname(ip_only.c_str());

		if (server == NULL) {
			fprintf(stderr,"ERROR, no such host\n");
			return 0;
		}

		bzero((char *) &serv_addr, sizeof(serv_addr));
		serv_addr.sin_family = AF_INET;
		bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
		serv_addr.sin_port = htons(portno);

		/* Now connect to the server */
		if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
			perror("ERROR connecting");
			cerr << "    IP: " << ip_only << endl;
			cerr << "  port: " << portno << endl;
			return 0;
		}
		
		cout << " --- Connected to --- " <<endl;
		cout << "    IP: " << ip_only << endl;
		cout << "  port: " << portno << endl;
		connected = true;
		sleep(1);

		// Read message posted at initial connection
		int tmp_size = 8192;
		char tmp[8192];
		bzero(tmp, 8192);
		int n = read(sockfd, tmp, tmp_size);
		if(n>0){
			cout << "(Read " << n << " residual bytes)" << endl;
//			cout << tmp << endl;
		}
		cout << endl;
	}
	
	int bytes_available = 0;
	ioctl(sockfd,FIONREAD,&bytes_available);
	if(bytes_available){
		cout << "Bytes cluttering queue: " << bytes_available << endl;
		read(sockfd, buff, buff_size);
		cout <<" --- \"" << buff << "\"" << endl;
	}
	
	/* Send message to the server */
//_DBG_ << " Sending command: " << command << endl;

	command += "\n";
	int n = write(sockfd, command.c_str(), command.length());
	if (n < 0) {
		perror("ERROR writing to socket");
		return 0;
	}
	
	if(command.find("CURVE?") != string::npos){
		usleep(100000);
//		write(sockfd, "!r\n", 3);
	}
	
	// Wait for server to send us some bytes
	bzero(buff,buff_size);
	for(int i=0; i<1000; i++){
		usleep(10000);
		bytes_available = 0;
		ioctl(sockfd,FIONREAD,&bytes_available);
		if(bytes_available > 0) break;
		if(i==500) write(sockfd, "!r\n", 3);
	}
	if(bytes_available<1){
		_DBG_ << "Timeout waiting for response!" << endl;
		return 0;
	}
	
	/* Now read server response */
	n = read(sockfd, buff, buff_size);
	string sbuff(buff);
//_DBG_<<"bytes_available="<<bytes_available<<endl;
//_DBG_<<" Received " << n << " bytes: ";
//if(n<180) cerr << "\"" << buff << "\""; else cerr << sbuff.substr(0, 20) + " ...";
//cerr << endl;

	if(sbuff.find("Timeout") == 0){
		n = read(sockfd, buff, buff_size);
		cout << "Detected timeout and re-read socket to get " << n << " new bytes" << endl;
	}

	if (n < 0) {
		perror("ERROR reading from socket");
		return 0;
	}

	return n;
}

//-------------------------
// GetWaveform
//-------------------------
TH1F* GetWaveform(string scopeURL, int channel)
{
	int buff_size = 10000*7+256;
	char *buff = new char[buff_size+1];
	
	// make up to 5 attempts to read the waveform
	TH1F *h = NULL;
	for(int i=0; i<5 ; i++){
		SendCommand(scopeURL,"CURVE?", buff, buff_size);
		
		// Sometimes it reads back all -128 values (?...)
		if(strncmp(buff, "-128,-128", 9)==0){
			
			cout << "Bad return values. Resetting and trying for another trigger ..." << endl;

			// Tell scope to start accepting triggers
			SendCommand(scopeURL, ":ACQUIRE:STATE on");

			// Wait until a trigger has occurred
			while(true){
				string state = TriggerGetState(scopeURL);
				if(state.find("SAVE") != string::npos)break;
				usleep(100000); // limits rate we ask for trigger state to 10Hz max
			}
//			SendCommand(scopeURL, ":ACQUIRE:STATE off");
			continue;
		}
	
		stringstream hname;
		hname << "wfm"<<channel;
		double xmin = (XZERO + 4901.0*XINCR)/1.0E-9;
		double xmax = (XZERO + 5100.0*XINCR)/1.0E-9;
		h = new TH1F(hname.str().c_str(),"", NR_PT, xmin, xmax);

		stringstream ss2(buff);
		int ibin=0;
		string item;
		while(getline(ss2, item, ',')) h->SetBinContent(++ibin, YMULT*(atof(item.c_str()) - YZERO));

		break;
	}

	delete[] buff;

	return h;
}

//-------------------------
// ReceiveData
//-------------------------
size_t ReceiveData( char *ptr, size_t size, size_t nmemb, DataBuffer_t *databuffer)
{
	int Nbytes = size*nmemb;
	if(databuffer == NULL)return Nbytes;
	if(databuffer->buff == NULL)return Nbytes;
	if(databuffer->Nbytes+Nbytes > databuffer->buff_size){
		cerr<<"Buffer not big enough to hold return data!!"<<endl;
		return 0;
	}

	memcpy(&databuffer->buff[databuffer->Nbytes], ptr, Nbytes);
	databuffer->Nbytes += Nbytes;
	
	//cout<<"received "<<Nbytes<<" bytes ("<<databuffer->Nbytes<<" bytes total)"<<endl;
	
	return Nbytes;
}

//-------------------------
// TektronixInternalToRootHist
//-------------------------
TH1F* TektronixInternalToRootHist(const char *buff, int buff_size, string hname)
{	
	// Copy file contents to string object for easier searching
	// First, find the header length. It's unclear the best way to do this.
	// What is done here is that we look for the string ":CURV", then look
	// for a "#" character after that and then the first non-digit character
	// after that.
	size_t pos = 0;
	bool done = false;
	for(; pos<buff_size; pos++){
		if(!strncmp(&buff[pos], ":CURV", 5)){
			pos += 6;
			for(; pos<buff_size; pos++){
				if(buff[pos]=='#'){
					pos++;
					for(; pos<buff_size; pos++)if(!isdigit(buff[pos])){done=true;break;}
				}
				if(done)break;
			}
		}
		if(done)break;
	}
	string header(buff, pos);
	
	// Parse Header
	ConversionParms parms;
	switch(SCOPE_MODEL){
		case TD3034:   ParseHeader3034(header, parms); break;
		case DPO4034B: ParseHeader4104(header, parms); break;
		case DPO4104:  ParseHeader4104(header, parms); break;
		case UNKNOWN:
		case NSCOPE_MODELS:
			return NULL;
	}
	unsigned int &NR_PT = parms.NR_PT;
	int &BYT_NR = parms.BYT_NR;
	double &YOFF = parms.YOFF;
	double &YMULT = parms.YMULT;
	double &XINCR = parms.XINCR;
	double &XZERO = parms.XZERO;
	int &Ch = parms.Ch;
	double &V_per_div = parms.V_per_div;
	double &s_per_div = parms.s_per_div;
	
#if 0
	cout<<"NR_PT: "<<NR_PT<<endl;
	cout<<"BYT_NR: "<<BYT_NR<<endl;
	cout<<"YOFF: "<<YOFF<<endl;
	cout<<"YMULT: "<<YMULT<<endl;
	cout<<"XINCR: "<<XINCR<<endl;
	cout<<"XZERO: "<<XZERO<<endl;
	cout<<"Ch: "<<Ch<<endl;
	cout<<"V_per_div: "<<V_per_div<<endl;
	cout<<"s_per_div: "<<s_per_div<<endl;
#endif
	
	
	// Parse data
	unsigned long residual_bytes = buff_size - header.length(); // bytes in file after header
	unsigned long data_bytes = NR_PT*BYT_NR;
	if(buff_size < (data_bytes+3)){
		cerr<<"File seems too short! residual_bytes="<<residual_bytes<<" data_bytes="<<data_bytes<<endl;
		cerr<<"Header: \""<<header<<"\""<<endl;
		return NULL;
	}
	//const char *ptr = &buff[buff_size-data_bytes-3];
	const char *ptr = &buff[header.length()];

	// Create ROOT hsitogram to hold output
	TH1F *h = new TH1F(hname.c_str(),"", NR_PT, XZERO/1.0E-9, (XZERO+XINCR*(double)NR_PT)/1.0E-9);
	
	// Loop over samples
	uint16_t *sptr = (uint16_t*)ptr;
	for(int i=0; i<NR_PT; i++){
		

#if 1
		uint32_t val = 0;
		unsigned char *cval = (unsigned char*)&val;
		for(int j=0; j<BYT_NR; j++, ptr++){
			cval[sizeof(uint32_t)-1 - j] = *ptr;
		}
		
		val = val>>16; // shift bytes down to LSB
#else
		unsigned char *cptr = (unsigned char *)sptr;
		unsigned char tmp = cptr[0];
		cptr[0]=cptr[1];
		cptr[1]=tmp;
		uint32_t val = *sptr++;
#endif
		// Empirically, it was noticed that a pulse rose above 2^16, but was
		// of course truncated due to the 16bit words the data is stored in.
		// Adding a value to the 17th bit when a very low value was found seems
		// to restore the correct pulse shape.
		if(val<6000)val += (1<<16);
		
//		double dval = YMULT*(double)val - 7.76; // 7.76 is empirical
		double dval = YMULT*(double)val;
		h->SetBinContent(i+1, dval);
		//cout<<"val["<<h->GetBinLowEdge(i+1)*1.0E-9<<"] = "<<dval<<" (val="<<val<<")"<<endl;
	}

	return h;
}

//-------------------------
// ParseHeader3034
//-------------------------
void ParseHeader3034(string header, class ConversionParms &parms)
{
	size_t pos = 0;
	const char *buff = header.c_str();
	
	parms.NR_PT=0;
	pos = header.find("NR_PT");
	if(pos!=string::npos)parms.NR_PT = atoi(&buff[pos+6]); // 6 = length of "NR_PT "
	
	parms.BYT_NR = 0;
	pos = header.find("BYT_NR");
	if(pos!=string::npos)parms.BYT_NR = atoi(&buff[pos+7]); // 7 = length of "BYT_NR "
	
	parms.YOFF = 0.0;  // this is just the offset on the scope display and should not be used!
	pos = header.find("YOFF ");
	if(pos!=string::npos)parms.YOFF = atof(&buff[pos+5]); // 5 = length of "YOFF "
	
	parms.YMULT = 0.0;
	pos = header.find("YMULT ");
	if(pos!=string::npos)parms.YMULT = atof(&buff[pos+6]); // 6 = length of "YMULT "
	
	parms.XINCR = 0.0;
	pos = header.find("XINCR ");
	if(pos!=string::npos)parms.XINCR = atof(&buff[pos+6]); // 6 = length of "XINCR "
	
	parms.XZERO = 0.0;
	pos = header.find("XZERO ");
	if(pos!=string::npos)parms.XZERO = atof(&buff[pos+6]); // 6 = length of "XZERO "
	
	parms.Ch = 0;
	pos = header.find("Ch");
	if(pos!=string::npos)parms.Ch = atoi(&buff[pos+2]); // 2 = length of "Ch"
	
	parms.V_per_div = 0.0;
	pos = header.find("coupling, ", pos);
	if(pos!=string::npos)parms.V_per_div = atof(&buff[pos+10]);
	
	parms.s_per_div = 0.0;
	pos = header.find("V/div, ", pos);
	if(pos!=string::npos)parms.s_per_div = atof(&buff[pos+7]);

}

//-------------------------
// ParseHeader4104
//-------------------------
void ParseHeader4104(string header, class ConversionParms &parms)
{
	size_t pos = 0;
	const char *buff = header.c_str();
	
	parms.NR_PT=0;
	pos = header.find("NR_P");
	if(pos!=string::npos)parms.NR_PT = atoi(&buff[pos+5]); // 5 = length of "NR_P "
	
	parms.BYT_NR = 0;
	pos = header.find("BYT_N");
	if(pos!=string::npos)parms.BYT_NR = atoi(&buff[pos+6]); // 7 = length of "BYT_N "
	
	parms.YOFF = 0.0;  // this is just the offset on the scope display and should not be used!
	pos = header.find("VOFFSET ");
	if(pos!=string::npos)parms.YOFF = atof(&buff[pos+8]); // 8 = length of "VOFFSET "
	
	parms.YMULT = 0.0;
	pos = header.find("YMU ");
	if(pos!=string::npos)parms.YMULT = atof(&buff[pos+4]); // 4 = length of "YMU "
	
	parms.XINCR = 0.0;
	pos = header.find("XIN ");
	if(pos!=string::npos)parms.XINCR = atof(&buff[pos+4]); // 4 = length of "XIN "
	
	parms.XZERO = 0.0;
	pos = header.find("XZE ");
	if(pos!=string::npos)parms.XZERO = atof(&buff[pos+6]); // 4 = length of "XZE "
	
	parms.Ch = 0;
	pos = header.find("Ch");
	if(pos!=string::npos)parms.Ch = atoi(&buff[pos+2]); // 2 = length of "Ch"
	
	parms.V_per_div = 0.0;
	pos = header.find("coupling, ", pos);
	if(pos!=string::npos){
		parms.V_per_div = atof(&buff[pos+10]);
		if(header.find("mV/div")!=string::npos)parms.V_per_div/=1000.0;
	}
	
	parms.s_per_div = 0.0;
	pos = header.find("V/div, ", pos);
	if(pos!=string::npos){
		parms.s_per_div = atof(&buff[pos+7]);
		if(header.find("us/div")!=string::npos)parms.V_per_div/=1.0E6;
		if(header.find("ns/div")!=string::npos)parms.V_per_div/=1.0E9;
	}
}

//-------------------------
// ParseCommandLineArguments
//-------------------------
void ParseCommandLineArguments(int narg, char *argv[])
{
	for(int iarg=1; iarg<narg; iarg++)
	{
		string arg(argv[iarg]);
		string next;
		if(iarg<(narg-1))next = argv[++iarg];

		if(arg == "-h") {Usage(); exit(0);}
		if(arg == "-u") SCOPE_URL = next;
		if(arg == "-N") MAX_EVENTS = atoi(next.c_str());
		if(arg == "-T") TIMEOUT_SECS = atoi(next.c_str());
		if(arg == "-R") REBIN_FACTOR = atoi(next.c_str());
		if(arg == "-t") TIMING_THRESHOLD_FRAC = atof(next.c_str());
		if(arg == "-W") SAVE_WAVEFORMS = true;
		if(arg == "-o") ROOT_FNAME = next;
		if(arg == "-c") NCHANNELS = atoi(next.c_str());
	}

}

//-------------------------
// Usage
//-------------------------
void Usage(void)
{
	stringstream ss;
	
	ss<<endl;
	ss<<"   Usage:"<<endl;
	ss<<"       ScopeDAQ [-u URL] [other options]"<<endl;
	ss<<endl;
	ss<<"  This program uses the web interface of a Tektronix scope to"<<endl;
	ss<<"download waveforms and store them in a ROOT file for later"<<endl;
	ss<<"analysis. This was developed using a TDC 3034 scope which"<<endl;
	ss<<"is pretty slow transferring the data over the network. The"<<endl;
	ss<<"limit seems to be about 1/2 second per waveform. So, if you"<<endl;
	ss<<"want to download both channel 1 and channel 2 for an event,"<<endl;
	ss<<"it will take 1 second per event. The method may not work for"<<endl;
	ss<<"newer scopes, but the network may be much faster too so YMMV."<<endl;
	ss<<endl;
	ss<<"  If no options are given, the program will try and grab waveforms"<<endl;
	ss<<"1-"<<NCHANNELS<<" from "<<SCOPE_URL<<". You will probably want"<<endl;
	ss<<"to at least give the \"-u URL\" option to point to your scope."<<endl;
	ss<<endl;
	ss<<"     options:"<<endl;
	ss<<endl;
	ss<<"  -u URL            Set the scope URL (def: "<<SCOPE_URL<<")"<<endl;
	ss<<"  -N Nevents        Number of events to record (def: "<<MAX_EVENTS<<")"<<endl;
	ss<<"  -T timeout        Unused at the moment (def: "<<TIMEOUT_SECS<<")"<<endl;
	ss<<"  -R rebin          Rebin factor for waveform histo (def: "<<REBIN_FACTOR<<")"<<endl;
	ss<<"  -t threshold_frac Signal fraction for timing (def: "<<TIMING_THRESHOLD_FRAC<<")"<<endl;
	ss<<"  -W                Save waveforms in 2D histos (def: don't save)"<<endl;
	ss<<"  -c Nchannels      Set number of channels to acquire (def. 2)" << endl;
	ss<<"  -o filename.root  Output ROOT filename (def: \""<<ROOT_FNAME<<"\")"<<endl;
	ss<<endl;
	
	cout<<ss.str();
}

//---------- DPO 4104 ----------
// :WFMP:NR_P 10000;:WFMP:BYT_N 2;BIT_N 16;ENC BIN;BN_F RI;
// BYT_O MSB;
// WFI "Ch1, DC coupling, 100.0mV/div, 4.000us/div, 10000 points, Sample mode";
// NR_P 10000;PT_F Y;XUN "s";XIN 4.0000E-9;XZE -20.0000E-6;
// PT_O 0;YUN "V";YMU 15.6250E-6;YOF 0.0E+0;YZE 0.0E+0;VSCALE 100.0000E-3;
// HSCALE 4.0000E-6;VPOS 0.0E+0;VOFFSET 0.0E+0;HDELAY 0.0E+0;:CURV #520000


//------- Older 3034 --------
// :WFMPRE:BYT_NR 2;BIT_NR 16;ENCDG BIN;BN_FMT RI;
// BYT_OR MSB;NR_PT 10000;
// WFID "Ch1, DC coupling, 1.0E0 V/div, 2.0E-7 s/div, 10000 points, Sample mode";
// PT_FMT Y;XINCR 2.0E-10;PT_OFF 0;XZERO -4.08E-7;XUNIT "s";
// YMULT 1.5625E-4;YZERO 0.0E0;YOFF -1.5872E4;YUNIT "V";:CURVE #520000

// :WFMPRE:BYT_NR 2;BIT_NR 16;ENCDG BIN;BN_FMT RI;
// BYT_OR MSB;NR_PT 10000;
// WFID "Ch1, DC coupling, 2.0E-2 V/div, 2.0E-7 s/div, 10000 points, Sample mode";
// PT_FMT Y;XINCR 2.0E-10;PT_OFF 0;XZERO -9.6E-7;XUNIT "s";
// YMULT 3.125E-6;YZERO 0.0E0;YOFF -1.28E2;YUNIT "V";:CURVE #520000

// :WFMPRE:BYT_NR 2;BIT_NR 16;ENCDG BIN;BN_FMT RI;
// BYT_OR MSB;NR_PT 10000;
// WFID "Ch1, DC coupling, 1.0E0 V/div, 2.0E-7 s/div, 10000 points, Sample mode";
// PT_FMT Y;XINCR 2.0E-10;PT_OFF 0;XZERO -4.08E-7;XUNIT "s";
// YMULT 1.5625E-4;YZERO 0.0E0;YOFF -1.5872E4;YUNIT "V";:CURVE #520000