#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include "TFile.h"
#include "TTree.h"

int rct2_mas12_to_str(std::vector< std::vector<std::string> >& ele_str_org) {
  std::ifstream ifs("./rct2.mas12");
  const unsigned int number_of_columns = 16;
  unsigned int column_end_points[number_of_columns] = {0,3,6,10,21,29,39,47,57,65,75,83,93,101,111,119}; // 0 origin
  
  if (ifs.fail()) {
    std::cerr << "Fail to read the file" << std::endl;
    return -1;
  }
  
  std::string buf;
  for (unsigned int i=1; i <=39; i++) {
    getline(ifs, buf);
    std::cout << "Skipped: " << buf << std::endl;
  }
  
  while (getline(ifs, buf)) {
    std::vector<std::string> str_tmp;
    unsigned int column_start_point = 0;
    //std::cout << "buf.length()" << buf.length() <<std::endl;
    for (unsigned int i = 0; i < number_of_columns; i++) {
      if ((column_end_points[i] + 1) < buf.length()) {
	str_tmp.push_back(buf.substr(column_start_point,
				     column_end_points[i] + 1 - column_start_point));
	column_start_point = column_end_points[i] + 1;
      } else if (column_start_point < buf.length()) {
	str_tmp.push_back(buf.substr(column_start_point,
				     buf.length() - column_start_point));
	column_start_point = buf.length() + 1;
      } else {
	str_tmp.push_back("");
      }
    }
    ele_str_org.push_back(str_tmp);
//    std::cout << "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" << std::endl;
//    std::cout <<  str << std::endl;
//    for (unsigned int i = 0; i < 16; i++) {
//      std::cout << str_tmp.at(i) << ",";
//    }
//    std::cout<<std::endl;
  }
  return 0;
}

int str_to_val(std::vector< std::vector<std::string> >& ele_str_org,
	       std::vector< std::vector<std::string> >& ele_str,
	       std::vector< std::vector<int> >&         ele_int,
	       std::vector< std::vector<double> >&      ele_double,
	       std::vector< std::vector<int> >&         ele_flag) {
  ele_str = ele_str_org;
  // resize of 2-dimensional vector
  ele_int.resize(ele_str_org.size(), std::vector<int>(ele_str_org.front().size(), 0));
  ele_double.resize(ele_str_org.size(), std::vector<double>(ele_str_org.front().size(), 0.0));
  ele_flag.resize(ele_str_org.size(), std::vector<int>(ele_str_org.front().size(), 0));
  
  for (unsigned int i=0; i<ele_str.size(); i++) {
    for (unsigned int j=0; j<ele_str.front().size(); j++) {
      // remove " " and "*"
      std::string::size_type pos = 0;
      while((pos = (ele_str[i][j]).find_first_of(" *", pos)) != std::string::npos) {
	(ele_str[i][j]).replace(pos, 1, "");
      }
      // remove "#" and ele_flag = 2
      pos = 0;
      while((pos = (ele_str[i][j]).find_first_of("#", pos)) != std::string::npos) {
	(ele_str[i][j]).replace(pos, 1, "");
	ele_flag[i][j] = 2;
      }
      if (ele_str[i][j]!="") {
	// convert string to int
	stringstream ss1;
	ss1 << ele_str[i][j];
	ss1 >> ele_int[i][j];
	// convert string to double
	stringstream ss2;
	ss2 << ele_str[i][j];
	ss2 >> ele_double[i][j];
	// if there is a value,  ele_flag = 1
	if (ele_flag[i][j] == 0) {
	  ele_flag[i][j] = 1;
	}
      }
    }
  }
  
  //for (unsigned int i=0; i<ele_str.size(); i++) {
  //  for (unsigned int j=0; j<ele_str.front().size(); j++) {
  //    std::cout << ele_str_org[i][j] << ",";
  //  }
  //  std::cout<<std::endl;
  //  for (unsigned int j=0; j<ele_str.front().size(); j++) {
  //    std::cout << ele_str[i][j] << ",";
  //  }
  //  std::cout<<std::endl;
  //  for (unsigned int j=0; j<ele_str.front().size(); j++) {
  //    std::cout << ele_str[i][j];
  //    if (ele_flag[i][j]==2) {
  //	std::cout  << "t";
  //    }
  //    std::cout  << ",";
  //  }
  //  std::cout<<std::endl;
  //  for (unsigned int j=0; j<ele_double.front().size(); j++) {
  //    std::cout << ele_double[i][j] << ",";
  //  }
  //  std::cout<<std::endl;
  //}
  return 0;
}

