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

int mass_mas12_to_str(std::vector< std::vector<std::string> >& ele_str_org) {
  std::ifstream ifs("./mass.mas12");
  // format    :  a1,i3,i5,i5,i5,1x,a3,a4,1x,f13.5,f11.5,f11.3,f9.3,1x,a2,f11.3,f9.3,1x,i3,1x,f12.5,f11.5
  //              cc NZ  N  Z  A    el  o     mass  unc binding unc     B  beta  unc    atomic_mass   unc
  const unsigned int number_of_columns = 17;
  unsigned int column_end_points[number_of_columns] = {0,3,8,13,18,22,26,40,51,62,71,74,85,94,98,111,122}; // 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 << "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" << 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_mass_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;
  
  mass_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_mass_mas12.root","recreate");
  TTree *t = new TTree("mass_mas12","mass.mas12 tree");
  
  Int_t       NZ;
  Int_t       N;
  Int_t       Z;
  Int_t       A;
  std::string EL;
  std::string O;
  Double_t    ME,      BE,      DE,      AM;
  Double_t    ME_err,  BE_err,  DE_err,  AM_err;
  Int_t       ME_flag, BE_flag, DE_flag, AM_flag;

  t->Branch("NZ",      &NZ,      "NZ/I");
  t->Branch("N",       &N,       "N/I");
  t->Branch("Z",       &Z,       "Z/I");
  t->Branch("A",       &A,       "A/I");
  t->Branch("EL",      &EL);
  t->Branch("O",       &O);
  t->Branch("ME",      &ME,      "ME/D");
  t->Branch("ME_err",  &ME_err,  "ME_err/D");
  t->Branch("ME_flag", &ME_flag, "ME_flag/I");
  t->Branch("BE",      &BE,      "BE/D");
  t->Branch("BE_err",  &BE_err,  "BE_err/D");
  t->Branch("BE_flag", &BE_flag, "BE_flag/I");
  t->Branch("DE",      &DE,      "DE/D");
  t->Branch("DE_err",  &DE_err,  "DE_err/D");
  t->Branch("DE_flag", &DE_flag, "DE_flag/I");
  t->Branch("AM",      &AM,      "AM/D");
  t->Branch("AM_err",  &AM_err,  "AM_err/D");
  t->Branch("AM_flag", &AM_flag, "AM_flag/I");

  for (unsigned int i=0; i<ele_str.size(); i++) {
    NZ      = ele_int[i][1];
    N       = ele_int[i][2];
    Z       = ele_int[i][3];
    A       = ele_int[i][4];
    EL      = ele_str[i][5];
    O       = ele_str[i][6];
    ME      = ele_double[i][7];
    BE      = ele_double[i][9];
    DE      = ele_double[i][12];
    AM      = ele_double[i][15];
    ME_err  = ele_double[i][8];
    BE_err  = ele_double[i][10];
    DE_err  = ele_double[i][13];
    AM_err  = ele_double[i][16];
    ME_flag = ele_flag[i][7];
    BE_flag = ele_flag[i][9];
    DE_flag = ele_flag[i][12];
    AM_flag = ele_flag[i][15];
    t->Fill();
  }  
  f->Write();
  f->Close();
  return 0;
}