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

namespace bip = boost::interprocess;
typedef bip::allocator<wchar_t, bip::managed_shared_memory::segment_manager> CharAllocator;
typedef bip::basic_string<wchar_t, std::char_traits<wchar_t>, CharAllocator> MyShmString;

class InnerData {
public:
	uint64_t id;
	MyShmString name;
	uint8_t status;
	static const uint8_t defaultStatus = 3;

	InnerData(CharAllocator cAlloc) :name(cAlloc) {}
};

typedef bip::allocator<InnerData, bip::managed_shared_memory::segment_manager> InnerDataAllocator;
typedef  bip::vector<InnerData, InnerDataAllocator> InnerDataVector;
class SharedData {
public:
	int a;
	InnerDataVector data;
	SharedData(InnerDataAllocator eAlloc) :data(eAlloc) {}
};

class UsualInnerData {//like InnerData but with normal std::wstring
public:
	uint64_t id;
	std::wstring name;
	uint8_t status;
	static const uint8_t defaultStatus = 3;
};

class Zone {
public:
	SharedData * sharedData;

	CharAllocator     charAllocator;
	InnerDataAllocator   innerDataAllocator;

	static bool alreadyCreated; //use for verification at creation, Zone is a singleton

	static Zone createNewZone(const std::string &_name, const std::string &_nameSeg);
	Zone(CharAllocator _charAllocator, InnerDataAllocator _innerDataAllocator, SharedData* _sharedData);
	void putInShm(const std::vector<UsualInnerData> &in);
	static void deleteZone(const std::string &_name);
};
bool Zone::alreadyCreated = false;


Zone Zone::createNewZone(const std::string &_name, const std::string &_nameSeg) {
	int size = 10000;
	bip::managed_shared_memory shm(bip::create_only, _name.c_str(), 10000 + size);
	CharAllocator charAllocator(shm.get_segment_manager());
	InnerDataAllocator innerDataAllocator(shm.get_segment_manager());
	SharedData * sharedData = shm.construct<SharedData>(_nameSeg.c_str())(innerDataAllocator);
	alreadyCreated = true;
	Zone ret(charAllocator, innerDataAllocator, sharedData); //Here, SharedData points to allocated memory, good. But as soon as we return from this function, it's deallocated
	return ret;
}

Zone::Zone(CharAllocator _charAllocator, InnerDataAllocator _innerDataAllocator, SharedData* _sharedData) :
	charAllocator(_charAllocator),
	innerDataAllocator(_innerDataAllocator),
	sharedData(_sharedData)
{}

void Zone::putInShm(const std::vector<UsualInnerData> &in) {
	InnerData newInnerData(charAllocator);
	MyShmString newShmString(charAllocator);
	for (auto a : in) {
		newInnerData.id = a.id;
		newShmString = a.name.c_str();//Here I get an access violation, which means charAllocator is bad ? -> "Exception thrown: read access violation. this was 0xE0008."
		newInnerData.name = newShmString;
		sharedData->data.push_back(newInnerData);
	}
	return;
}
void Zone::deleteZone(const std::string &_name) {
	bip::shared_memory_object::remove(_name.c_str());
	return;
}

int main() {
	std::string name = "Name";
	std::string segName = "SegName";
	Zone zone = Zone::createNewZone(name, segName);

	UsualInnerData usualInnerData;
	usualInnerData.id = 12;
	usualInnerData.name = L"usualInnerData Name";
	usualInnerData.status = UsualInnerData::defaultStatus;

	std::vector<UsualInnerData> dataToSend;
	dataToSend.push_back(usualInnerData);

	zone.putInShm(dataToSend);
	return 1;


}