int tree_rct2_mas12(){
  std::vector< std::vector<std::string> > ele_str_org;
  std::vector< std::vector<std::string> > ele_str;
  std::vector< std::vector<int> >         ele_int;
  std::vector< std::vector<double> >      ele_double;
  std::vector< std::vector<int> >         ele_flag;
  
  rct2_mas12_to_str(ele_str_org);
  str_to_val(ele_str_org, ele_str, ele_int, ele_double, ele_flag);  
  
  TFile *f = new TFile("tree_rct2_mas12.root","recreate");
  TTree *t = new TTree("rct2_mas12","rct2.mas12 tree");
  
  Int_t       A;
  std::string elt;
  Int_t       Z;
  Double_t    Sn,      Sp,      Q4B,      Qda,      Qpa,      Qna;
  Double_t    Sn_err,  Sp_err,  Q4B_err,  Qda_err,  Qpa_err,  Qna_err;
  Int_t       Sn_flag, Sp_flag, Q4B_flag, Qda_flag, Qpa_flag, Qna_flag;

  t->Branch("A",            &A,            "A/I");
  t->Branch("elt",          &elt);
  t->Branch("Z",            &Z,            "Z/I");
  t->Branch("Sn",           &Sn,           "Sn/D");
  t->Branch("Sn_err",       &Sn_err,       "Sn_err/D");
  t->Branch("Sn_flag",      &Sn_flag,      "Sn_flag/I");
  t->Branch("Sp",           &Sp,           "Sp/D");
  t->Branch("Sp_err",       &Sp_err,       "Sp_err/D");
  t->Branch("Sp_flag",      &Sp_flag,      "Sp_flag/I");
  t->Branch("Q4B",          &Q4B,          "Q4B/D");
  t->Branch("Q4B_err",      &Q4B_err,      "Q4B_err/D");
  t->Branch("Q4B_flag",     &Q4B_flag,     "Q4B_flag/I");
  t->Branch("Qda",          &Qda,          "Qda/D");
  t->Branch("Qda_err",      &Qda_err,      "Qda_err/D");
  t->Branch("Qda_flag",     &Qda_flag,     "Qda_flag/I");
  t->Branch("Qpa",          &Qpa,          "Qpa/D");
  t->Branch("Qpa_err",      &Qpa_err,      "Qpa_err/D");
  t->Branch("Qpa_flag",     &Qpa_flag,     "Qpa_flag/I");
  t->Branch("Qna",          &Qna,          "Qna/D");
  t->Branch("Qna_err",      &Qna_err,      "Qna_err/D");
  t->Branch("Qna_flag",     &Qna_flag,     "Qna_flag/I");
  
  for (unsigned int i=0; i<ele_str.size(); i++) {
    A            = ele_int[i][1];
    elt          = ele_str[i][2];
    Z            = ele_int[i][3];
    Sn           = ele_double[i][4];
    Sp           = ele_double[i][6];
    Q4B          = ele_double[i][8];
    Qda          = ele_double[i][10];
    Qpa          = ele_double[i][12];
    Qna          = ele_double[i][14];
    Sn_err       = ele_double[i][5];
    Sp_err       = ele_double[i][7];
    Q4B_err      = ele_double[i][9];
    Qda_err      = ele_double[i][11];
    Qpa_err      = ele_double[i][13];
    Qna_err      = ele_double[i][15];
    Sn_flag      = ele_flag[i][4];
    Sp_flag      = ele_flag[i][6];
    Q4B_flag     = ele_flag[i][8];
    Qda_flag     = ele_flag[i][10];
    Qpa_flag     = ele_flag[i][12];
    Qna_flag     = ele_flag[i][14];
    t->Fill();
  }  
  f->Write();
  return 0;
}