/************************************************************************
    MeOS - Orienteering Software
    Copyright (C) 2009-2022 Melin Software HB

    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, either version 3 of the License, or
    (at your option) any later version.

    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, see <http://www.gnu.org/licenses/>.

    Melin Software HB - software@melin.nu - www.melin.nu
    Eksoppsvägen 16, SE-75646 UPPSALA, Sweden

************************************************************************/

#include "stdafx.h"
#include <set>
#include "oDataContainer.h"
#include "oEvent.h"

#include "gdioutput.h"
#include "xmlparser.h"
#include "Table.h"
#include "meos_util.h"
#include "Localizer.h"
#include "meosException.h"

oDataContainer::oDataContainer(int maxsize) {
  dataPointer = 0;
  dataMaxSize = maxsize;
  stringIndexPointer = 0;
  stringArrayIndexPointer = 2;
}

oDataContainer::~oDataContainer(void) {
}

CellType oDataDefiner::getCellType() const {
  return CellType::cellEdit; 
}

oDataInfo::oDataInfo() {
  memset(Name, 0, sizeof(Name));
  Index = 0;
  Size = 0;
  Type = 0;
  SubType = 0;
  tableIndex = 0;
  decimalSize = 0;
  decimalScale = 1;
  zeroSortPadding = 0;
  memset(Description, 0, sizeof(Description));
}

oDataInfo::~oDataInfo() {
}

oDataInfo &oDataContainer::addVariableInt(const char *name,
                                          oIntSize isize, const char *description,
                                          const shared_ptr<oDataDefiner> &dataDef) {
  oDataInfo odi;
  odi.dataDefiner = dataDef;
  odi.Index=dataPointer;
  strcpy_s(odi.Name, name);
  strcpy_s(odi.Description, description);

  if (isize == oIS64)
    odi.Size=sizeof(__int64);
  else
    odi.Size=sizeof(int);

  odi.Type=oDTInt;
  odi.SubType=isize;

  if (dataPointer+odi.Size<=dataMaxSize){
    dataPointer+=odi.Size;
    return addVariable(odi);
  }
  else
    throw std::exception("oDataContainer: Out of bounds.");
}

oDataInfo &oDataContainer::addVariableDecimal(const char *name, const char *descr, int fixedDeci) {
  oDataInfo &odi = addVariableInt(name, oISDecimal, descr);
  odi.decimalSize = fixedDeci;
  int &s = odi.decimalScale;
  s = 1;
  for (int k = 0; k < fixedDeci; k++)
    s*=10;

  return odi;
}

oDataInfo &oDataContainer::addVariableString(const char *name, const char *descr, const shared_ptr<oDataDefiner> &dataDef) {
  return addVariableString(name, -1, descr, dataDef);
}

oDataInfo &oDataContainer::addVariableString(const char *name, int maxChar,
                                       const char *descr, const shared_ptr<oDataDefiner> &dataDef)
{
  oDataInfo odi;
  odi.dataDefiner = dataDef;
  strcpy_s(odi.Name,name);
  strcpy_s(odi.Description,descr);
  if (maxChar > 0) {
    odi.Index = dataPointer;
    odi.Size = sizeof(wchar_t)*(maxChar+1);
    odi.Type = oDTString;
    odi.SubType = oSSString;

    if (dataPointer+odi.Size<=dataMaxSize){
      dataPointer+=odi.Size;
      return addVariable(odi);
    }
    else
      throw std::exception("oDataContainer: Out of bounds.");
  }
  else {
    odi.Index = stringIndexPointer++;
    odi.Size = 0;
    odi.Type = oDTStringDynamic;
    odi.SubType = oSSString;
    return addVariable(odi);
  }
}

oDataInfo &oDataContainer::addVariableEnum(const char *name, int maxChar, const char *descr,
                                           const vector< pair<wstring, wstring> > enumValues) {
  oDataInfo &odi = addVariableString(name, maxChar, descr);
  odi.SubType = oSSEnum;
  for (size_t k = 0; k<enumValues.size(); k++)
    odi.enumDescription.push_back(enumValues[k]);
  return odi;
}

oDataInfo &oDataContainer::addVariable(oDataInfo &odi) {
  if (findVariable(odi.Name))
    throw std::exception("oDataContainer: Variable already exist.");

  //index[odi.Name]=odi;
  index.insert(hash(odi.Name), ordered.size());
  ordered.push_back(odi);
  return ordered.back();
}

int oDataContainer::hash(const char *name) {
  int res = 0;
  while(*name != 0) {
    res = 31 * res + *name;
    name++;
  }
  return res;
}

oDataInfo *oDataContainer::findVariable(const char *name) {
/*  map<string, oDataInfo>::iterator it=index.find(Name);

  if (it == index.end())
    return 0;
  else return &(it->second);

  return 0;*/
  int res;
  if (index.lookup(hash(name), res)) {
    return &ordered[res];
  }
  return 0;

}



const oDataInfo *oDataContainer::findVariable(const char *name) const
{
  if (name == 0)
    return 0;
  /*map<string, oDataInfo>::const_iterator it=index.find(Name);

  if (it == index.end())
    return 0;
  else return &(it->second);
  */
  int res;
  if (index.lookup(hash(name), res)) {
    return &ordered[res];
  }
  return 0;
}

