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

int rct1_mas12_to_str(std::vector< std::vector<std::string> >& ele_str_org) {
  std::ifstream ifs("./rct1.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 <<  buf << 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_rct1_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;
  
  rct1_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_rct1_mas12.root","recreate");
  TTree *t = new TTree("rct1_mas12","rct1.mas12 tree");
  
  Int_t       A;
  std::string elt;
  Int_t       Z;
  Double_t    S2n,      S2p,      Qa,      Q2B,      Qep,      QBn;
  Double_t    S2n_err,  S2p_err,  Qa_err,  Q2B_err,  Qep_err,  QBn_err;
  Int_t       S2n_flag, S2p_flag, Qa_flag, Q2B_flag, Qep_flag, QBn_flag;
  
  t->Branch("A",            &A,            "A/I");
  t->Branch("elt",          &elt);
  t->Branch("Z",            &Z,            "Z/I");
  t->Branch("S2n",          &S2n,          "S2n/D");
  t->Branch("S2n_err",      &S2n_err,      "S2n_err/D");
  t->Branch("S2n_flag",     &S2n_flag,     "S2n_flag/I");
  t->Branch("S2p",          &S2p,          "S2p/D");
  t->Branch("S2p_err",      &S2p_err,      "S2p_err/D");
  t->Branch("S2p_flag",     &S2p_flag,     "S2p_flag/I");
  t->Branch("Qa",           &Qa,           "Qa/D");
  t->Branch("Qa_err",       &Qa_err,       "Qa_err/D");
  t->Branch("Qa_flag",      &Qa_flag,      "Qa_flag/I");
  t->Branch("Q2B",          &Q2B,          "Q2B/D");
  t->Branch("Q2B_err",      &Q2B_err,      "Q2B_err/D");
  t->Branch("Q2B_flag",     &Q2B_flag,     "Q2B_flag/I");
  t->Branch("Qep",          &Qep,          "Qep/D");
  t->Branch("Qep_err",      &Qep_err,      "Qep_err/D");
  t->Branch("Qep_flag",     &Qep_flag,     "Qep_flag/I");
  t->Branch("QBn",          &QBn,          "QBn/D");
  t->Branch("QBn_err",      &QBn_err,      "QBn_err/D");
  t->Branch("QBn_flag",     &QBn_flag,     "QBn_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];
    S2n          = ele_double[i][4];
    S2p          = ele_double[i][6];
    Qa           = ele_double[i][8];
    Q2B          = ele_double[i][10];
    Qep          = ele_double[i][12];
    QBn          = ele_double[i][14];
    S2n_err      = ele_double[i][5];
    S2p_err      = ele_double[i][7];
    Qa_err       = ele_double[i][9];
    Q2B_err      = ele_double[i][11];
    Qep_err      = ele_double[i][13];
    QBn_err      = ele_double[i][15];
    S2n_flag     = ele_flag[i][4];
    S2p_flag     = ele_flag[i][6];
    Qa_flag      = ele_flag[i][8];
    Q2B_flag     = ele_flag[i][10];
    Qep_flag     = ele_flag[i][12];
    QBn_flag     = ele_flag[i][14];
    t->Fill();
  }  
  f->Write();
  return 0;
}