#define SOL_ALL_SAFETIES_ON 1
#include <sol/sol.hpp>

#include <vector>
#include <numeric>

#include <iostream>

class number_storage {
private:
	std::vector<int> data;

public:
	number_storage(int i) {
		data.push_back(i);
	}

	int accumulate() const {
		return std::accumulate(data.begin(), data.end(), 0);
	}

public:
	using value_type = decltype(data)::value_type;
	using iterator = decltype(data)::iterator;
	using size_type = decltype(data)::size_type;
	iterator begin() {
		return iterator(data.begin());
	}
	iterator end() {
		return iterator(data.end());
	}
	size_type size() const noexcept {
		return data.size();
	}
	size_type max_size() const noexcept {
		return data.max_size();
	}
	void push_back(int value) {
		data.push_back(value);
	}
	bool empty() const noexcept {
		return data.empty();
	}
};

namespace sol {
	template <>
	struct is_container<number_storage> : std::false_type { };
} // namespace sol

int main(int, char*[]) {
	std::cout << "=== container as container ===" << std::endl;

	sol::state lua;
	lua.open_libraries(sol::lib::base);

	lua.new_usertype<number_storage>("number_storage",
	     sol::constructors<number_storage(int)>(),
	     "accumulate",
	     &number_storage::accumulate,
	     "iterable",
	     [](number_storage& ns) {
		     return sol::as_container(
		          ns); // treat like a container, despite
		               // is_container specialization
	     });

	lua.script(R"(
ns = number_storage.new(23)
print("accumulate before:", ns:accumulate())

-- reference original usertype like a container
ns_container = ns:iterable()
ns_container:add(24)
ns_container:add(25)

-- now print to show effect
print("accumulate after :", ns:accumulate())
	)");

	number_storage& ns = lua["ns"];
	number_storage& ns_container = lua["ns_container"];
	sol_c_assert(&ns == &ns_container);
	sol_c_assert(ns.size() == 3);

	std::cout << std::endl;

	return 0;
}