void oDataContainer::initData(oBase *ob, int datasize) {
  if (datasize<dataPointer)
    throw std::exception("oDataContainer: Buffer too small.");

  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);
  memset(data, 0, dataPointer);
  memset(oldData, 0, dataPointer);

  if (stringIndexPointer > 0 || stringArrayIndexPointer>2) {
    vector<vector<wstring>> &str = *strptr;
    str.clear();
    str.resize(stringArrayIndexPointer);
    str[0].resize(stringIndexPointer);
    str[1].resize(stringIndexPointer);
  }
}

bool oDataContainer::setInt(void *data, const char *Name, int V)
{
  oDataInfo *odi=findVariable(Name);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  if (odi->Type!=oDTInt)
    throw std::exception("oDataContainer: Variable of wrong type.");

  if (odi->SubType == oIS64)
    throw std::exception("oDataContainer: Variable to large.");

  LPBYTE vd=LPBYTE(data)+odi->Index;
  if (*((int *)vd)!=V){
    *((int *)vd)=V;
    return true;
  }
  else return false;//Not modified
}

bool oDataContainer::setInt64(void *data, const char *Name, __int64 V)
{
  oDataInfo *odi=findVariable(Name);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  if (odi->Type!=oDTInt)
    throw std::exception("oDataContainer: Variable of wrong type.");

  if (odi->SubType != oIS64)
    throw std::exception("oDataContainer: Variable to large.");

  LPBYTE vd=LPBYTE(data)+odi->Index;
  if (*((__int64 *)vd)!=V){
    *((__int64 *)vd)=V;
    return true;
  }
  else return false;//Not modified
}

int oDataContainer::getInt(const void *data, const char *Name) const
{
  const oDataInfo *odi=findVariable(Name);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  if (odi->Type!=oDTInt)
    throw std::exception("oDataContainer: Variable of wrong type.");

  if (odi->SubType == oIS64)
    throw std::exception("oDataContainer: Variable to large.");

  LPBYTE vd=LPBYTE(data)+odi->Index;
  return *((int *)vd);
}

__int64 oDataContainer::getInt64(const void *data, const char *Name) const
{
  const oDataInfo *odi=findVariable(Name);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  if (odi->Type!=oDTInt)
    throw std::exception("oDataContainer: Variable of wrong type.");

  LPBYTE vd=LPBYTE(data)+odi->Index;

  if (odi->SubType == oIS64)
    return *((__int64 *)vd);
  else {
    int tmp = *((int *)vd);
    return tmp;
  }
}

bool oDataContainer::setString(oBase *ob, const char *name, const wstring &v) {
  oDataInfo *odi=findVariable(name);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  if (odi->Type == oDTString) {
    LPBYTE vd=LPBYTE(data)+odi->Index;

    if (wcscmp((wchar_t *)vd, v.c_str())!=0){
      wcsncpy_s((wchar_t *)vd, odi->Size/sizeof(wchar_t), v.c_str(), (odi->Size-1)/sizeof(wchar_t));
      return true;
    }
    else return false;//Not modified
  }
  else if (odi->Type == oDTStringDynamic) {
    wstring &str = (*strptr)[0][odi->Index];
    if (str == v)
      return false; // Same string

    str = v;
    return true;
  }
  else
    throw std::exception("oDataContainer: Variable of wrong type.");

}

const wstring &oDataContainer::formatString(const oBase *ob, const char *Name) const {
  const oDataInfo *odi = findVariable(Name);
  if (odi->dataDefiner) {
    return odi->dataDefiner->formatData(ob);
  }
  else if (odi->Type == oDTString) {
    return getString(ob, Name);
  }
  else if (odi->Type == oDTInt) {
    return itow(getInt(ob, Name));
  }
  throw std::exception("oDataContainer: Formatting failed.");
}

const wstring &oDataContainer::getString(const oBase *ob, const char *Name) const {
  const oDataInfo *odi=findVariable(Name);

  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  if (odi->Type == oDTString) {
    LPBYTE vd=LPBYTE(data)+odi->Index;
    wstring &res = StringCache::getInstance().wget();
    res = (wchar_t *) vd;
    return res;
  }
  else if (odi->Type == oDTStringDynamic) {
    wstring &str = (*strptr)[0][odi->Index];
    return str;
  }
  else
    throw std::exception("oDataContainer: Variable of wrong type.");
}


bool oDataContainer::setDate(void *data, const char *Name, const wstring &V)
{
  oDataInfo *odi=findVariable(Name);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  if (odi->Type!=oDTInt)
    throw std::exception("oDataContainer: Variable of wrong type.");

  int year=0,month=0,day=0;

  swscanf_s(V.c_str(), L"%d-%d-%d", &year, &month, &day);

  int C=year*10000+month*100+day;

  LPBYTE vd=LPBYTE(data)+odi->Index;
  if (*((int *)vd)!=C){
    *((int *)vd)=C;
    return true;
  }
  else return false;//Not modified
}

const wstring &oDataContainer::getDate(const void *data,
                               const char *Name) const
{
  const oDataInfo *odi=findVariable(Name);

  if (!odi)
    throw std::exception("oDataContainer: Variable not found.");

  if (odi->Type!=oDTInt)
    throw std::exception("oDataContainer: Variable of wrong type.");

  LPBYTE vd=LPBYTE(data)+odi->Index;
  int C=*((int *)vd);

  wchar_t bf[24];
  if (C%10000!=0 || C==0)
    swprintf_s(bf, L"%04d-%02d-%02d", C/10000, (C/100)%100, C%100);
  else
    swprintf_s(bf, L"%04d", C/10000);

  wstring &res = StringCache::getInstance().wget();
  res = bf;
  return res;
}

