#include "/stok6/claudia/obs_dist/new_dist/sla02_structure.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>


void read_tp(sla02 *s, FILE *fp) {
	double mes;
	double lastime;
	double shut_diff;
	double mes_corr;


	fread(&mes,sizeof(mes),1,fp);
	fread(&lastime,sizeof(lastime),1,fp);
	fread(&shut_diff,sizeof(shut_diff),1,fp);
	fread(&mes_corr,sizeof(mes_corr),1,fp);
	
	s->tp.mes=mes;
	s->tp.lastime=lastime;
	s->tp.shut_diff=shut_diff;
	s->tp.mes_corr=mes_corr;
	

}

void read_rp(sla02 *s, FILE *fp) {
	double range_corr;
	fread(&range_corr,sizeof(range_corr),1,fp);
	s->rp.range_corr=range_corr;
	
}


void read_bp(sla02 *s, FILE *fp) {
	double lat;
	double lon;
	double ellip_ht;
	double surface_1;
	double surface_2;
	double surface_3;
	double geoid;
	double ortho_ht;

	fread(&lat,sizeof(lat),1,fp);
	fread(&lon,sizeof(lon),1,fp);
	fread(&ellip_ht,sizeof(ellip_ht),1,fp);
	fread(&surface_1,sizeof(surface_1),1,fp);
	fread(&surface_2,sizeof(surface_2),1,fp);
	fread(&surface_3,sizeof(surface_3),1,fp);
	fread(&geoid,sizeof(geoid),1,fp);
	fread(&ortho_ht,sizeof(ortho_ht),1,fp);


	s->bp.lat=lat;
	s->bp.lon=lon;
	s->bp.ellip_ht=ellip_ht;
	s->bp.surface_1=surface_1;
	s->bp.surface_2=surface_2;
	s->bp.surface_3=surface_3;
	s->bp.geoid=geoid;
	s->bp.ortho_ht=ortho_ht;
	
}

void read_pap(sla02 *s, FILE *fp){
	double satht;
	double ecfx_shot;
	double ecfy_shot;
	double ecfz_shot;
	double azimuth;
	double aoffnadir;


	fread(&satht,sizeof(double),1,fp);
	fread(&ecfx_shot,sizeof(double),1,fp);
	fread(&ecfy_shot,sizeof(double),1,fp);
	fread(&ecfz_shot,sizeof(double),1,fp);
	fread(&azimuth,sizeof(double),1,fp);
	fread(&aoffnadir,sizeof(double),1,fp);

	s->pap.satht=satht;
	s->pap.ecfx_shot=ecfx_shot;
	s->pap.ecfy_shot=ecfy_shot;
	s->pap.ecfz_shot=ecfz_shot;
	s->pap.azimuth=azimuth;
	s->pap.aoffnadir=aoffnadir;

}

