#ifndef FORTUNA_POOL_H
#define FORTUNA_POOL_H

#include "util.h"

#include <fmt/core.h>
#include <stdexcept>

namespace fortuna {
namespace accumulator {

class Pool {
public:
	Pool() noexcept {};
	Pool(const Pool& pool) = delete; // no copy
	~Pool() noexcept = default;

	// TODO(me): this public setter should be fixed?
	auto set_id(unsigned int id) -> void {
		pool_id = id;
	}

	auto get_id() const -> unsigned int;

	auto initialize_pool(unsigned int id) -> void {
		set_id(id);
	}

	// add entropy contained in a random event of 1 to 32 bytes
	auto add_entropy(const uint source, const std::vector<char> &event) -> int {
		std::string event_str;
		const size_t event_size{event.size()};

		try {
			if (source < 0 || source > 255) {
				throw std::invalid_argument("source number outside of interval <0,255>\n");
			}
			if (event_size < 1 || event_size > 32) {
				throw std::invalid_argument("the length of the event needs to be from the interval <1,32>\n");
			}
		} catch(const std::exception& e) {
			fmt::print("{}", e.what());
		}

		try {
			event_str = std::string(event.begin(), event.end());
		} catch(const std::exception& e) {
			fmt::print("{}", e.what());
		}

		try {
			std::string digest(fortuna::Util::do_sha(event_str));
			size += event_size;
			append_s(digest);
			digest.clear();
		} catch(const std::exception& e) {
			fmt::print("{}", e.what());
		}

		return 0;
	}

	auto get_s_length() const -> uint64_t {
		// returns total length of entropy contained in this pool
		return this->s.length();
	}

	auto get_s() const -> std::string {
		return this->s;
	}

	auto clear_pool() -> void {
		this->s.clear();
	}

protected:
	auto append_s(const std::string& entropy_s) -> void {
		try {
			(this->s).append(std::string(entropy_s));
		} catch(const std::exception& e) {
			fmt::print("{}", e.what());
		}
	}

private:
	unsigned int pool_id{0};
	std::string s{""};
	uint64_t size{0};

}; // class Pool

} //namespace accumulator
} //namespace fortuna

#endif//FORTUNA_POOL_H