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

#pragma once


#include "geode_defs.hpp"
#include "begin_native.hpp"
#include <geode/CacheableKey.hpp>
#include <geode/CacheableBuiltins.hpp>
#include "end_native.hpp"

#include "ISerializable.hpp"
#include "IDelta.hpp"
#include "native_shared_ptr.hpp"
#include "impl/EnumInfo.hpp"
#include "Log.hpp"
#include <vcclr.h>
#include "IPdxTypeMapper.hpp"

using namespace System::Reflection;
using namespace System;
using namespace System::Collections::Generic;

namespace Apache
{
  namespace Geode
  {
    namespace Client
    {
      namespace native = apache::geode::client;

        interface class IPdxSerializable;
        interface class IPdxSerializer;
        ref class Cache;

      /// <summary>
      /// Signature of native function delegates passed to native
      /// <c>native::Serializable::registerType</c>.
      /// Such functions should return an empty instance of the type they
      /// represent. The instance will typically be initialized immediately
      /// after creation by a call to native
      /// <c>native::Serializable::fromData</c>.
      /// </summary>
      delegate std::shared_ptr<native::Serializable> TypeFactoryNativeMethodGeneric();

      /// <summary>
      /// Signature of function delegates passed to
      /// <see cref="Serializable.RegisterType" />. Such functions should
      /// return an empty instance of the type they represent.
      /// The delegate shall be stored in the internal <c>DelegateWrapper</c>
      /// class and an instance will be initialized in the
      /// <c>DelegateWrapper.NativeDelegate</c> method by a call to
      /// <see cref="ISerializable.FromData" />.
      /// </summary>
      public delegate Apache::Geode::Client::ISerializable^ TypeFactoryMethod();
      /// <summary>
      /// Delegate to wrap a native <c>native::Serializable</c> type.
      /// </summary>
      /// <remarks>
      /// This delegate should return an object of type <c>ISerializable</c>
      /// given a native object.
      /// </remarks>
      delegate Apache::Geode::Client::ISerializable^ DataSerializablePrimitiveWrapperDelegate(std::shared_ptr<native::Serializable> obj);

			/// <summary>
      /// Signature of function delegates passed to
      /// <see cref="Serializable.RegisterPdxType" />. Such functions should
      /// return an empty instance of the type they represent.
      /// New instance will be created during de-serialization of Pdx Types
      /// <see cref="IPdxSerializable" />.
      /// </summary>
      public delegate Apache::Geode::Client::IPdxSerializable^ PdxTypeFactoryMethod();
      
      /// <summary>
      /// This class wraps the native C++ <c>native::Serializable</c> objects
      /// as managed <see cref="ISerializable" /> objects.
      /// </summary>
      public ref class Serializable
        : public Apache::Geode::Client::ISerializable
      {
      public:        
        /// <summary>
        /// return the size of this object in bytes
        /// </summary>
        virtual property System::UInt64 ObjectSize
        {
          virtual System::UInt64 get(); 
        }

        /// <summary>
        /// Return a string representation of the object.
        /// It simply returns the string representation of the underlying
        /// native object by calling its <c>toString()</c> function.
        /// </summary>
        virtual String^ ToString() override;


      internal:
        static std::shared_ptr<CacheableKey> GetNativeCacheableKeyWrapperForManagedISerializable(ISerializable^ managedObject);
				static System::Int32 GetPDXIdForType(native::Pool* pool, ISerializable^ pdxType, Cache^ cache);
				static ISerializable^ GetPDXTypeById(native::Pool* pool, System::Int32 typeId, Cache^ cache);
        
        static int GetEnumValue(Internal::EnumInfo^ ei, Cache^ cache);
        static Internal::EnumInfo^ GetEnum(int val, Cache^ cache);

        // These are the new static methods to get/put data from c++

        //byte
        static Byte getByte(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableByte(Byte val);
        
        //boolean
        static bool getBoolean(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableBoolean(bool val);
        
        //widechar
        static Char getChar(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableWideChar(Char val);
        
        //double
        static double getDouble(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableDouble(double val);
        
        //float
        static float getFloat(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableFloat(float val);
        
        //int16
        static System::Int16 getInt16(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableInt16(int val);
        
        //int32
        static System::Int32 getInt32(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableInt32(System::Int32 val);
        
        //int64
        static System::Int64 getInt64(std::shared_ptr<native::Serializable> nativeptr);
        
        static std::shared_ptr<native::CacheableKey> getCacheableInt64(System::Int64 val);
        
        static String^ getString(std::shared_ptr<native::Serializable> nativeptr);
                
        static std::shared_ptr<native::CacheableString> GetCacheableString(String^ value);

        static array<Byte>^ getSByteArray(array<SByte>^ sArray);
        
        static array<System::Int16>^ getInt16Array(array<System::UInt16>^ sArray);
        
        static array<System::Int32>^ getInt32Array(array<System::UInt32>^ sArray);        

        static array<System::Int64>^ getInt64Array(array<System::UInt64>^ sArray);
        

        /// <summary>
        /// Default constructor.
        /// </summary>
        inline Apache::Geode::Client::Serializable()
        :Serializable(__nullptr) { }

        /// <summary>
        /// Internal constructor to wrap a native object pointer
        /// </summary>
        /// <param name="nativeptr">The native object pointer</param>
        inline Apache::Geode::Client::Serializable(std::shared_ptr<native::Serializable> nativeptr)
        {
          m_nativeptr = gcnew native_shared_ptr<native::Serializable>(nativeptr);
        }

        generic<class TKey>
        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(TKey ky);

        generic<class TKey>
        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(TKey key, bool isAciiChar);

        generic<class TKey>
        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(Type^ managedType, TKey key);

        generic<class TKey>
        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(Type^ managedType, TKey key, bool isAsciiChar);

        static Serializable()
        {
          
        }

        protected:
          native_shared_ptr<native::Serializable>^ m_nativeptr;
      };
    }  // namespace Client
  }  // namespace Geode
}  // namespace Apache