bool oDataContainer::write(const oBase *ob, xmlparser &xml) const {
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  xml.startTag("oData");


  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];
    if (di.Type==oDTInt){
      LPBYTE vd=LPBYTE(data)+di.Index;
      if (di.SubType != oIS64) {
        int nr;
        memcpy(&nr, vd, sizeof(int));
        xml.write(di.Name, nr);
      }
      else {
        __int64 nr;
        memcpy(&nr, vd, sizeof(__int64));
        xml.write64(di.Name, nr);
      }
    }
    else if (di.Type == oDTString){
      LPBYTE vd=LPBYTE(data)+di.Index;
      wstring out = (wchar_t*)vd;
      xml.write(di.Name, out);
    }
    else if (di.Type == oDTStringDynamic) {
      const wstring &str = (*strptr)[0][di.Index];
      xml.write(di.Name, str);
    }
  }

  xml.endTag();

  return true;
}

void oDataContainer::set(oBase *ob, const xmlobject &xo) {
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  xmlList xl;
  xo.getObjects(xl);

  xmlList::const_iterator it;

  for(it=xl.begin(); it != xl.end(); ++it){

    oDataInfo *odi=findVariable(it->getName());

    if (odi) {
      if (odi->Type == oDTInt){
        LPBYTE vd=LPBYTE(data)+odi->Index;
        if (odi->SubType != oIS64)
          *((int *)vd) = it->getInt();
        else
          *((__int64 *)vd) = it->getInt64();
      }
      else if (odi->Type == oDTString) {
        LPBYTE vd=LPBYTE(data)+odi->Index;
        wcsncpy_s((wchar_t *)vd, odi->Size/sizeof(wchar_t), it->getw(), (odi->Size-1)/sizeof(wchar_t));
      }
      else if (odi->Type == oDTStringDynamic) {
        wstring &str = (*strptr)[0][odi->Index];
        str = it->getw();
      }
    }
  }

  allDataStored(ob);
}

void oDataContainer::buildDataFields(gdioutput &gdi, int maxFieldSize) const
{
  vector<string> fields;
  for (size_t k = 0; k < ordered.size(); k++)
    fields.push_back(ordered[k].Name);

  buildDataFields(gdi, fields, maxFieldSize);
}

void oDataContainer::buildDataFields(gdioutput &gdi, const vector<string> &fields, int maxFieldSize) const
{
  for (size_t k=0;k<fields.size();k++) {
    //map<string, oDataInfo>::const_iterator it=index.find(fields[k]);
    const oDataInfo *odi = findVariable(fields[k].c_str());

    //if (it==index.end())
    if (odi == 0)
      throw std::exception( ("Bad key: " + fields[k]).c_str());

    const oDataInfo &di=*odi;
    string Id=di.Name+string("_odc");

    if (di.Type==oDTInt){
      if (di.SubType == oISDate || di.SubType == oISTime)
        gdi.addInput(Id, L"", 10, 0, gdi.widen(di.Description) + L":");
      else
        gdi.addInput(Id, L"", 6, 0, gdi.widen(di.Description) + L":");
    }
    else if (di.Type==oDTString){
      gdi.addInput(Id, L"", min(di.Size+2, maxFieldSize), 0, gdi.widen(di.Description) + L":");
    }
    else if (di.Type==oDTStringDynamic){
      gdi.addInput(Id, L"", maxFieldSize, 0, gdi.widen(di.Description) + L":");
    }
  }
}

int oDataContainer::getDataAmountMeasure(const void *data) const
{
  int amount = 0;
  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];
    if (di.Type==oDTInt) {
      LPBYTE vd=LPBYTE(data)+di.Index;
      int nr;
      memcpy(&nr, vd, sizeof(int));
      if (nr != 0)
        amount++;
    }
    else if (di.Type==oDTString) {
      LPBYTE vd=LPBYTE(data)+di.Index;
      amount += strlen((char *)vd);
    }

  }
  return amount;
}

void oDataContainer::fillDataFields(const oBase *ob, gdioutput &gdi) const
{
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];

    string Id=di.Name+string("_odc");
    if (di.Type==oDTInt){
      LPBYTE vd=LPBYTE(data)+di.Index;

      if (di.SubType != oIS64) {
        int nr;
        memcpy(&nr, vd, sizeof(int));
        if (di.SubType == oISCurrency) {
          if (strcmp(di.Name, "CardFee") == 0 && nr == -1)
            nr = 0; //XXX CardFee hack. CardFee = 0 is coded as -1
          gdi.setText(Id.c_str(), ob->getEvent()->formatCurrency(nr));
        }
        else {
          wchar_t bf[64];
          formatNumber(nr, di, bf);
          gdi.setText(Id.c_str(), bf);
        }
      }
      else {
        __int64 nr;
        memcpy(&nr, vd, sizeof(__int64));
        wchar_t bf[16];
        oBase::converExtIdentifierString(nr, bf);
        gdi.setText(Id.c_str(), bf);
      }
    }
    else if (di.Type==oDTString){
      LPBYTE vd=LPBYTE(data)+di.Index;
      gdi.setText(Id.c_str(), (wchar_t *)vd);
    }
    else if (di.Type==oDTStringDynamic){
      const wstring &str = (*strptr)[0][di.Index];
      gdi.setText(Id.c_str(), str);
    }
  }
}