void read_ep(sla02 *s, FILE *fp){
	byte xmit_en[1];
	byte receive_en[3];
	byte thresh[3];
	byte channel[1];
	byte wave_offset[1];
	byte vga[1];
	double digi_atten;
	double scale_factor;
	byte pwidth[1];
	byte average[1];
	double bin_size;
	byte waveform[150];
	
	int i;
	


	for (i=0; i<1; i++) 
		fread(&xmit_en[i],sizeof(xmit_en[i]),1,fp);
	for (i=0; i<3; i++) 
		fread(&receive_en[i],sizeof(receive_en[i]),1,fp);
	for (i=0; i<3; i++) 
		fread(&thresh[i],sizeof(thresh[i]),1,fp);
	for (i=0; i<1; i++) 
		fread(&channel[i],sizeof(channel[i]),1,fp);
	for (i=0; i<1; i++) 
		fread(&wave_offset[i],sizeof(wave_offset[i]),1,fp);
	for (i=0; i<1; i++) 
		fread(&vga[i],sizeof(vga[i]),1,fp);
	fread(&digi_atten, sizeof(digi_atten), 1,fp);
	fread(&scale_factor, sizeof(scale_factor), 1,fp);
	for (i=0; i<1; i++) 
		fread(&pwidth[i],sizeof(pwidth[i]),1,fp);
	for (i=0; i<1; i++) 
		fread(&average[i],sizeof(average[i]),1,fp);
	fread(&bin_size, sizeof(bin_size), 1,fp);
	for (i=0; i<150; i++) 
		fread(&waveform[i],sizeof(waveform[i]),1,fp);



	for (i=0; i<1; i++) 
		s->ep.xmit_en[i]=xmit_en[i];
	for (i=0; i<3; i++) 
		s->ep.receive_en[i]=receive_en[i];
	for (i=0; i<3; i++) 
		s->ep.thresh[i]=thresh[i];
	for (i=0; i<1; i++) 
		s->ep.channel[i]=channel[i];
	for (i=0; i<1; i++) 
		s->ep.wave_offset[i]=wave_offset[i];
	for (i=0; i<1; i++) 
		s->ep.vga[i]=vga[i];
	s->ep.digi_atten=digi_atten;
	s->ep.scale_factor=scale_factor;
	for (i=0; i<1; i++) 
		s->ep.pwidth[i]=pwidth[i];
	for (i=0; i<1; i++) 
		s->ep.average[i]=average[i];
	s->ep.bin_size=bin_size;
	for (i=0; i<150; i++) 
		s->ep.waveform[i]=waveform[i];
	


	
}	
	
void read_wavgrp_bl(sla02 *s, FILE *fp) {
	unsigned short int npoints;
	float mean;
	float sig;

	fread(&npoints,sizeof(npoints),1,fp);
	fread(&mean,sizeof(mean),1,fp);
	fread(&sig,sizeof(sig),1,fp);

	s->wavgrp.bl.npoints=npoints;
	s->wavgrp.bl.mean=mean;
	s->wavgrp.bl.sig=sig;
} 


void read_wavgrp_wf_mmnt(sla02 *s, FILE *fp) {
	float mean;
	float sig;
	float skew;
	float kurt;

	fread(&mean,sizeof(mean),1,fp);
	fread(&sig,sizeof(sig),1,fp);
	fread(&skew,sizeof(skew),1,fp);
	fread(&kurt,sizeof(kurt),1,fp);

	s->wavgrp.wf.mmnt.mean=mean;
	s->wavgrp.wf.mmnt.sig=sig;
	s->wavgrp.wf.mmnt.skew=skew;
	s->wavgrp.wf.mmnt.kurt=kurt;

}

void read_wavgrp_wf(sla02 *s, FILE *fp) {
	unsigned short int start;
	unsigned short int npoints;
	float max;
	float width;
	float amplitude;
	float area;
	float nmax;

	fread(&start,sizeof(start),1,fp);
	fread(&npoints,sizeof(npoints),1,fp);
	fread(&max,sizeof(max),1,fp);
	fread(&width,sizeof(width),1,fp);
	fread(&amplitude,sizeof(amplitude),1,fp);
	fread(&area,sizeof(area),1,fp);
	read_wavgrp_wf_mmnt(s,fp);
	fread(&nmax,sizeof(nmax),1,fp);

	s->wavgrp.wf.start=start;
	s->wavgrp.wf.npoints=npoints;
	s->wavgrp.wf.max=max;
	s->wavgrp.wf.width=width;
	s->wavgrp.wf.amplitude=amplitude;
	s->wavgrp.wf.area=area;
	s->wavgrp.wf.nmax=nmax;

}



void read_wavgrp_en(sla02 *s, FILE *fp) {
	float dem;
	float ndvi1;
	float ndvi2;
	unsigned short int landcover;
	float slope;
	float roughness;

	fread(&dem,sizeof(dem),1,fp);
	fread(&ndvi1,sizeof(ndvi1),1,fp);
	fread(&ndvi2,sizeof(ndvi2),1,fp);
	fread(&landcover,sizeof(landcover),1,fp);
	fread(&slope,sizeof(slope),1,fp);
	fread(&roughness,sizeof(roughness),1,fp);

	s->wavgrp.en.dem=dem;
	s->wavgrp.en.ndvi1=ndvi1;
	s->wavgrp.en.ndvi2=ndvi2;
	s->wavgrp.en.landcover=landcover;
	s->wavgrp.en.slope=slope;
	s->wavgrp.en.roughness=roughness;

}

