#include "../shared/SimpleLogFile.h"

#include "SerializeValuesByName.h"



/////////////////////////////////////////////////////////////////////
// SerializeRecords
/////////////////////////////////////////////////////////////////////

void SerializeRecords::addRecord(std::string &destination, 
				 RecordBuilder &source)
{ // Interesting.  RecordBuilder::exportAsString() isn't const.  It would
  // take some changes to make it const.  Easier just to accept it than to
  // fix it.
  std::string asString = source.exportAsString();
  size_t size = asString.size();
  assert(size <= 0xffffff);  // Three bytes
  destination.append((char *)(&size), 3);
  destination += asString;
}

void SerializeRecords::loadNames(RecordBuilder &header,
				 ValuesByName const &source)
{
  for (auto it = source.begin(); it != source.end(); it++)
    if (!_names.count(it->first))
    {
      const int fieldId = _names.size();
      _names[it->first] = fieldId;
      header.append(fieldId, it->first);
    }
}

void SerializeRecords::go(RecordBuilder &record, 
			  ValuesByName const &source) const
{
  for (auto it = source.begin(); it != source.end(); it++)
  {
    std::string const &name = it->first;
    const int fieldId = getProperty(_names, name, -1);
    assert(fieldId != -1);
    it->second.appendTo(record, fieldId);
  }
}


/////////////////////////////////////////////////////////////////////
// DeserializeRecords
/////////////////////////////////////////////////////////////////////

std::vector< Record::Ref > 
DeserializeRecords::getRecords(std::string const &source)
{
  std::vector< Record::Ref > result;
  int offset = 0;
  while (true)
  {
    int remaining = ((int)source.length()) - offset;
    if (remaining == 0)
      return result;
    if (remaining < 3)
    {
      reportError("getRecords() invalid record header");
      return std::vector< Record::Ref >();
    }
    int recordSize = 0;
    char *p = (char *)&recordSize;
    *p++ = source[offset++];
    *p++ = source[offset++];
    *p++ = source[offset++];
    remaining -= 3;
    if (recordSize > remaining)
    {
      reportError("getRecords() incomplete record");
      return std::vector< Record::Ref >();
    }
    Record::Ref record = Record::create(source.substr(offset, recordSize));
    if (!record)
    {
      reportError("getRecords() invalid record");
      return std::vector< Record::Ref >();
    }
    result.push_back(record);
    offset += recordSize;
  }
}

void DeserializeRecords::reportError(std::string const &type)
{
  static const bool immediate = false;
  if (immediate)
  { // Useful in testing.  You can see exactly which test case failed.  Also,
    // our tests usually abort before the 5 minute timer would print the
    // first ThreadMonitor data.
    TclList msg;
    msg<<FLF<<type;
    sendToLogFile(msg);
  }
  else
  {
    ThreadMonitor::find().increment(type);
  }
}

DeserializeRecords::DeserializeRecords(Record const &header)
{
  for (FieldId fieldId = 0; ; fieldId++)
  {
    const ValueBox value = header.lookUpValue(fieldId);
    bool success;
    std::string name;
    value.getString(success, name);
    if (!success)
      break;
    _names[fieldId] = name;
  }
}

bool DeserializeRecords::go(ValuesByName &dest, Record const &source) const
{
  auto fields = source.getFields();
  for (auto it = fields.cbegin(); it != fields.cend(); it++)
  {
    const FieldId fieldId = *it;
    const std::string name = getPropertyDefault(_names, fieldId);
    if (name == "")
    {
      reportError("loadFromString() can't find field name");
      return false;
    }
    dest[name] = source.lookUpValue(fieldId);
  }
  return true;
}


/////////////////////////////////////////////////////////////////////
// debugDump()
/////////////////////////////////////////////////////////////////////

std::string debugDump(Parse::ValuesByName const &row)
{
  TclList result;
  for (auto it = row.begin(); it != row.end(); it++)
  {
    TclList pair;
    pair<<it->first
	<<it->second.shortDebug();
    result<<pair;
  }
  return result;
}

void debugDump(TclList &addTo, std::vector< Parse::ValuesByName > const &rows)
{
  for (auto it = rows.begin(); it != rows.end(); it++)
    addTo<<debugDump(*it);
}

std::string debugDump(std::vector< Parse::ValuesByName > const &rows)
{
  TclList result;
  debugDump(result, rows);
  return result;
}