bool oDataContainer::saveDataFields(oBase *ob, gdioutput &gdi) {
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];

    string Id=di.Name+string("_odc");

    if (!gdi.hasWidget(Id)) {
      continue;
    }
    if (di.Type==oDTInt){
      int no = 0;
      if (di.SubType == oISCurrency) {
        no = ob->getEvent()->interpretCurrency(gdi.getText(Id.c_str()));
      }
      else if (di.SubType == oISDate) {
        no = convertDateYMS(gdi.getText(Id.c_str()), true);
      }
      else if (di.SubType == oISTime) {
        no = convertAbsoluteTimeHMS(gdi.getText(Id.c_str()), -1);
      }
      else if (di.SubType == oISDecimal) {
        wstring str = gdi.getText(Id.c_str());
        for (size_t k = 0; k < str.length(); k++) {
          if (str[k] == ',') {
            str[k] = '.';
            break;
          }
        }
        double val = _wtof(str.c_str());
        no = int(di.decimalScale * val);
      }
      else {
        no = gdi.getTextNo(Id.c_str());
      }

      LPBYTE vd=LPBYTE(data)+di.Index;
      int oldNo = *((int *)vd);
      if (oldNo != no) {
        *((int *)vd)=no;
        ob->updateChanged();
      }
    }
    else if (di.Type == oDTString) {
      LPBYTE vd=LPBYTE(data)+di.Index;
      wstring oldS = (wchar_t *)vd;
      wstring newS = gdi.getText(Id.c_str());
      if (oldS != newS) {
        wcsncpy_s((wchar_t *)vd, di.Size/sizeof(wchar_t), newS.c_str(), (di.Size-1)/sizeof(wchar_t));
        ob->updateChanged();
      }
    }
    else if (di.Type == oDTStringDynamic) {
      wstring &oldS = (*strptr)[0][di.Index];
      wstring newS = gdi.getText(Id.c_str());
      if (oldS != newS) {
        oldS = newS;
        ob->updateChanged();
      }
    }
  }

  return true;
}

string oDataContainer::C_INT64(const string &name)
{
  return " `"+name+"` BIGINT NOT NULL DEFAULT 0, ";
}

string oDataContainer::C_INT(const string &name)
{
  return " `"+name+"` INT NOT NULL DEFAULT 0, ";
}

string oDataContainer::C_SMALLINT(const string &name)
{
  return " `"+name+"` SMALLINT NOT NULL DEFAULT 0, ";
}

string oDataContainer::C_TINYINT(const string &name)
{
  return " `"+name+"` TINYINT NOT NULL DEFAULT 0, ";
}

string oDataContainer::C_SMALLINTU(const string &name)
{
  return " `"+name+"` SMALLINT UNSIGNED NOT NULL DEFAULT 0, ";
}

string oDataContainer::C_TINYINTU(const string &name)
{
  return " `"+name+"` TINYINT UNSIGNED NOT NULL DEFAULT 0, ";
}

string oDataContainer::C_STRING(const string &name, int len)
{
  if (len>0) {
    char bf[16];
    sprintf_s(bf, "%d", len);
    return " `"+name+"` VARCHAR("+ bf +") NOT NULL DEFAULT '', ";
  }
  else {
    return " `"+name+"` MEDIUMTEXT NOT NULL, ";
  }
}

string oDataContainer::SQL_quote(const wchar_t *in)
{
  int len = wcslen(in);
  size_t alloc = len*4+4;
  if (alloc < 500) {
    char output[512];
    int len8 = WideCharToMultiByte(CP_UTF8, 0, in, len+1, output, alloc, 0, 0);
    output[len8] = 0;
    const char *inutf = output;
    char out[1024];
    int o=0;
    while(*inutf && o<1023){
      if (*inutf=='\'')
        out[o++]='\'';
      if (*inutf=='\\')
        out[o++]='\\';
      out[o++]=*inutf;
      inutf++;
    }
    out[o]=0;
    return out;
  }
  else {
    vector<char> output;
    output.resize(alloc);
    int len8 = WideCharToMultiByte(CP_UTF8, 0, in, len+1, &output.front(), alloc, 0, 0);
    output[len8] = 0;
    const char *inutf = &output.front();
  
    vector<char> out;
    out.reserve(alloc);
    while(*inutf){
      if (*inutf=='\'')
        out.push_back('\'');
      if (*inutf=='\\')
        out.push_back('\\');
      out.push_back(*inutf);
      inutf++;
    }
    out.push_back(0);
    string outs(&out[0]);
    return outs;
  }
}

string oDataContainer::generateSQLDefinition(const std::set<string> &exclude) const {
  string sql;
  bool addSyntx = !exclude.empty();

  for (size_t k = 0; k < ordered.size(); k++) {
    if (exclude.count(ordered[k].Name) == 0) {
      if (addSyntx)
         sql += "ADD COLUMN ";

      const oDataInfo &di = ordered[k];
      string name = di.Name;
      if (di.Type==oDTInt){
        if (di.SubType==oIS32 || di.SubType==oISDate || di.SubType==oISCurrency ||
           di.SubType==oISTime || di.SubType==oISDecimal)
          sql+=C_INT(name);
        else if (di.SubType==oIS16)
          sql+=C_SMALLINT(name);
        else if (di.SubType==oIS8)
          sql+=C_TINYINT(name);
        else if (di.SubType==oIS64)
          sql+=C_INT64(name);
        else if (di.SubType==oIS16U)
          sql+=C_SMALLINTU(name);
        else if (di.SubType==oIS8U)
          sql+=C_TINYINTU(name);
      }
      else if (di.Type==oDTString){
        sql+=C_STRING(name, di.Size-1);
      }
      else if (di.Type==oDTStringDynamic || di.Type==oDTStringArray){
        sql+=C_STRING(name, -1);
      }
    }
  }

  if (addSyntx && !sql.empty())
    return sql.substr(0, sql.length() - 2); //Remove trailing comma-space
  else
    return sql;
}