void read_wavgrp_cl(sla02 *s, FILE *fp) {
	unsigned short int rtyp;
	unsigned short int styp;
	unsigned short int dtyp;
	float rms;
	float aspect;
	float lp_centroid;
	float wv_centroid;

	fread(&rtyp,sizeof(rtyp),1,fp);
	fread(&styp,sizeof(styp),1,fp);
	fread(&dtyp,sizeof(dtyp),1,fp);
	fread(&rms,sizeof(rms),1,fp);
	fread(&aspect,sizeof(aspect),1,fp);
	fread(&lp_centroid,sizeof(lp_centroid),1,fp);
	fread(&wv_centroid,sizeof(wv_centroid),1,fp);

	s->wavgrp.cl.rtyp=rtyp;
	s->wavgrp.cl.styp=styp;
	s->wavgrp.cl.dtyp=dtyp;
	s->wavgrp.cl.rms=rms;
	s->wavgrp.cl.aspect=aspect;
	s->wavgrp.cl.lp_centroid=lp_centroid;
	s->wavgrp.cl.wv_centroid=wv_centroid;
}

void read_wavgrp_gm(sla02 *s, FILE *fp) {
	unsigned short int cfflag;
	float g0;
	float g1;
	float g2;
	double chisq;
	unsigned short int nitr;

	fread(&cfflag,sizeof(cfflag),1,fp);
	fread(&g0,sizeof(g0),1,fp);
	fread(&g1,sizeof(g1),1,fp);
	fread(&g2,sizeof(g2),1,fp);
	fread(&chisq,sizeof(chisq),1,fp);
	fread(&nitr,sizeof(nitr),1,fp);


	s->wavgrp.gm.cfflag=cfflag;
	s->wavgrp.gm.g0=g0;
	s->wavgrp.gm.g1=g1;
	s->wavgrp.gm.g2=g2;
	s->wavgrp.gm.chisq=chisq;
	s->wavgrp.gm.nitr=nitr;
}


void read_wavgrp(sla02 *s, FILE *fp) {
	read_wavgrp_bl(s,fp);
	read_wavgrp_wf(s,fp);
	read_wavgrp_en(s,fp);
	read_wavgrp_cl(s,fp);
	read_wavgrp_gm(s,fp);
}




void read_one_shot(sla02 *s, FILE *fp){
	read_tp(s,fp);
	read_rp(s,fp);
	read_bp(s,fp);
	read_pap(s,fp);
	read_ep(s,fp);
	read_wavgrp(s,fp);


}


void print_tp(sla02 s) {
	printf("sla02.tp.mes       	%f\n",s.tp.mes);
	printf("sla02.tp.lastime   	%f\n",s.tp.lastime);
	printf("sla02.tp.shut_diff 	%f\n",s.tp.shut_diff);
	printf("sla02.tp.mes_corr  	%f\n",s.tp.mes_corr);


}


void print_rp(sla02 s) {
	printf("sla02.rp.range_corr     %f\n",s.rp.range_corr);
}

void print_bp(sla02 s) {
	printf("sla02.bp.lat      	%f\n",s.bp.lat);
	printf("sla02.bp.lon      	%f\n",s.bp.lon);
	printf("sla02.bp.ellip_ht      	%f\n",s.bp.ellip_ht);
	printf("sla02.bp.surface_1      %f\n",s.bp.surface_1);
	printf("sla02.bp.surface_2      %f\n",s.bp.surface_2);
	printf("sla02.bp.surface_3      %f\n",s.bp.surface_3);
	printf("sla02.bp.geoid      	%f\n",s.bp.geoid);
	printf("sla02.bp.ortho_ht      	%f\n",s.bp.ortho_ht);

}

