//
// Created by ps on 8/9/18.
//

#ifndef SYNCDBTOOL_SHAREMEMORYTOOL_HPP
#define SYNCDBTOOL_SHAREMEMORYTOOL_HPP


#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <mutex>
#include <iostream>

//#include "SyncDB.hpp"

namespace BISTL {

    using boost::interprocess::managed_shared_memory;
    using boost::interprocess::shared_memory_object;
    using boost::interprocess::create_only;
    using boost::interprocess::open_only;
    using boost::interprocess::open_read_only;
    using boost::interprocess::open_or_create;
    using boost::interprocess::open_copy_on_write;

    using boost::interprocess::allocator;
    //DataType
    using boost::interprocess::basic_string;
    using boost::interprocess::vector;
    using boost::interprocess::map;

    typedef managed_shared_memory::segment_manager segment_manager_t;

    typedef allocator<void, segment_manager_t> void_allocator;

    //vector<int>
    typedef allocator<int, segment_manager_t> int_allocator;
    typedef vector<int, int_allocator> int_vector;

    //vector<vector<int>>
    typedef allocator<int_vector, segment_manager_t> int_vector_allocator;
    typedef vector<int_vector, int_vector_allocator> int_vector_vector;

    //std::string
    typedef allocator<char, segment_manager_t> char_allocator;
    typedef basic_string<char, std::char_traits<char>, char_allocator> char_string;

    typedef std::lock_guard<std::mutex> LockG;

    /***
     * 创建共享内存
     * @param shm_Name 名称
     * @param size 大小
     * @param type 类型
     * @return managed_shared_memory
     */
    static managed_shared_memory
    createSHM(std::string &message, std::string shm_Name, std::size_t size = 4096, int type = 1) {
        try {
            switch (type) {
                case 1:
                    return managed_shared_memory(create_only, shm_Name.c_str(), size * 1024);
                case 2:
                    return managed_shared_memory(open_only, shm_Name.c_str());
                case 3:
                    return managed_shared_memory(open_read_only, shm_Name.c_str());
                case 4:
                    return managed_shared_memory(open_or_create, shm_Name.c_str(), size * 1024);
                case 5:
                    return managed_shared_memory(open_copy_on_write, shm_Name.c_str());
                default:
                    //ERR
                    message = "type is error ";
//                    return managed_shared_memory(create_only, shm_Name.c_str(), size);
            }
        } catch (std::exception ex) {
            message = ex.what();
        }
//        return ;
    }

    //shanchu shm
    /***
     * 删除共享内存
     * @param shm_Name 名称
     * @return 状态
     */
    static bool removeSHM(std::string shm_Name) {
        return shared_memory_object::remove(shm_Name.c_str());
    }

    struct Feature_Info {
    public:
        Feature_Info(const char *id, const char *feature, const char *create_by,
                     const char *create_time, const char *update_time,
                     const void_allocator &void_alloc) :
            m_id(id, void_alloc), m_feature(feature, void_alloc), m_create_by(create_by, void_alloc),
            m_create_time(create_time, void_alloc), m_update_time(update_time, void_alloc) {}

        ~Feature_Info() {}

        char_string m_id;
        char_string m_feature;
        char_string m_create_by;
        char_string m_create_time;
        char_string m_update_time;
    };

    //vector<Feature_Info>
    typedef allocator<Feature_Info, segment_manager_t> Feature_Info_allocator;
    typedef vector<Feature_Info, Feature_Info_allocator> Feature_Info_vector;

    //map<string,Feature_Info>
    typedef char_string KeyType;
    typedef Feature_Info MappedType;
    typedef std::pair<const KeyType, MappedType> ValueType;
    typedef allocator<ValueType, segment_manager_t> ShmemAllocator;
    typedef map<KeyType, MappedType, std::less<char_string>, ShmemAllocator> bi_map_Feature_Info;

    //无用
    template<class T>
    class BiMapData {
    public:
        BiMapData(std::string shm_Name, std::size_t size)
            : m_shm_Name(shm_Name), m_size(size * 1024), m_segment(open_or_create, m_shm_Name.c_str(), m_size),
              m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
            createMap();
        }

        BiMapData(std::string shm_Name)
            : m_shm_Name(shm_Name), m_size(10 * 1024), m_segment(open_only, m_shm_Name.c_str()),
              m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
        }

        virtual ~BiMapData() {

        }

        const BISTL::void_allocator *getVoid_allocator() {
            return &m_alloc_inst;
        }

        const T *getMap() {
            return mymap;
        }

    private:
        void createMap() {
            mymap = m_segment.find_or_construct<T>(m_shm_Name.c_str())(
                std::less<char_string>(), m_alloc_inst);
        }

    private:
        std::string m_shm_Name;
        std::size_t m_size;
        managed_shared_memory m_segment;

        void_allocator m_alloc_inst;

        T *mymap;
        std::mutex m_mutex;
    };


    class BiMapFeaData {
    public:
        /***
         * 打开或创建共享内存
         * @param shm_Name 名称
         * @param size 大小
         */
        BiMapFeaData(std::string shm_Name, std::size_t size)
            : m_shm_Name(shm_Name), m_size(size * 1024), m_segment(open_or_create, m_shm_Name.c_str(), m_size),
              m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
            createMap_Feature_Info();
            std::cout << m_segment.get_free_memory() << std::endl;
            std::cout << m_shm_Name.c_str() << std::endl;
        }

        /***
         * 打开共享内存
         * @param shm_Name 名称
         */
        BiMapFeaData(std::string shm_Name)
            : m_shm_Name(shm_Name), m_size(10 * 1024), m_segment(open_only, m_shm_Name.c_str()),
              m_alloc_inst(m_segment.get_segment_manager()), mymap(nullptr) {
            createMap_Feature_Info();
            std::cout << m_segment.get_free_memory() << std::endl;
            std::cout << m_shm_Name.c_str() << std::endl;
        }

        virtual ~BiMapFeaData() {

        }

        /***
         * 获取一个能够转换为任何allocator<T, segment_manager_t>类型的allocator
         * @return
         */
        const BISTL::void_allocator *getVoid_allocator() {
            return &m_alloc_inst;
        }

        /***
         * 返回map地址
         * @return
         */
        const BISTL::bi_map_Feature_Info *getMap() {
            return mymap;
        }

        /***
         * 封装value的初始化操作
         * @param id
         * @param feature
         * @param create_by
         * @param create_time
         * @param update_time
         * @return
         */
        bool saveKeyOrValue(std::string id, std::string feature, std::string create_by, std::string create_time,
                            std::string update_time) {
            Feature_Info v(id.c_str(), feature.c_str(), create_by.c_str(),
                           create_time.c_str(), update_time.c_str(), m_alloc_inst);
            char_string key_object(id.c_str(), m_alloc_inst);
            LockG lock(m_mutex);
            auto item = mymap->insert(ValueType(key_object, v));
            return item.second;
        }


    private:
        /***
         * 创建相应类型的map
         */
        void createMap_Feature_Info() {
            mymap = m_segment.find_or_construct<bi_map_Feature_Info>(m_shm_Name.c_str())(
                std::less<char_string>(), m_alloc_inst);
        }


    private:
        std::string m_shm_Name;
        std::size_t m_size;
        managed_shared_memory m_segment;

        void_allocator m_alloc_inst;

        bi_map_Feature_Info *mymap;
        std::mutex m_mutex;
    };


}

#endif //SYNCDBTOOL_SHAREMEMORYTOOL_HPP