bool oDataContainer::isModified(const oDataInfo &di,
                                const void *data,
                                const void *oldData,
                                vector< vector<wstring> > *strptr) const {

  if (di.Type == oDTInt) {
    LPBYTE vd=LPBYTE(data)+di.Index;
    LPBYTE vdOld=LPBYTE(oldData)+di.Index;
    if (di.SubType != oIS64) {
      return memcmp(vd, vdOld, 4) != 0;
    }
    else {
      return memcmp(vd, vdOld, 8) != 0;
    }
  }
  else if (di.Type == oDTString) {
    LPBYTE vdB = LPBYTE(data) + di.Index;
    LPBYTE vdOldB = LPBYTE(oldData) + di.Index;
    wchar_t * vd=(wchar_t *)vdB;
    wchar_t * vdOld=(wchar_t *)vdOldB;
    return wcscmp(vd, vdOld) != 0;
  }
  else if (di.Type == oDTStringDynamic){
    const wstring &newS = (*strptr)[0][di.Index];
    const wstring &oldS = (*strptr)[1][di.Index];
    return newS != oldS;
  }
  else if (di.Type == oDTStringArray){
    const vector<wstring> &newS = (*strptr)[di.Index];
    const vector<wstring> &oldS = (*strptr)[di.Index+1];
    return newS != oldS;
  }
  else
    return true;
}

void oDataContainer::allDataStored(const oBase *ob) {
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);
  memcpy(oldData, data, ob->getDISize());
  if (stringIndexPointer > 0 || stringArrayIndexPointer > 2) {
    for (size_t k = 0; k < stringArrayIndexPointer; k+=2) {
      (*strptr)[k+1] = (*strptr)[k];
    }
  }
}

namespace {
  char *ensureCapacity(int size, vector<char> &bfData, int &alloc) {
    assert(alloc > 100);
    if (size >= alloc) {
      alloc += size;
      bfData.resize(alloc);
    }
    return &bfData[0];
  }
}

string oDataContainer::generateSQLSet(const oBase *ob, bool forceSetAll) const {
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  string sql;
  int alloc = 256;
  vector<char> bfData(alloc);
  char *bf = &bfData[0];

  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];

    if (!forceSetAll && !isModified(di, data, oldData, strptr)) {
      continue;
    }

    if (di.Type==oDTInt) {
      LPBYTE vd=LPBYTE(data)+di.Index;
      if (di.SubType == oIS8U) {
        sprintf_s(bf, alloc, ", `%s`=%u", di.Name, (*((int *)vd))&0xFF);
        sql+=bf;
      }
      else if (di.SubType == oIS16U) {
        sprintf_s(bf, alloc, ", `%s`=%u", di.Name, (*((int *)vd))&0xFFFF);
        sql+=bf;
      }
      else if (di.SubType == oIS8) {
        char r = (*((int *)vd))&0xFF;
        sprintf_s(bf, alloc, ", `%s`=%d", di.Name, (int)r);
        sql+=bf;
      }
      else if (di.SubType == oIS16) {
        short r = (*((int *)vd))&0xFFFF;
        sprintf_s(bf, alloc, ", `%s`=%d", di.Name, (int)r);
        sql+=bf;
      }
      else if (di.SubType != oIS64) {
        sprintf_s(bf, alloc, ", `%s`=%d", di.Name, *((int *)vd));
        sql+=bf;
      }
      else {
        char tmp[32];
        _i64toa_s(*((__int64 *)vd), tmp, 32, 10);
        sprintf_s(bf, alloc, ", `%s`=%s", di.Name, tmp);
        sql+=bf;
      }
    }
    else if (di.Type==oDTString) {
      LPBYTE vd=LPBYTE(data)+di.Index;
      sprintf_s(bf, alloc, ", `%s`='%s'", di.Name, SQL_quote((wchar_t *)vd).c_str());
      sql+=bf;
    }
    else if (di.Type==oDTStringDynamic) {
      const wstring &str = (*strptr)[0][di.Index];
      bf = ensureCapacity(2 * str.length() + 30, bfData, alloc);
      sprintf_s(bf, alloc, ", `%s`='%s'", di.Name, SQL_quote(str.c_str()).c_str());
      sql+=bf;
    }
    else if (di.Type==oDTStringArray) {
      const wstring str = encodeArray((*strptr)[di.Index]);
      bf = ensureCapacity(2 * str.length() + 30, bfData, alloc);
      sprintf_s(bf, alloc, ", `%s`='%s'", di.Name, SQL_quote(str.c_str()).c_str());
      sql+=bf;
    }
  }
  return sql;
}

