// class columns in columns .h

class col_metadata {
public:
   // initialize class members
   col_metadata()
      : scaleMin(0.0),
        scaleMax(0.0),
        content(""),
        type(""),
        scale_type("") { }

   float scaleMin, scaleMax;
   std::string content, type, scale_type, header;
};

class column_data {
public:
   // initialize class members
   column_data()
      : header("") { }

   std::string header;
   std::vector<std::string> inputDataString;
   std::vector<char> inputDataChar;
   std::vector<int> inputDataInt;
   std::vector<float> inputDataFloat;
};

std::vector<col_metadata> metadata;  // create vector of col_metadata objects
std::vector<column_data> columns;  // create vector of column_data objects

#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>

#include "columns.h"

using namespace std;

// creates a data object and meta data object for each column
int createColObjs( stringstream &colsRowStream ){
   std::string rowCell;
   // parse header row into cells, tab delimiter
   while(getline(colsRowStream,rowCell,'\t')) {
      // create new column data object
      col_metadata newColMeta;  metadata.push_back(newColMeta);
      // create new column data object
      column_data newCol;  columns.push_back(newCol);
   }
   // clear the buffer
   colsRowStream.clear();
}


int main(int argc, char **argv) {

// declarations for args
   // file names
   int cmdArguments;
   std::string colsInFile, splitsInFile, outputFile;

//---------------------------------------------------------------------
//  Parse command line arguments
while ((cmdArguments = getopt (argc, argv, "c:i:o:d:h")) != -1)
   switch (cmdArguments)
   {
      case 'c':
         colsInFile = optarg;
      break;
      case 'i':
         splitsInFile = optarg;
      break;
      case 'o':
         outputFile = optarg;
      break;
      case 'd':
         //set delimiter;
      break;
      case 'h':
         std::cout << std::endl; // print help blurb
         exit(0);
      break;
   }

//---------------------------------------------------------------------
// check args

   if(splitsInFile.length() == 0) {
      std::cout << "  -> no input file was specified" << std::endl;
      return(-1);
   }
//---------------------------------------------------------------------
// declarations
   int i; // loop iterator
   std::string newSplitsLine, rowCell;
   std::vector<std::string> storeSplitsRows;    // storage structure for input rows
   stringstream colsRowStream;

//---------------------------------------------------------------------

   // create an input stream and open the parameter file
   ifstream splitsInput;
   splitsInput.open( splitsInFile.c_str() );

   // read innput file and store,
   while(getline(splitsInput,newSplitsLine)) {
      // remove '\r' EOL chars
      newSplitsLine.erase (remove(newSplitsLine.begin(),newSplitsLine.end(),'\r') , newSplitsLine.end());
      // store row data in vector of string
      storeSplitsRows.push_back(newSplitsLine);
   }

   //use first row to create objects for each col
   colsRowStream << storeSplitsRows[0];
   createColObjs ( colsRowStream );


   // load information from metadata row 0 to metadata[i].content
   colsRowStream << storeSplitsRows[0];
   i = 0;
   // parse header row into cells, tab delimiter
   while(getline(colsRowStream,rowCell,'\t')) {
      metadata[i].content = rowCell;
      i++;
   }
   // clear the buffer
   colsRowStream.clear();

   // load information from metadata row 1 to metadata[i].type
   colsRowStream << storeSplitsRows[1];
   i = 0;
   // parse header row into cells, tab delimiter
   while(getline(colsRowStream,rowCell,'\t')) {
      // add header row content to content field
      metadata[i].type = rowCell;
      i++;
   }
   // clear the buffer
   colsRowStream.clear();

   // load information from metadata row 1 to metadata[i].scale_type
   colsRowStream << storeSplitsRows[2];
   i = 0;
   // parse header row into cells, tab delimiter
   while(getline(colsRowStream,rowCell,'\t')) {
      // add header row content to content field
      metadata[i].scale_type = rowCell;
      i++;
   }
   // clear the buffer
   colsRowStream.clear();

   std::cout << std::endl;
   for (i=0; i<metadata.size(); i++) {
      std::cout << "metadata[" << i << "].content     " << metadata[i].content << std::endl;
      std::cout << "metadata[" << i << "].type        " << metadata[i].type << std::endl;
      std::cout << "metadata[" << i << "].scale_type  " << metadata [i].scale_type << std::endl;
      std::cout << std::endl;
   }

} // main EOF brace

// accepts a string stream and parses the data in to columns
int metadata_row_toCol( stringstream &colsRowStream ){
   int i = 0;
   std::string rowCell;
   // parse header row into cells, tab delimiter
   while(getline(colsRowStream,rowCell,'\t')) {
      metadata[i].content = rowCell;
      i++;
   }
   // clear the buffer
   colsRowStream.clear();
}

colsRowStream << storeSplitsRows[0];
metadata_row_toCol( colsRowStream ); // loads the first row to metadata[i].content