#include "sampling.h"
#include <stdlib.h>	//rand() srand()
#include <time.h>	//time()
#include <algorithm>	//swap
#include <iostream>
using namespace std;



void Sampling::Init(fx_module *module, int *num_of_people, 
											Vector *ind_unknown_x, double *initial_percent_sample,
											Vector *initial_parameter) {
	module_=module;
	const char *data_file1=fx_param_str_req(module_, "data1");
	const char *info_file1=fx_param_str_req(module_, "info1");
	Matrix x;
	data::Load(data_file1, &x);
	//num_of_betas_=x.n_rows();
	
  Matrix info1;
  data::Load(info_file1, &info1);
	num_of_people_=info1.n_cols();
	*num_of_people=num_of_people_;
  population_first_stage_x_.Init(num_of_people_);
	index_t start_col=0;
  for(index_t i=0; i<num_of_people_; i++) {
    population_first_stage_x_[i].Init(x.n_rows(), (index_t)info1.get(0, i));
    population_first_stage_x_[i].CopyColumnFromMat(0, start_col, 
										(index_t)info1.get(0,i), x);
    start_col+=(index_t)info1.get(0, i);
  }

	/*
	cout<<"data file 1:";
	for(index_t i=0; i<num_of_people_; i++) {
		cout<<"population_first_stage_x["<<i<<"]"<<endl;
		for(index_t j=0; j<population_first_stage_x_[i].n_rows(); j++){
			for(index_t k=0; k<population_first_stage_x_[i].n_cols(); k++) {
				cout<<population_first_stage_x_[i].get(j,k)<<" ";
			}
			cout<<endl;
		}
		cout<<endl;		
	}
	*/
  const char *data_file2=fx_param_str_req(module_, "data2");
	x.Destruct();
	data::Load(data_file2, &x);
	population_second_stage_x_.Init(num_of_people_);
	start_col=0;
  for(index_t i=0; i<num_of_people_; i++) {
    population_second_stage_x_[i].Init(x.n_rows(), (index_t)info1.get(0,i));
	  population_second_stage_x_[i].CopyColumnFromMat(0, start_col, 
							(index_t)info1.get(0,i), x);
    start_col+=(index_t)info1.get(0,i);
  }

	/*cout<<"data file 2:";
	for(index_t i=0; i<num_of_people_; i++) {
		cout<<"population_second_stage_x["<<i<<"]"<<endl;
		for(index_t j=0; j<population_second_stage_x_[i].n_rows(); j++){
			for(index_t k=0; k<population_second_stage_x_[i].n_cols(); k++) {
				cout<<population_second_stage_x_[i].get(j,k)<<" ";
			}
			cout<<endl;
		}
		cout<<endl;		
	}
	*/

	//need to be fixed
	const char *data_file3=fx_param_str_req(module_, "data3");
  x.Destruct();
  data::Load(data_file3, &x);
  population_unknown_x_past_.Init(num_of_people_);
  start_col=0;
  for(index_t i=0; i<num_of_people_; i++) {
    population_unknown_x_past_[i].Init(x.n_rows(), (index_t)info1.get(0,i));
    population_unknown_x_past_[i].CopyColumnFromMat(0, start_col, 
        (index_t)info1.get(0,i), x);
    start_col+=(index_t)info1.get(0, i);
  }

	 
	const char *info_y_file=fx_param_str_req(module_, "info_y");
  Matrix info_y;
  data::Load(info_y_file, &info_y);
  population_first_stage_y_.Init(num_of_people_);
  for(index_t i=0; i<num_of_people_; i++) {
	  population_first_stage_y_[i]=(index_t)info_y.get(0,i);
  }

  const char *info_ind_unknown_x_file=fx_param_str_req(module_, "info_ind_unknown_x");
  Matrix info_ind_unknown_x;
  data::Load(info_ind_unknown_x_file, &info_ind_unknown_x);
  num_of_unknown_x_=info_ind_unknown_x.n_cols();
  population_ind_unknown_x_.Init(num_of_unknown_x_);
  for(index_t i=0; i<num_of_unknown_x_; i++) {
	  population_ind_unknown_x_[i]=info_ind_unknown_x.get(0,i);
  }

	ind_unknown_x->Copy(population_ind_unknown_x_);

	
	if (fx_param_exists(module_, "starting_points")) {
		const char *initial_parameter_file=fx_param_str_req(module_,"stating_points");
		Matrix mtx_initial_parameter;
		data::Load(initial_parameter_file, &mtx_initial_parameter);
		if(mtx_initial_parameter.n_rows() != x.n_rows()){
			NOTIFY("The number of starting points given is not same as the number of parameters");
			NOTIFY("Use default...");
			initial_parameter->Init(x.n_rows()+2);	//beta+p+q
			initial_parameter->SetZero();
		}	//if
		mtx_initial_parameter.MakeColumnVector(0, initial_parameter);
	}	//if
	else {
		NOTIFY("Starting points are not given. Use default...");
		initial_parameter->Init(x.n_rows()+2);
		initial_parameter->SetZero();

	}



	//const char *initial_parameter_file=fx_param_str(module_, "stating_points", "default_initial.csv");
	/*if(initial_parameter_file !=NULL) {
		Matrix mtx_initial_parameter;
    data::Load(initial_parameter_file, &mtx_initial_parameter);
		mtx_initial_parameter.MakeColumnVector(0, initial_parameter);
	}
	else {
		NOTIFY("Starting points are not given. Use default...");
		initial_parameter->Init(x.n_rows());
		initial_parameter->SetZero();
	}
	*/
	/*Matrix mtx_initial_parameter;
  data::Load(initial_parameter_file, &mtx_initial_parameter);
	if(mtx_initial_parameter.n_rows()==1 && mtx_initial_parameter.get(0,0)==0){
		NOTIFY("Starting points are not given. Use default...");
		initial_parameter->Init(x.n_rows());
		initial_parameter->SetZero();
	}
	else if(mtx_initial_parameter.n_rows() != x.n_rows()){
		FATAL("The number of starting points given is not same as the number of parameters");
	}
	else {
		mtx_initial_parameter.MakeColumnVector(0, initial_parameter);
	}
	*/


  double arg_initial_percent_sample=fx_param_double(module_, "initial_percent_sample", 5);

	//Initilize memeber variables
	num_of_selected_sample_=0;
	count_num_sampling_=0;
	initial_percent_sample_=arg_initial_percent_sample;
  *initial_percent_sample=initial_percent_sample_;

	shuffled_array_.Init(num_of_people_);

	//return num_of_people_;

}