bool oDataContainer::merge(oBase &destination, const oBase &source, const oBase *base) const {
  bool modified = false;
  void *destdata, *oldDataDmy;
  vector< vector<wstring> > *deststrptr;
  destination.getDataBuffers(destdata, oldDataDmy, deststrptr);

  void *srcdata;
  vector< vector<wstring> > *srcstrptr;
  source.getDataBuffers(srcdata, oldDataDmy, srcstrptr);

  void *basedata = nullptr;
  vector< vector<wstring> > *basestrptr = nullptr;
  if (base)
    base->getDataBuffers(basedata, oldDataDmy, basestrptr);
 
  auto setData = [](void *d, void *s, void *b, int off, int size) {
    LPBYTE vd = LPBYTE(d) + off;
    LPBYTE vs = LPBYTE(s) + off;
    if (memcmp(vd, vs, size) != 0) {
      if (b == nullptr || memcmp(LPBYTE(b) + off, vs, size) != 0) {
        memcpy(vd, vs, size);
        return true;
      }
    }
    return false;
  };
  
  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di = ordered[kk];
    if (di.Type == oDTInt) {
      if (di.SubType != oIS64) {
        if (setData(destdata, srcdata, basedata, di.Index, sizeof(int)))
          modified = true;
      }
      else {
        if (setData(destdata, srcdata, basedata, di.Index, sizeof(int64_t)))
          modified = true;
      }
    }
    else if (di.Type == oDTString) {
      if (setData(destdata, srcdata, basedata, di.Index, di.Size))
        modified = true;
    }
    else if (di.Type == oDTStringDynamic) {
      const wstring &s = (*srcstrptr)[0][di.Index];
      wstring &d = (*deststrptr)[0][di.Index];
      if (s != d) {
        if (basestrptr == nullptr || (*basestrptr)[0][di.Index] != s) {
          d = s;
          modified = true;
        }
      }
    }
    else if (di.Type == oDTStringArray) {
      const auto &s = (*srcstrptr)[di.Index];
      auto &d = (*deststrptr)[di.Index];
      if (s != d) {
        if (basestrptr == nullptr || (*basestrptr)[di.Index] != s) {
          d = s;
          modified = true;
        }
      }
    }
  }

  return modified;
}

void oDataContainer::getVariableInt(const void *data,
                                    list<oVariableInt> &var) const {
  var.clear();

  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];

    if (di.Type == oDTInt) {
      LPBYTE vd=LPBYTE(data)+di.Index;

      oVariableInt vi;
      memcpy(vi.name, di.Name, sizeof(vi.name));
      if (di.SubType != oIS64)
        vi.data32 = (int *)vd;
      else
        vi.data64 = (__int64 *)vd;
      var.push_back(vi);
    }
  }
}


void oDataContainer::getVariableString(const oBase *ob,
                                       list<oVariableString> &var) const
{
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  var.clear();

  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];

    if (di.Type == oDTString){
      LPBYTE vd=(LPBYTE)(data)+di.Index;

      oVariableString vs((wchar_t *)vd, di.Size);
      memcpy(vs.name, di.Name, sizeof(vs.name));
      var.push_back(vs);
    }
    else if (di.Type == oDTStringDynamic) {
      oVariableString vs((*strptr)[0], di.Index);
      memcpy(vs.name, di.Name, sizeof(vs.name));
      var.push_back(vs);
    }
    else if (di.Type == oDTStringArray) {
      oVariableString vs((*strptr)[di.Index]);
      memcpy(vs.name, di.Name, sizeof(vs.name));
      var.push_back(vs);
    }
  }
}

oDataInterface oDataContainer::getInterface(void *data, int datasize, oBase *ob)
{
  if (datasize<dataPointer) throw std::exception("Out Of Bounds.");

  return oDataInterface(this, data, ob);
}

oDataConstInterface oDataContainer::getConstInterface(const void *data, int datasize,
                                                      const oBase *ob) const
{
  if (datasize<dataPointer) throw std::exception("Out Of Bounds.");

  return oDataConstInterface(this, data, ob);
}


oDataInterface::oDataInterface(oDataContainer *odc, void *data, oBase *ob)
{
  oB=ob;
  oDC=odc;
  Data=data;
}

oDataConstInterface::~oDataConstInterface(void)
{
}

oDataConstInterface::oDataConstInterface(const oDataContainer *odc, const void *data, const oBase *ob)
{
  oB=ob;
  oDC=odc;
  Data=data;
}

oDataInterface::~oDataInterface(void)
{
}


void oDataContainer::buildTableCol(Table *table)
{
  for (size_t kk = 0; kk < ordered.size(); kk++) {
    oDataInfo &di=ordered[kk];

    if (di.dataDefiner)  {
      table->addDataDefiner(di.Name, di.dataDefiner.get());
      int w = strlen(di.Description)*6;
      di.tableIndex = di.dataDefiner->addTableColumn(table, di.Description, w);
    }
    else if (di.Type == oDTInt) {
      bool right = di.SubType == oISCurrency;
      bool numeric = di.SubType != oISDate && di.SubType != oISTime;
      int w;
      if (di.SubType == oISDecimal)
        w = max( (di.decimalSize+4)*10, 70);
      else
        w = 70;

      w = max(int(strlen(di.Description))*6, w);
      di.tableIndex = table->addColumn(di.Description, w, numeric, right);
    }
    else if (di.Type == oDTString) {
      int w = max(max(di.Size+1, int(strlen(di.Description)))*6, 70);

      for (size_t k = 0; k < di.enumDescription.size(); k++)
        w = max<int>(w, lang.tl(di.enumDescription[k].second).length() * 6);

      if (di.zeroSortPadding)
        di.tableIndex = table->addColumnPaddedSort(di.Description, w, di.zeroSortPadding, true);

      else
        di.tableIndex = table->addColumn(di.Description, w, false);

    }
    else if (di.Type == oDTStringDynamic) {
      int w = 64*6;
      di.tableIndex = table->addColumn(di.Description, w, false);
    }
  }
}

