/* Copyright (C) 2014 InfiniDB, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/*******************************************************************************
 * $Id$
 *
 *******************************************************************************/

/*
 * we_brmrprtparser.cpp
 *
 *  Created on: Dec 13, 2011
 *      Author: bpaul
 */

#include <fstream>
#include <iostream>
using namespace std;

#include "we_brmrprtparser.h"

namespace WriteEngine
{
BrmReportParser::BrmReportParser() : fRptFile()
{
}

BrmReportParser::~BrmReportParser()
{
}

//------------------------------------------------------------------------------
// Serialize specified RptFileName into the ByteStream Bs.
// Serialization is done one record at a time.  File should be an ASCII file
// with newlines markers, because getline() is used.
// Function is limited to records that are no longer than 255 bytes.
// If a record is longer than 255 bytes, the function misbehaves.
//------------------------------------------------------------------------------
bool BrmReportParser::serialize(std::string RptFileName, messageqcpp::ByteStream& Bs)
{
  try
  {
    fRptFile.open(RptFileName.c_str(), ifstream::in);
  }
  catch (std::exception& ex)
  {
    cout << "Failed to open BRMRptFile " << RptFileName << endl;
    cout << ex.what() << endl;
    throw runtime_error(ex.what());
  }

  if (fRptFile.good())
  {
    char aBuff[10240];
    unsigned int aLen = 0;

    while (fRptFile.good() && !fRptFile.eof())
    {
      fRptFile.getline(aBuff, sizeof(aBuff) - 1);
      aLen = fRptFile.gcount();

      if ((aLen != (sizeof(aBuff) - 1)) && (aLen > 0))
      {
        // aBuff[aLen-1] = '\n';
        // aBuff[aLen]=0;
        // cout << "Data Read " << aBuff <<endl;
        if (aBuff[0] != '#')  // do not serialize comments
        {
          std::string strData = aBuff;
          Bs << strData;
        }
      }
    }  // while

    fRptFile.close();
    cout << "Closed File : " << RptFileName << " " << errno << endl;
  }
  else
  {
    cout << "Failed to open : " << RptFileName << " " << errno << endl;
    return false;
  }

  return true;
}

//------------------------------------------------------------------------------
// Serialize specified RptFileName into the ByteStream Bs.
// Serialization is done in 8192 byte blocks instead of by line or by record,
// so that this function will work for both character and binary files.
//------------------------------------------------------------------------------
bool BrmReportParser::serializeBlocks(std::string RptFileName, messageqcpp::ByteStream& Bs)
{
  try
  {
    fRptFile.open(RptFileName.c_str(), ifstream::in);
  }
  catch (std::exception& ex)
  {
    cout << "Failed to open Report File " << RptFileName << endl;
    cout << ex.what() << endl;
    return false;
  }

  if (fRptFile.good())
  {
    char aBuff[8192];
    unsigned int aLen = 0;
    std::string strBuff;

    while (fRptFile.good())
    {
      fRptFile.read(aBuff, sizeof(aBuff));
      aLen = fRptFile.gcount();

      if (aLen > 0)
      {
        strBuff.assign(aBuff, aLen);
        Bs << strBuff;
      }
    }

    fRptFile.close();
    cout << "Closed Report File : " << RptFileName << endl;
  }
  else
  {
    std::ostringstream oss;
    oss << "Failed to open Report File " << RptFileName << endl;
    cout << oss.str() << endl;
    return false;
  }

  return true;
}

void BrmReportParser::unserialize(messageqcpp::ByteStream& Bs)
{
  // TODO to be changed. left it here to understand how to implement
  /*
  ObjectReader::checkType(b, ObjectReader::SIMPLECOLUMN);
  ReturnedColumn::unserialize(b); // parent class unserialize
  b >> (uint32_t&) fOid;
  b >> fData;
  b >> reinterpret_cast<ByteStream::doublebyte&>(fReturnAll);
  b >> (uint32_t&) fSequence;
  */

  std::string aStrLine;

  while (Bs.length() > 0)
  {
    Bs >> aStrLine;
    cout << aStrLine;
  }
}

} /* namespace WriteEngine */