void print_pap(sla02 s) {	
	printf("sla02.pap.satht         %f\n",s.pap.satht);
	printf("sla02.pap.ecfx_shot    	%f\n",s.pap.ecfx_shot);
	printf("sla02.pap.ecfy_shot     %f\n",s.pap.ecfy_shot);
	printf("sla02.pap.ecfz_shot     %f\n",s.pap.ecfz_shot);
	printf("sla02.pap.azimuth       %f\n",s.pap.azimuth);
	printf("sla02.pap.aoffnadir     %f\n",s.pap.aoffnadir);

}
void print_ep(sla02 s) {
	int i;
	for (i=0; i<1; i++) 
		printf("sla02.ep.xmit_en[%d] 	%d\n",i,s.ep.xmit_en[i]);
	for (i=0; i<3; i++) 
		printf("sla02.ep.receive_en[%d] 	%d\n",i,s.ep.receive_en[i]);
	for (i=0; i<3; i++) 
		printf("sla02.ep.thresh[%d]    	%d\n",i,s.ep.thresh[i]);
	for (i=0; i<1; i++) 
		printf("sla02.ep.channel[%d]    	%d\n",i,s.ep.channel[i]);
	for (i=0; i<1; i++) 
		printf("sla02.ep.wave_offset[%d]    %d\n",i,s.ep.wave_offset[i]);
	for (i=0; i<1; i++) 
		printf("sla02.ep.vga[%d]    	%d\n",i,s.ep.vga[i]);
		printf("sla02.ep.digi_atten         %f\n",s.ep.digi_atten);
		printf("sla02.ep.scale_factor       %f\n",s.ep.scale_factor);
	for (i=0; i<1; i++) 
		printf("sla02.ep.pwidth[%d]    	%d\n",i,s.ep.pwidth[i]);
	for (i=0; i<1; i++) 
		printf("sla02.ep.average[%d]    	%d\n",i,s.ep.average[i]);
		printf("sla02.ep.bin_size           %f\n",s.ep.bin_size);
	for (i=0; i<150; i++) 
		printf("sla02.ep.waveform[%d]    	%d\n",i,s.ep.waveform[i]);




}

void print_wavgrp_bl(sla02 s) {

	printf("sla02.wavgrp.bl.npoints          	%d\n",s.wavgrp.bl.npoints);
	printf("sla02.wavgrp.bl.mean               	%f\n",s.wavgrp.bl.mean);
	printf("sla02.wavgrp.bl.sig                	%f\n",s.wavgrp.bl.sig);
} 


void print_wavgrp_wf_mmnt(sla02 s) {

	printf("sla02.wavgrp.wf.mmnt.mean          	%f\n",s.wavgrp.wf.mmnt.mean);
	printf("sla02.wavgrp.wf.mmnt.sig           	%f\n",s.wavgrp.wf.mmnt.sig);
	printf("sla02.wavgrp.wf.mmnt.skew           	%f\n",s.wavgrp.wf.mmnt.skew);
	printf("sla02.wavgrp.wf.mmnt.kurt           	%f\n",s.wavgrp.wf.mmnt.kurt);

}

void print_wavgrp_wf(sla02 s) {
	printf("sla02.wavgrp.wf.start               	%d\n",s.wavgrp.wf.start);
	printf("sla02.wavgrp.wf.npoints             	%d\n",s.wavgrp.wf.npoints);
	printf("sla02.wavgrp.wf.max                 	%f\n",s.wavgrp.wf.max);
	printf("sla02.wavgrp.wf.width               	%f\n",s.wavgrp.wf.width);
	printf("sla02.wavgrp.wf.amplitude           	%f\n",s.wavgrp.wf.amplitude);
	printf("sla02.wavgrp.wf.area                	%f\n",s.wavgrp.wf.area);
	printf("sla02.wavgrp.wf.nmax                	%f\n",s.wavgrp.wf.nmax);

}