bool oDataContainer::formatNumber(int nr, const oDataInfo &di, wchar_t bf[64]) const {
  if (di.SubType == oISDate) {
    if (nr>0) {
      swprintf_s(bf, 64, L"%d-%02d-%02d", nr/(100*100), (nr/100)%100, nr%100);
    }
    else {
      bf[0] = '-';
      bf[1] = 0;
    }
    return true;
  }
  else if (di.SubType == oISTime) {
    if (nr>0 && nr<(30*24*3600)) {
      if (nr < 24*3600)
        swprintf_s(bf, 64, L"%02d:%02d:%02d", nr/3600, (nr/60)%60, nr%60);
      else {
        int days = nr / (24*3600);
        nr = nr % (24*3600);
        swprintf_s(bf, 64, L"%d+%02d:%02d:%02d", days, nr/3600, (nr/60)%60, nr%60);
      }
    }
    else {
      bf[0] = '-';
      bf[1] = 0;
    }
    return true;
  }
  else if (di.SubType == oISDecimal) {
    if (nr) {
      int whole = nr / di.decimalScale;
      int part = nr - whole * di.decimalScale;
      wstring deci = L",";
      wstring ptrn = L"%d" + deci + L"%0" + itow(di.decimalSize) + L"d";
      swprintf_s(bf, 64, ptrn.c_str(), whole, abs(part));
    }
    else
      bf[0] = 0;

    return true;
  }
  else {
    if (nr)
      swprintf_s(bf, 64, L"%d", nr);
    else
      bf[0] = 0;
    return true;
  }
}

int oDataContainer::fillTableCol(const oBase &owner, Table &table, bool canEdit) const {
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  owner.getDataBuffers(data, oldData, strptr);

  int nextIndex = 0;
  wchar_t bf[64];
  oBase &ob = *(oBase *)&owner;
  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di=ordered[kk];
    if (di.dataDefiner != nullptr) {
      if (di.tableIndex >= 0) {
        table.set(di.tableIndex, ob, 1000 + di.tableIndex,
                  di.dataDefiner->formatData(&ob), canEdit && di.dataDefiner->canEdit(),
                  di.dataDefiner->getCellType());
      }
    }
    else if (di.Type==oDTInt) {
      LPBYTE vd=LPBYTE(data)+di.Index;
      if (di.SubType != oIS64) {
        int nr;
        memcpy(&nr, vd, sizeof(int));
        if (di.SubType == oISCurrency) {
          table.set(di.tableIndex, ob, 1000+di.tableIndex, ob.getEvent()->formatCurrency(nr), canEdit);
        }
        else {
          formatNumber(nr, di, bf);
          table.set(di.tableIndex, ob, 1000+di.tableIndex, bf, canEdit);
        }
      }
      else {
        __int64 nr;
        memcpy(&nr, vd, sizeof(__int64));
        wchar_t bf[16];
        oBase::converExtIdentifierString(nr, bf);
        table.set(di.tableIndex, ob, 1000+di.tableIndex, bf, canEdit);
      }
    }
    else if (di.Type==oDTString) {
      LPBYTE vd=LPBYTE(data)+di.Index;
      if (di.SubType == oSSString || !canEdit) {
        table.set(di.tableIndex, *((oBase*)&owner), 1000+di.tableIndex, (wchar_t *)vd, canEdit, cellEdit);
      }
      else {
        wstring str((wchar_t *)vd);
        for (size_t k = 0; k<di.enumDescription.size(); k++) {
          if ( str == di.enumDescription[k].first ) {
            str = lang.tl(di.enumDescription[k].second);
            break;
          }
        }
        table.set(di.tableIndex, *((oBase*)&owner), 1000+di.tableIndex, str, true, cellSelection);
      }
    }
    else if (di.Type == oDTStringDynamic) {
      const wstring &str = (*strptr)[0][di.Index];
      table.set(di.tableIndex, *((oBase*)&owner), 1000+di.tableIndex, str, canEdit, cellEdit);
    }
    if (di.tableIndex >= 0)
      nextIndex = di.tableIndex + 1;
  }
  return nextIndex;
}

