/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * PdxObject.cpp
 *
 *  Created on: Sep 29, 2011
 *      Author: npatel
 */

#include "PdxVersioned1.hpp"

#include <util/Log.hpp>

namespace PdxTests {

using apache::geode::client::CacheableInt32;

template <typename T1, typename T2>
bool PdxTests::PdxVersioned1::genericValCompare(T1 value1, T2 value2) const {
  if (value1 != value2) return false;
  LOGINFO("PdxObject::genericValCompare Line_19");
  return true;
}

template <typename T1, typename T2, typename L>
bool PdxTests::PdxVersioned1::genericCompare(T1* value1, T2* value2,
                                             L length) const {
  L i = 0;
  while (i < length) {
    if (value1[i] != value2[i]) {
      return false;
    } else {
      i++;
    }
  }
  LOGINFO("PdxObject::genericCompare Line_34");
  return true;
}

template <typename T1, typename T2>
bool PdxTests::PdxVersioned1::generic2DCompare(T1** value1, T2** value2,
                                               int length,
                                               int* arrLengths) const {
  LOGINFO("generic2DCompare length = %d ", length);
  LOGINFO("generic2DCompare value1 = %d \t value2", value1[0][0], value2[0][0]);
  LOGINFO("generic2DCompare value1 = %d \t value2", value1[1][0], value2[1][0]);
  LOGINFO("generic2DCompare value1 = %d \t value2", value1[1][1], value2[1][1]);
  for (int j = 0; j < length; j++) {
    LOGINFO("generic2DCompare arrlength0 = %d ", arrLengths[j]);
    for (int k = 0; k < arrLengths[j]; k++) {
      LOGINFO("generic2DCompare arrlength = %d ", arrLengths[j]);
      LOGINFO("generic2DCompare value1 = %d \t value2 = %d ", value1[j][k],
              value2[j][k]);
      if (value1[j][k] != value2[j][k]) return false;
    }
  }
  LOGINFO("PdxObject::genericCompare Line_34");
  return true;
}
/*void PdxVersioned1::checkNullAndDelete(void *data)
{
        if(data != NULL)
                delete[] data;
}
PdxVersioned1::~PdxVersioned1() {
         LOGINFO("~PdxVersioned1 - 1");
                checkNullAndDelete( m_string);
                LOGINFO("~PdxVersioned1 - 2");
                checkNullAndDelete( m_byteArray);
                LOGINFO("~PdxVersioned1 - 3");
                checkNullAndDelete( m_boolArray);
                LOGINFO("~PdxVersioned1 - 4");
                checkNullAndDelete( m_sbyteArray);
                LOGINFO("~PdxVersioned1 - 5");
                checkNullAndDelete( m_charArray);
                LOGINFO("~PdxVersioned1 - 6");
                checkNullAndDelete( m_uint16Array);
                LOGINFO("~PdxVersioned1 - 7");
                checkNullAndDelete( m_uint16Array);
                LOGINFO("~PdxVersioned1 - 8");
                checkNullAndDelete( m_int32Array);
                LOGINFO("~PdxVersioned1 - 9");
                checkNullAndDelete( m_uint32Array);
                LOGINFO("~PdxVersioned1 - 10");
                checkNullAndDelete( m_longArray);
                LOGINFO("~PdxVersioned1 - 11");
                checkNullAndDelete( m_ulongArray);
                LOGINFO("~PdxVersioned1 - 12");
                checkNullAndDelete( m_floatArray);
                LOGINFO("~PdxVersioned1 - 13");
                checkNullAndDelete( m_doubleArray);
                LOGINFO("~PdxVersioned1 - 14");
                checkNullAndDelete( m_byteByteArray);
                LOGINFO("~PdxVersioned1 - 15");
                checkNullAndDelete( m_stringArray);
                LOGINFO("~PdxVersioned1 - 16");
                checkNullAndDelete( m_byte252);
                LOGINFO("~PdxVersioned1 -17 ");
                checkNullAndDelete( m_byte253);
                LOGINFO("~PdxVersioned1 - 18");
                checkNullAndDelete( m_byte65535);
                LOGINFO("~PdxVersioned1 - 19");
                checkNullAndDelete( m_byte65536);
                LOGINFO("~PdxVersioned1 -20 ");
}*/
PdxVersioned1::PdxVersioned1(const char* key) { init(key); }

void PdxVersioned1::init(const char* key) {
  m_char = 'C';
  m_bool = true;
  m_byte = 0x74;
  m_sbyte = 0x67;
  m_int16 = 0xab;
  m_uint16 = 0x2dd5;
  m_int32 = 0x2345abdc;
  // m_uint32 = 0x2a65c434;
  // m_long = 324897980;
  m_ulong = 238749898;
  m_float = 23324.324f;
  m_double = 3243298498.00;
  m_string = std::string("PdxVersioned ") + key;
  m_boolArray = std::vector<bool>(3);
  m_boolArray[0] = true;
  m_boolArray[1] = false;
  m_boolArray[2] = true;
  /*for(int i=0; i<3; i++){
    m_boolArray[i] = true;
  };*/

  m_byteArray = std::vector<int8_t>(2);
  m_byteArray[0] = 0x34;
  m_byteArray[1] = 0x64;

  m_sbyteArray = std::vector<int8_t>{0x34, 0x64};

  m_charArray = std::vector<char16_t>{u'c', u'v'};

  int64_t d = 1310447869154L;
  m_date = CacheableDate::create(CacheableDate::duration(d));

  m_int16Array = std::vector<int16_t>{0x2332, 0x4545};

  m_uint16Array = std::vector<int16_t>{0x3243, 0x3232};

  m_int32Array = std::vector<int32_t>{23, 676868, 34343, 2323};

  m_uint32Array = std::vector<int32_t>{435, 234324, 324324, 23432432};

  m_longArray = std::vector<int64_t>{324324L, 23434545L};

  m_ulongArray = std::vector<int64_t>{3245435, 3425435};

  m_floatArray = std::vector<float>{232.565f, 2343254.67f};

  m_doubleArray = std::vector<double>{23423432, 4324235435.00};

  m_byteByteArray = new int8_t*[2];
  // for(int i=0; i<2; i++){
  //  m_byteByteArray[i] = new int8_t[1];
  //}
  m_byteByteArray[0] = new int8_t[1];
  m_byteByteArray[1] = new int8_t[2];
  m_byteByteArray[0][0] = 0x23;
  m_byteByteArray[1][0] = 0x34;
  m_byteByteArray[1][1] = 0x55;

  m_stringArray = {"one", "two"};

  m_arraylist = CacheableArrayList::create();
  m_arraylist->push_back(CacheableInt32::create(1));
  m_arraylist->push_back(CacheableInt32::create(2));

  m_map = CacheableHashMap::create();
  m_map->emplace(CacheableInt32::create(1), CacheableInt32::create(1));
  m_map->emplace(CacheableInt32::create(2), CacheableInt32::create(2));
  m_pdxEnum = CacheableEnum::create("pdxEnumTest", "pdx2", pdx2);
  m_byte252 = std::vector<int8_t>(252);
  for (int i = 0; i < 252; i++) {
    m_byte252[i] = 0;
  }

  m_byte253 = std::vector<int8_t>(253);
  for (int i = 0; i < 253; i++) {
    m_byte253[i] = 0;
  }

  m_byte65535 = std::vector<int8_t>(65535);
  for (int i = 0; i < 65535; i++) {
    m_byte65535[i] = 0;
  }

  m_byte65536 = std::vector<int8_t>(65536);
  for (int i = 0; i < 65536; i++) {
    m_byte65536[i] = 0;
  }

  /*for (int32_t index = 0; index <3; ++index) {
    m_objectArray->push_back(objectArray[index]);
  }*/
  /*
  if (keys.size() > 0) {
    m_objectArray = CacheableObjectArray::create();
    for (int32_t index = 0; index < keys.size(); ++index) {
      m_objectArray->push_back(keys.operator[](index));
    }
  }*/

  boolArrayLen = 3;
  byteArrayLen = 2;
  shortArrayLen = 2;
  intArrayLen = 4;
  longArrayLen = 2;
  doubleArrayLen = 2;
  floatArrayLen = 2;
  strLenArray = 2;
  charArrayLen = 2;
  byteByteArrayLen = 2;

  lengthArr = new int[2];

  lengthArr[0] = 1;
  lengthArr[1] = 2;
}

void PdxTests::PdxVersioned1::toData(PdxWriter& pw) const {
  // TODO:delete it later

  int* lengths = new int[2];

  lengths[0] = 1;
  lengths[1] = 2;
  pw.writeArrayOfByteArrays("m_byteByteArray", m_byteByteArray, 2, lengths);
  pw.writeChar("m_char", m_char);
  pw.writeBoolean("m_bool", m_bool);  // 1
  pw.writeBooleanArray("m_boolArray", m_boolArray);
  pw.writeByte("m_byte", m_byte);
  pw.writeByteArray("m_byteArray", m_byteArray);
  pw.writeCharArray("m_charArray", m_charArray);
  pw.writeObject("m_arraylist", m_arraylist);
  pw.writeObject("m_map", m_map);
  pw.writeString("m_string", m_string);
  pw.writeDate("m_dateTime", m_date);
  pw.writeDouble("m_double", m_double);
  pw.writeDoubleArray("m_doubleArray", m_doubleArray);
  pw.writeFloat("m_float", m_float);
  pw.writeFloatArray("m_floatArray", m_floatArray);
  pw.writeShort("m_int16", m_int16);
  pw.writeInt("m_int32", m_int32);
  // pw.writeLong("m_long", m_long);
  pw.writeIntArray("m_int32Array", m_int32Array);
  pw.writeLongArray("m_longArray", m_longArray);
  pw.writeShortArray("m_int16Array", m_int16Array);
  pw.writeByte("m_sbyte", m_sbyte);
  pw.writeByteArray("m_sbyteArray", m_sbyteArray);
  // int* strlengthArr = new int[2];

  // strlengthArr[0] = 5;
  // strlengthArr[1] = 5;
  pw.writeStringArray("m_stringArray", m_stringArray);
  pw.writeShort("m_uint16", m_uint16);
  // pw.writeInt("m_uint32", m_uint32);
  pw.writeLong("m_ulong", m_ulong);
  pw.writeIntArray("m_uint32Array", m_uint32Array);
  pw.writeLongArray("m_ulongArray", m_ulongArray);
  pw.writeShortArray("m_uint16Array", m_uint16Array);
  pw.writeByteArray("m_byte252", m_byte252);
  pw.writeByteArray("m_byte253", m_byte253);
  pw.writeByteArray("m_byte65535", m_byte65535);
  pw.writeByteArray("m_byte65536", m_byte65536);
  pw.writeObject("m_pdxEnum", m_pdxEnum);

  // TODO:delete it later
}

void PdxTests::PdxVersioned1::fromData(PdxReader& pr) {
  // TODO:temp added, delete later

  int32_t* Lengtharr;
  _GEODE_NEW(Lengtharr, int32_t[2]);
  int32_t arrLen = 0;
  m_byteByteArray =
      pr.readArrayOfByteArrays("m_byteByteArray", arrLen, &Lengtharr);
  // TODO::need to write compareByteByteArray() and check for m_byteByteArray
  // elements
  m_char = pr.readChar("m_char");
  // GenericValCompare
  m_bool = pr.readBoolean("m_bool");
  // GenericValCompare
  m_boolArray = pr.readBooleanArray("m_boolArray");
  m_byte = pr.readByte("m_byte");
  m_byteArray = pr.readByteArray("m_byteArray");
  m_charArray = pr.readCharArray("m_charArray");
  m_arraylist = std::dynamic_pointer_cast<CacheableArrayList>(
      pr.readObject("m_arraylist"));
  m_map = std::dynamic_pointer_cast<CacheableHashMap>(pr.readObject("m_map"));
  // TODO:Check for the size
  m_string = pr.readString("m_string");  // GenericValCompare
  m_date = pr.readDate("m_dateTime");    // compareData
  m_double = pr.readDouble("m_double");
  m_doubleArray = pr.readDoubleArray("m_doubleArray");
  m_float = pr.readFloat("m_float");
  m_floatArray = pr.readFloatArray("m_floatArray");
  m_int16 = pr.readShort("m_int16");
  m_int32 = pr.readInt("m_int32");
  // m_long = pr.readLong("m_long");
  m_int32Array = pr.readIntArray("m_int32Array");
  m_longArray = pr.readLongArray("m_longArray");
  m_int16Array = pr.readShortArray("m_int16Array");
  m_sbyte = pr.readByte("m_sbyte");
  m_sbyteArray = pr.readByteArray("m_sbyteArray");
  m_stringArray = pr.readStringArray("m_stringArray");
  m_uint16 = pr.readShort("m_uint16");
  // m_uint32 = pr.readInt("m_uint32");
  m_ulong = pr.readLong("m_ulong");
  m_uint32Array = pr.readIntArray("m_uint32Array");
  m_ulongArray = pr.readLongArray("m_ulongArray");
  m_uint16Array = pr.readShortArray("m_uint16Array");
  // LOGINFO("PdxVersioned1::readInt() start...");

  m_byte252 = pr.readByteArray("m_byte252");
  m_byte253 = pr.readByteArray("m_byte253");
  m_byte65535 = pr.readByteArray("m_byte65535");
  m_byte65536 = pr.readByteArray("m_byte65536");
  // TODO:Check for size
  m_pdxEnum = pr.readObject("m_pdxEnum");
}

std::string PdxTests::PdxVersioned1::toString() const {
  return "PdxVersioned 1 : " + m_string;
}

bool PdxTests::PdxVersioned1::equals(PdxTests::PdxVersioned1& other) const {
  PdxVersioned1* ot = dynamic_cast<PdxVersioned1*>(&other);
  if (!ot) {
    return false;
  }
  if (ot == this) {
    return true;
  }
  genericValCompare(ot->m_int32, m_int32);
  genericValCompare(ot->m_bool, m_bool);
  genericValCompare(ot->m_byte, m_byte);
  genericValCompare(ot->m_int16, m_int16);
  // genericValCompare(ot->m_long, m_long);
  genericValCompare(ot->m_float, m_float);
  genericValCompare(ot->m_double, m_double);
  genericValCompare(ot->m_sbyte, m_sbyte);
  genericValCompare(ot->m_uint16, m_uint16);
  // genericValCompare(ot->m_uint32, m_uint32);
  genericValCompare(ot->m_ulong, m_ulong);
  genericValCompare(ot->m_char, m_char);
  if (ot->m_string != m_string) {
    return false;
  }
  genericCompare(ot->m_byteArray.data(), m_byteArray.data(),
                 m_byteArray.size());
  genericCompare(ot->m_int16Array.data(), m_int16Array.data(),
                 m_int16Array.size());
  genericCompare(ot->m_int32Array.data(), m_int32Array.data(),
                 m_int32Array.size());
  genericCompare(ot->m_longArray.data(), m_longArray.data(),
                 m_longArray.size());
  genericCompare(ot->m_uint32Array.data(), m_uint32Array.data(),
                 m_uint32Array.size());
  genericCompare(ot->m_ulongArray.data(), m_ulongArray.data(),
                 m_ulongArray.size());
  genericCompare(ot->m_uint16Array.data(), m_uint16Array.data(),
                 m_uint16Array.size());
  genericCompare(ot->m_sbyteArray.data(), m_sbyteArray.data(),
                 m_sbyteArray.size());
  genericCompare(ot->m_charArray.data(), m_charArray.data(),
                 m_charArray.size());
  // generic2DCompare(ot->m_byteByteArray, m_byteByteArray, byteByteArrayLen,
  // lengthArr);

  // auto myenum = std::dynamic_pointer_cast<CacheableEnum>(m_pdxEnum);
  // auto otenum = std::dynamic_pointer_cast<CacheableEnum>(ot->m_pdxEnum);
  // if (myenum->getEnumOrdinal() != otenum->getEnumOrdinal()) return false;
  // if (strcmp(myenum->getEnumClassName(), otenum->getEnumClassName()) != 0)
  // return false;
  // if (strcmp(myenum->getEnumName(), otenum->getEnumName()) != 0) return
  // false;

  genericValCompare(ot->m_arraylist->size(), m_arraylist->size());
  for (size_t k = 0; k < m_arraylist->size(); k++) {
    genericValCompare(ot->m_arraylist->at(k), m_arraylist->at(k));
  }

  return true;
}
}  // namespace PdxTests