#ifndef BAIDU_RPC_UNREFLECTABLE_MESSAGE_H
#define BAIDU_RPC_UNREFLECTABLE_MESSAGE_H

#include <google/protobuf/message.h>

#if GOOGLE_PROTOBUF_VERSION >= 3007000
#define BAIDU_RPC_USE_UNREFLECTABLE_MESSAGE 1
#else // GOOGLE_PROTOBUF_VERSION < 3007000
#define BAIDU_RPC_USE_UNREFLECTABLE_MESSAGE 0
#endif // GOOGLE_PROTOBUF_VERSION

namespace baidu {
namespace rpc {

#if BAIDU_RPC_USE_UNREFLECTABLE_MESSAGE
// brpc中有部分模拟成Message的类型，用于和非PB协议系统交互
// 提供统一包装成Message的基类，这些类型并不需要依赖PB反射
// 且PB的内部接口变动频繁，这里对反射相关的部分提供空实现
template <typename T>
class UnreflectableMessage : public ::google::protobuf::Message {
public:
    ////////////////////////////////////////////////////////////////////////////
    // Message风格的拷贝和清理机制

    // Message基类要求const Message&函数，不过跨类型Merge基本无意义
    // 这里为了简便统一实现了，子类面向具体类型编程
    virtual void MergeFrom(const T&) {};

    // 清理实例
    void Clear() override {}
    ////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////
    // 用来支持SerializeToXXX，ParseFromXXX函数的底层实现
    // 不需要支持框架序列化的情况下，可以保持默认空实现
    //
    // 序列化分两阶段，递归统计长度，递归序列化
    // 实际序列化时可以假定刚刚调用过ByteSizeLong来统计长度
    // 因此可以在其中进行长度缓存
    // 并在InternalSerializeWithCachedSizesToArray中直接使用

    // 计算序列化后的长度
    size_t ByteSizeLong() const override {
        return 0;
    }

    // 反序列化
#if GOOGLE_PROTOBUF_VERSION >= 3010000
    const char* _InternalParse(const char* ptr,
            ::google::protobuf::internal::ParseContext*) override {
        return ptr;
    }
#else // GOOGLE_PROTOBUF_VERSION < 3010000
    bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream*) override {
        return true;
    }
#endif // GOOGLE_PROTOBUF_VERSION

    // 序列化
#if GOOGLE_PROTOBUF_VERSION >= 3011000
    uint8_t* _InternalSerialize(uint8_t* ptr,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const override {
        return ptr;
    }
#elif GOOGLE_PROTOBUF_VERSION >= 3010000
    uint8_t* InternalSerializeWithCachedSizesToArray(uint8_t* ptr,
            ::google::protobuf::io::EpsCopyOutputStream*) const override {
        return ptr;
    }
#elif GOOGLE_PROTOBUF_VERSION >= 3007000
    void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream*) const override {
    }
    uint8_t* InternalSerializeWithCachedSizesToArray(uint8_t* target) const override {
        return target;
    }
#endif // GOOGLE_PROTOBUF_VERSION
    ////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////
    // 重新放开拷贝构造和赋值能力
    inline UnreflectableMessage() = default;
    inline UnreflectableMessage(const UnreflectableMessage&) : UnreflectableMessage() {
    }
    inline UnreflectableMessage& operator=(const UnreflectableMessage& other) {
        CopyFrom(other);
        return *this;
    }
    inline UnreflectableMessage& operator=(const T& other) {
        CopyFrom(other);
        return *this;
    }
    ////////////////////////////////////////////////////////////////////////////

    // 反射获得类型名，不支持
    ::std::string GetTypeName() const override {
        return "";
    }

    // 从default_instance构造Message，支持
#if GOOGLE_PROTOBUF_VERSION >= 3019000
    Message* New(::google::protobuf::Arena* arena) const override {
        return ::google::protobuf::Arena::Create<T>(arena);
    }
#else
    Message* New() const override {
        return new T();
    }
#endif
    
    // required缺失判断，不支持
    bool IsInitialized() const override {
        return true;
    }

    // required field缺失详细信息，不支持
    std::string InitializationErrorString() const override {
        return "unknown error";
    }
    
    // 类型校验转换，并调用明确子类的MergeFrom
    void MergeFrom(const ::google::protobuf::Message& other) override {
        if (&other == this) return;
#if GOOGLE_PROTOBUF_VERSION >= 3007000
        const T* same_type_other = ::google::protobuf::DynamicCastToGenerated<T>(&other);
#elif GOOGLE_PROTOBUF_VERSION >= 3000000
        const T* same_type_other = ::google::protobuf::internal::DynamicCastToGenerated<const T>(&other);
#endif // GOOGLE_PROTOBUF_VERSION
        if (same_type_other != nullptr) {
            MergeFrom(*same_type_other);
        } else {
            Message::MergeFrom(other);
        }
    }

    // 依赖MergeFrom实现
    inline void CopyFrom(const UnreflectableMessage& other) {
        Clear();
        MergeFrom(other);
    }

#if GOOGLE_PROTOBUF_VERSION < 3019000
    // 依赖MergeFrom实现
    void CopyFrom(const ::google::protobuf::Message& other) override {
        Clear();
        MergeFrom(other);
    }

    // 清除unknown field，不支持
    void DiscardUnknownFields() override {}
#endif

    // 内存结构用量，不支持
    size_t SpaceUsedLong() const override {
        return 0;
    }

    // 反射信息，返回无意义Metadata，除了
    // descriptor和reflection可以通过同一性来辨识类型
    ::google::protobuf::Metadata GetMetadata() const override {
        ::google::protobuf::Metadata metadata;
        metadata.descriptor = reinterpret_cast<const ::google::protobuf::Descriptor*>(&_instance);
        metadata.reflection = reinterpret_cast<const ::google::protobuf::Reflection*>(&_instance);
        return metadata;
    }

#if GOOGLE_PROTOBUF_VERSION < 4025000
    // 反射体系使用的获取和设置长度缓存的函数，非反射版本无需关心
    void SetCachedSize(int) const override {
    }

    // 反射体系使用的获取和设置长度缓存的函数，非反射版本无需关心
    int GetCachedSize() const override {
        return 0;
    }
#endif // GOOGLE_PROTOBUF_VERSION < 4025000

    // 仅能用来进行同一性辨识的descriptor
    inline static const ::google::protobuf::Descriptor* descriptor() noexcept {
        return default_instance().GetMetadata().descriptor;
    }

    // 仅能用来进行New构造的default_instance
    // 在静态初始化以外的场景，可以作为合法空实例使用
    inline static const T& default_instance() noexcept {
        return _instance;
    }

private:
    static T _instance;
};

template <typename T>
T UnreflectableMessage<T>::_instance;
#endif // BAIDU_RPC_USE_UNREFLECTABLE_MESSAGE

}
}

#endif // BAIDU_RPC_UNREFLECTABLE_MESSAGE_H