pair<int, bool>  oDataContainer::inputData(oBase *ob, int id,
                                           const wstring &input, int inputId,
                                           wstring &output, bool noUpdate)
{
  void *data, *oldData;
  vector< vector<wstring> > *strptr;
  ob->getDataBuffers(data, oldData, strptr);

  for (size_t kk = 0; kk < ordered.size(); kk++) {
    const oDataInfo &di = ordered[kk];

    if (di.tableIndex + 1000 == id) {
      if (di.dataDefiner) {
        const wstring &src = di.dataDefiner->formatData(ob);
        auto ret = di.dataDefiner->setData(ob, input, output, inputId);
        bool ch = output != src;
        if (ch && noUpdate == false)
          ob->synchronize(true);
        return ret;
      }
      else if (di.Type == oDTInt) {
        LPBYTE vd = LPBYTE(data) + di.Index;

        int no = 0;
        if (di.SubType == oISCurrency) {
          no = ob->getEvent()->interpretCurrency(input);
        }
        else if (di.SubType == oISDate) {
          no = convertDateYMS(input, true);
        }
        else if (di.SubType == oISTime) {
          no = convertAbsoluteTimeHMS(input, -1);
        }
        else if (di.SubType == oISDecimal) {
          wstring str = input;
          for (size_t k = 0; k < str.length(); k++) {
            if (str[k] == ',') {
              str[k] = '.';
              break;
            }
          }
          double val = _wtof(str.c_str());
          no = int(di.decimalScale * val);
        }
        else if (di.SubType == oIS64) {
          //__int64 no64 = _atoi64(input.c_str());
          __int64 k64;
          memcpy(&k64, vd, sizeof(__int64));
          __int64 no64 = oBase::converExtIdentifierString(input);

          memcpy(vd, &no64, sizeof(__int64));
          __int64 out64 = no64;
          if (k64 != no64) {
            ob->updateChanged();
            if (noUpdate == false)
              ob->synchronize(true);

            memcpy(&out64, vd, sizeof(__int64));
          }
          //output = itos(out64);
          wchar_t outbf[16];
          oBase::converExtIdentifierString(out64, outbf);
          output = outbf;

          return make_pair(0, false);
        }
        else
          no = _wtoi(input.c_str());

        int k;
        memcpy(&k, vd, sizeof(int));
        memcpy(vd, &no, sizeof(int));
        wchar_t bf[128];
        int outN = no;

        if (k != no) {
          ob->updateChanged();
          if (noUpdate == false)
            ob->synchronize(true);

          memcpy(&outN, vd, sizeof(int));
        }

        formatNumber(outN, di, bf);
        output = bf;
      }
      else if (di.Type == oDTString) {
        LPBYTE vd = LPBYTE(data) + di.Index;
        const wchar_t *str = input.c_str();

        if (di.SubType == oSSEnum) {
          size_t ix = inputId - 1;
          if (ix < di.enumDescription.size()) {
            str = di.enumDescription[ix].first.c_str();
          }
        }

        if (wcscmp((wchar_t *)vd, str) != 0) {
          wcsncpy_s((wchar_t *)vd, di.Size / sizeof(wchar_t), str, (di.Size - 1) / sizeof(wchar_t));

          ob->updateChanged();
          if (noUpdate == false)
            ob->synchronize(true);

          if (di.SubType == oSSEnum) {
            size_t ix = inputId - 1;
            if (ix < di.enumDescription.size()) {
              output = lang.tl(di.enumDescription[ix].second);
              // This might be incorrect if data was changed on server,
              // but this issue is minor, I think: conflicts have no resolution
              // Anyway, the row will typically be reloaded
            }
            else
              output = (wchar_t *)vd;
          }
          else
            output = (wchar_t *)vd;
          return make_pair(0, false);
        }
        else
          output = input;

      }
      else if (di.Type == oDTStringDynamic) {
        wstring &vd = (*strptr)[0][di.Index];

        if (vd != input) {
          vd = input;
          ob->updateChanged();
          if (noUpdate == false)
            ob->synchronize(true);

          output = (*strptr)[0][di.Index];
        }
        else
          output = input;
      }
    }
  }
  return make_pair(0, false);
}

void oDataContainer::fillInput(const oBase *obj, int id, const char *name,
                               vector< pair<wstring, size_t> > &out, size_t &selected) const {

  void *data, *olddata;
  pvectorstr strData;
  obj->getDataBuffers(data, olddata, strData);

  const oDataInfo * info = findVariable(name);

  if (!info) {
    for (size_t kk = 0; kk < ordered.size(); kk++) {
      const oDataInfo &di=ordered[kk];
      if (di.tableIndex+1000 == id) {
        info = &di;
        break;
      }
    }
  }

  if (info && info->Type == oDTString && info->SubType == oSSEnum) {
    wchar_t *vd = (wchar_t *)(LPBYTE(data)+info->Index);

    selected = -1;
    for (size_t k = 0; k < info->enumDescription.size(); ++k) {
      out.push_back(make_pair(lang.tl(info->enumDescription[k].second), k+1));
      if (info->enumDescription[k].first == wstring(vd))
        selected = k+1;
    }
  }
  else if (info && info->dataDefiner) {
    info->dataDefiner->fillInput(obj, out, selected);
  }
  else
    throw meosException("Invalid enum");
}

bool oDataContainer::setEnum(oBase *ob, const char *name, int selectedIndex) {
  const oDataInfo * info = findVariable(name);

  if (info  && info->Type == oDTString && info->SubType == oSSEnum) {
    if (size_t(selectedIndex - 1) < info->enumDescription.size()) {
      return setString(ob, name, info->enumDescription[selectedIndex-1].first);
    }
  }
  throw meosException("Invalid enum");
}

bool oVariableString::store(const wchar_t *in) {
  if (data) {
    if (wcscmp(in, data) != 0) {
      wcsncpy_s(data, maxSize/sizeof(wchar_t), in, (maxSize-1)/sizeof(wchar_t));
      return true;
    }
    return false;
  }
  else {
    vector<wstring> &str = *strData;
    if (strIndex>=0) {
      if (str[strIndex] != in) {
        str[strIndex] = in;
        return true;
      }
      else
        return false;
    }
  }

  return false;
}

wstring oDataContainer::encodeArray(const vector<wstring> &input) {
  return L"";//XXX
}

void oDataContainer::decodeArray(const string &input, vector<wstring> &output) {
}