void print_wavgrp_en(sla02 s) {

	printf("sla02.wavgrp.en.dem               	%f\n",s.wavgrp.en.dem);
	printf("sla02.wavgrp.en.ndvi1             	%f\n",s.wavgrp.en.ndvi1);
	printf("sla02.wavgrp.en.ndvi2               	%f\n",s.wavgrp.en.ndvi2);
	printf("sla02.wavgrp.en.landcover           	%d\n",s.wavgrp.en.landcover);
	printf("sla02.wavgrp.en.slope               	%f\n",s.wavgrp.en.slope);
	printf("sla02.wavgrp.en.roughness           	%f\n",s.wavgrp.en.roughness);

}

void print_wavgrp_cl(sla02 s) {

	printf("sla02.wavgrp.cl.rtyp               	%d\n",s.wavgrp.cl.rtyp);
	printf("sla02.wavgrp.cl.styp                	%d\n",s.wavgrp.cl.styp);
	printf("sla02.wavgrp.cl.dtyp                	%d\n",s.wavgrp.cl.dtyp);
	printf("sla02.wavgrp.cl.rms                 	%f\n",s.wavgrp.cl.rms);
	printf("sla02.wavgrp.cl.aspect              	%f\n",s.wavgrp.cl.aspect);
	printf("sla02.wavgrp.cl.lp_centroid         	%f\n",s.wavgrp.cl.lp_centroid);
	printf("sla02.wavgrp.cl.wv_centroid         	%f\n",s.wavgrp.cl.wv_centroid);
}

void print_wavgrp_gm(sla02 s) {

	printf("sla02.wavgrp.gm.cfflag              	%d\n",s.wavgrp.gm.cfflag);
	printf("sla02.wavgrp.gm.g0                 	%f\n",s.wavgrp.gm.g0);
	printf("sla02.wavgrp.gm.g1                  	%f\n",s.wavgrp.gm.g1);
	printf("sla02.wavgrp.gm.g2                  	%f\n",s.wavgrp.gm.g2);
	printf("sla02.wavgrp.gm.chisq               	%f\n",s.wavgrp.gm.chisq);
	printf("sla02.wavgrp.gm.nitr                	%d\n",s.wavgrp.gm.nitr);
}


void print_wavgrp(sla02 s) {
	print_wavgrp_bl(s);
	print_wavgrp_wf(s);
	print_wavgrp_en(s);
	print_wavgrp_cl(s);
	print_wavgrp_gm(s);
}


void print_one_shot(sla02 s) {

	print_tp(s);
	print_rp(s);
	print_bp(s);
	print_pap(s);
	print_ep(s);
	print_wavgrp(s);
}

sla02 sla, *s;

main(int argc, char *argv[]) 
{

	FILE *fp;
	long int shot_index, shot_count=0;
	char *obs, *infile, *infile1, *infile2;
	int shot_find=0;
	
	
	if (argc !=3 ) {
		fprintf(stderr,
		"The syntax for running this program is:  read_bin_sla obs# shot#\n");
		fprintf(stderr,
		"eg:  read_bin_sla obs1 168\n");
		
		return 1;
	}	
	
	obs=argv[1];
	infile1="/stok6/claudia/obs_dist/new_dist/";
	infile2="_sla.bin";
	
	infile=strcat(infile1,obs);
	infile=strcat(infile,infile2);
	printf("%s\n", infile);
	if ((fp=fopen(infile,"rb"))== NULL) { 
		fprintf(stderr,"Cann't open the binary file!!!\n");
		return 1;
		}
		
		
		
	shot_index=atol(argv[2]);
	while (!feof(fp)) {
	s=&sla;
	read_one_shot(s,fp);
	if (shot_index == shot_count) {
		shot_find=1;
		print_one_shot(sla);
		fclose(fp);
		return 0;
	}
	shot_count++;
	printf("shot count ->   %ld\n",shot_count);
	}	
	fclose(fp);
	if (!shot_find) 
		fprintf(stderr,"The shot index  %ld  you submitted is out ofrange\n",shot_index);
	

	return 1;

}