void Sampling::Shuffle() {
	//check - can be done in initilization
	int random =0;
	for(index_t i=0; i<num_of_people_; i++){
		shuffled_array_[i]=i;
	}	//i

	//http://www.cppreference.com/wiki/stl/algorithm/random_shuffle
//	std::random_shuffle(shuffled_array_.ptr(),
//	                  shuffled_array_.ptr()+num_of_people_);
		
   
	//Shuffle elements by randomly exchanging each with one other.
	for(index_t j=0; j<num_of_people_-1; j++){
		//random number for remaining position
		random = j+(rand() % (num_of_people_-j));	
		//shuffle
		swap( shuffled_array_[j], shuffled_array_[random] );
	}	//j

	cout<<"shuffled_array :";
	for(index_t i=0; i<num_of_people_; i++){
		cout<<shuffled_array_[i] <<" ";
	}
	cout<<endl;

}



/*void Sampling::ExpandSubset(double percent_added_sample, ArrayList<Matrix> *added_first_stage_x, 
											 ArrayList<Matrix> *added_second_stage_x, ArrayList<Matrix> *added_unknown_x_past, 
											 ArrayList<index_t> *added_first_stage_y, Vector *ind_unknown_x) {
												 */

void Sampling::ExpandSubset(double percent_added_sample, ArrayList<Matrix> *added_first_stage_x, 
											 ArrayList<Matrix> *added_second_stage_x, ArrayList<Matrix> *added_unknown_x_past, 
											 ArrayList<index_t> *added_first_stage_y) {
	
	int num_added_sample=0;
	
	//int old_num_selected_sample=num_of_selected_sample_;

	/*if(count_num_sampling_==0) {
		num_add_sample=math::RoundInt((num_of_people_)*(percent_added_sample));
		if(num_add_sample==0) {
			NOTIFY("number of sample to add is zero. start with Two samples.");
			num_add_sample=2;
		}

	}	else {
		num_add_sample=math::RoundInt((num_of_selected_sample_)*(percent_added_sample));
	}	//else
	*/
	if(num_of_selected_sample_==0) {
		NOTIFY("Initial sampling...");
		cout<<"initial_percent_sample_="<<initial_percent_sample_<<endl;
		num_added_sample=math::RoundInt((num_of_people_)*(initial_percent_sample_)/100);
	} else {
		num_added_sample=math::RoundInt((num_of_selected_sample_)*(percent_added_sample)/100);
	}

	if(num_added_sample==0) {
			NOTIFY("number of sample to add is zero. start with Two samples.");
			num_added_sample=2;
	}	//if
	else if(num_added_sample > num_of_people) {
			NOTIFY("number of sample to add exceeds total number of data points. Use all data");
			
	}	//if



	//Copy to currect Subset
	//added_first_stage_x->Init();
	//added_second_stage_x->Init();
	//added_unknown_x_past->Init();
	//added_first_stage_y->Init();
	//ind_unknown_x->CopyValues(population_ind_unknown_x_);


	if(num_added_sample+num_of_selected_sample_ >= num_of_people_){
		for(index_t i=num_of_selected_sample_; i<num_of_people_; i++){
			added_first_stage_x->PushBackCopy(population_first_stage_x_[shuffled_array_[i]]);
			added_second_stage_x->PushBackCopy(population_second_stage_x_[shuffled_array_[i]]);
			added_unknown_x_past->PushBackCopy(population_unknown_x_past_[shuffled_array_[i]]);
			added_first_stage_y->PushBackCopy(population_first_stage_y_[shuffled_array_[i]]);
		}		//i	
		num_of_selected_sample_=num_of_people_;
		NOTIFY("All data are used");
		
	} else {
		for(index_t i=num_of_selected_sample_; i<(num_of_selected_sample_+num_added_sample); i++){
			added_first_stage_x->PushBackCopy(population_first_stage_x_[shuffled_array_[i]]);
			added_second_stage_x->PushBackCopy(population_second_stage_x_[shuffled_array_[i]]);
			added_unknown_x_past->PushBackCopy(population_unknown_x_past_[shuffled_array_[i]]);
			added_first_stage_y->PushBackCopy(population_first_stage_y_[shuffled_array_[i]]);			
		}	//i
		num_of_selected_sample_+=num_added_sample;		
	}	//else
	
	//DEBUG_SAME_SIZE(sample_selector->size(), num_selected_sample);
  /*DEBUG_ASSERT_MSG(added_first_stage_x->size()==num_added_sample, 
      "Size of added first stage x is not same as number of added sample %i != %i",
      added_first_stage_x->size(), num_added_sample);
*/

	count_num_sampling_+=1;
	NOTIFY("Extend subset (%d)", count_num_sampling_);
	cout<<"num_added_sample="<<num_added_sample<<endl;
	
	
}


/*double Sampling::CalculateSamplingError() {

}
*/