/*
 * 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.
 */

#include "../begin_native.hpp"
#include <PdxTypes.hpp>
#include "../end_native.hpp"

#include "PdxInstanceFactoryImpl.hpp"
#include "PdxInstanceImpl.hpp"
#include "DotNetTypes.hpp"

using namespace System::Text;

namespace Apache
{
  namespace Geode
  {
    namespace Client
    {

      namespace Internal
      {

        namespace native = apache::geode::client;

        PdxInstanceFactoryImpl::PdxInstanceFactoryImpl(String^ className, Cache^ cache)
        {
          if (className == nullptr)
            throw gcnew IllegalStateException(
            "Classname should not be null.");
          m_pdxType = gcnew PdxType(className, false);
          m_FieldVsValues = gcnew Dictionary<String^, Object^>();
          m_created = false;
          m_cache = cache;
        }

        IPdxInstance^ PdxInstanceFactoryImpl::Create()
        {
          if (m_created)
          {
            throw gcnew IllegalStateException(
              "The IPdxInstanceFactory.Create() method can only be called once.");
          }
          //need to get typeid;
          IPdxInstance^ pi = gcnew PdxInstanceImpl(m_FieldVsValues, m_pdxType, m_cache);
          m_created = true;
          return pi;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteChar(String^ fieldName, Char value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "char", PdxFieldTypes::CHAR, native::PdxTypes::CHAR_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteBoolean(String^ fieldName, Boolean value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "boolean", PdxFieldTypes::BOOLEAN, native::PdxTypes::BOOLEAN_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteByte(String^ fieldName, SByte value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "byte", PdxFieldTypes::BYTE, native::PdxTypes::BYTE_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteShort(String^ fieldName, Int16 value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "short", PdxFieldTypes::SHORT, native::PdxTypes::SHORT_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteInt(String^ fieldName, Int32 value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "int", PdxFieldTypes::INT, native::PdxTypes::INTEGER_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteLong(String^ fieldName, Int64 value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "long", PdxFieldTypes::LONG, native::PdxTypes::LONG_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteFloat(String^ fieldName, float value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "float", PdxFieldTypes::FLOAT, native::PdxTypes::FLOAT_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDouble(String^ fieldName, double value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "double", PdxFieldTypes::DOUBLE, native::PdxTypes::DOUBLE_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDate(String^ fieldName, System::DateTime value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddFixedLengthTypeField(fieldName, "Date", PdxFieldTypes::DATE, native::PdxTypes::DATE_SIZE);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteString(String^ fieldName, String^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "String", PdxFieldTypes::STRING);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteObject(String^ fieldName, Object^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Object", PdxFieldTypes::OBJECT);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteBooleanArray(String^ fieldName, array<Boolean>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "bool[]", PdxFieldTypes::BOOLEAN_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteCharArray(String^ fieldName, array<Char>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "char[]", PdxFieldTypes::CHAR_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteByteArray(String^ fieldName, array<Byte>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "byte[]", PdxFieldTypes::BYTE_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteShortArray(String^ fieldName, array<Int16>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "short[]", PdxFieldTypes::SHORT_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteIntArray(String^ fieldName, array<Int32>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "int[]", PdxFieldTypes::INT_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteLongArray(String^ fieldName, array<Int64>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "long[]", PdxFieldTypes::LONG_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteFloatArray(String^ fieldName, array<float>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "float[]", PdxFieldTypes::FLOAT_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDoubleArray(String^ fieldName, array<double>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "double[]", PdxFieldTypes::DOUBLE_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteStringArray(String^ fieldName, array<String^>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "String[]", PdxFieldTypes::STRING_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteObjectArray(String^ fieldName, System::Collections::Generic::List<Object^>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "Object[]", PdxFieldTypes::OBJECT_ARRAY);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteArrayOfByteArrays(String^ fieldName, array<array<Byte>^>^ value)
        {
          isFieldAdded(fieldName);
          m_pdxType->AddVariableLengthTypeField(fieldName, "byte[][]", PdxFieldTypes::ARRAY_OF_BYTE_ARRAYS);
          m_FieldVsValues->Add(fieldName, value);
          return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteField(String^ fieldName, Object^ fieldValue, Type^ type)
        {
          isFieldAdded(fieldName);
          if (type->Equals(DotNetTypes::IntType))
          {
            return this->WriteInt(fieldName, (int)fieldValue);
          }
          else if (type->Equals(DotNetTypes::StringType))
          {
            return this->WriteString(fieldName, (String^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::BooleanType))
          {
            return this->WriteBoolean(fieldName, (bool)fieldValue);
          }
          else if (type->Equals(DotNetTypes::FloatType))
          {
            return this->WriteFloat(fieldName, (float)fieldValue);
          }
          else if (type->Equals(DotNetTypes::DoubleType))
          {
            return this->WriteDouble(fieldName, (double)fieldValue);
          }
          else if (type->Equals(DotNetTypes::CharType))
          {
            return this->WriteChar(fieldName, (Char)fieldValue);
          }
          else if (type->Equals(DotNetTypes::SByteType))
          {
            return this->WriteByte(fieldName, (SByte)fieldValue);
          }
          else if (type->Equals(DotNetTypes::ShortType))
          {
            return this->WriteShort(fieldName, (short)fieldValue);
          }
          else if (type->Equals(DotNetTypes::LongType))
          {
            return this->WriteLong(fieldName, (Int64)fieldValue);
          }
          else if (type->Equals(DotNetTypes::ByteArrayType))
          {
            return this->WriteByteArray(fieldName, (array<Byte>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::DoubleArrayType))
          {
            return this->WriteDoubleArray(fieldName, (array<double>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::FloatArrayType))
          {
            return this->WriteFloatArray(fieldName, (array<float>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::ShortArrayType))
          {
            return this->WriteShortArray(fieldName, (array<Int16>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::IntArrayType))
          {
            return this->WriteIntArray(fieldName, (array<System::Int32>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::LongArrayType))
          {
            return this->WriteLongArray(fieldName, (array<Int64>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::BoolArrayType))
          {
            return this->WriteBooleanArray(fieldName, (array<bool>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::CharArrayType))
          {
            return this->WriteCharArray(fieldName, (array<Char>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::StringArrayType))
          {
            return this->WriteStringArray(fieldName, (array<String^>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::DateType))
          {
            return this->WriteDate(fieldName, (DateTime)fieldValue);
          }
          else if (type->Equals(DotNetTypes::ByteArrayOfArrayType))
          {
            return this->WriteArrayOfByteArrays(fieldName, (array<array<Byte>^>^)fieldValue);
          }
          else if (type->Equals(DotNetTypes::ObjectArrayType))
          {
            return this->WriteObjectArray(fieldName, safe_cast<System::Collections::Generic::List<Object^>^>(fieldValue));
          }
          else
          {
            return this->WriteObject(fieldName, fieldValue);
            //throw gcnew IllegalStateException("WriteField unable to serialize  " 
            //																	+ fieldName + " of " + type); 
          }
          // return this;
        }

        IPdxInstanceFactory^ PdxInstanceFactoryImpl::MarkIdentityField(String^ fieldName)
        {
          PdxFieldType^ pft = m_pdxType->GetPdxField(fieldName);

          if (pft == nullptr)
          {
            throw gcnew IllegalStateException(
              "Field must be added before calling MarkIdentityField ");
          }

          pft->IdentityField = true;
          return this;
        }

        void PdxInstanceFactoryImpl::isFieldAdded(String^ fieldName)
        {
          if (fieldName == nullptr || fieldName->Length == 0 || m_FieldVsValues->ContainsKey(fieldName))
          {
            throw gcnew IllegalStateException(
              "Field: " + fieldName + " either already added into PdxInstanceFactory or it is null");
          }  // namespace Client
        }  // namespace Geode
      }  // namespace Apache

    }
  }
}