#include "../envi/envi.h"
#include "../envi/binary.h"

namespace rts{

template <typename T>

class bsq: public binary<T> {

protected:
	
	envi header;

public:

	//open a file, given the file and its header's names
	bool open(std::string filename, std::string headername){

		if (header.load(headername)==false){
			std::cout<<"ERROR: unable to load head file"<<std::endl;
			return false;
		}

		binary::open(filename, vec<unsigned int>(header.samples, header.lines, header.bands), header.header_offset);
		return true;
		
	}

	//save one band of the file into the memory, and return the pointer
	bool getBand( T * p, unsigned int page){

		if (page >= header.bands){										//make sure the bank number is right
			std::cout<<"ERROR: page out of range"<<std::endl;
			return false;
		}

		getSlice(p, 2, page);
		return true;
	}

	//save one pixel of the file into the memory, and return the pointer
	bool getSpectrum(T * p, unsigned x, unsigned y){

		unsigned int i;

		if ( x >= header.samples || y >= header.lines){							//make sure the sample and line number is right
			std::cout<<"ERROR: sample or line out of range"<<std::endl;
			return false;
		}

		file.seekg((x + y * header.samples) * sizeof(T), std::ios::beg);           //point to the certain sample and line
		for (i = 0; i < header.bands; i++)
		{
			file.read((char *)(p + i), sizeof(T));
			file.seekg((header.lines * header.samples - 1) * sizeof(T), std::ios::cur);    //go to the next band
		}

		return true;	
	}

	//baseline correction and save it into file
	bool baseline(std::string outname, std::vector<unsigned> bands )
	{
		unsigned N = bands.size();							 //to get points number;

		ofstream bitext(outname.c_str(), std::ios::binary);                  //target binary file

		unsigned i, j, k;
		unsigned lownum, highnum;
		unsigned control=0;

		T * low;
		T * high;
		T * current;
		T * temp;

		low=(T *)malloc(header.lines * header.samples * sizeof(T));     //memory allocation
		high=(T *)malloc(header.lines * header.samples * sizeof(T)); 
		current=(T *)malloc(header.lines * header.samples * sizeof(T)); 

		if (low == NULL || high == NULL || current == NULL){
			cout<<"memory allocation failure";	
			return false;
			}

		//perform baseline correction

		//initialize lownum, highnum, low, high		
		lownum=0;
		if(bands[0] != 0){
			highnum = bands[control];			
			memset(low, 0.0, sizeof(T) * header.lines * header.samples);
		}
		else{
			control += 1;
			getBand(low, lownum);
			highnum = bands[control];
		}
		getBand(high, highnum);

		//correct every band 
		for(k = 0; k < header.bands; k++)		
		{		
			cout<<k<<endl;			//progress bar, delete it afterwards
			if( k == highnum && k != header.bands-1) {
				//if the high band is now on the last BL point?
				if (control != N-1) {

					control += 1;

					temp=low;
					low = high;
					high=temp;

					lownum=highnum;
					highnum = bands[control];
					getBand(high, highnum);

				}
				//if the last BL point on the last band of the file?
				else if ( bands[control] != header.bands-1) {

					temp = low;
					low = high;
					high = temp;

					memset(high, 0.0, sizeof(T) * header.lines * header.samples);

					lownum = highnum;
					highnum = header.bands-1;
				}
			}
			getBand(current, k);

		for(j=0; j<header.lines; j++)
			{
				for(i=0; i<header.samples; i++)
				{
					//straight line correction
					current[j * header.samples + i] = current[j * header.samples + i] - (
						( high[j * header.samples + i] - low[j * header.samples + i] ) * (T)(k - lownum) / (T)(highnum - lownum)
						) - low[j * header.samples + i];
				}				
			}
			
		bitext.write(reinterpret_cast<const char*>(current), sizeof(T) * header.lines * header.samples);   //write the corrected data into destination
		
		}	
		
		free(low);
		free(high);
		free(current);
		bitext.close();
		return true;
	}


	};
}