#include "pch.hpp"
#include "entCache.h"
#include <exceptions.h>
#include "lockHelpers.h"
#include <pwd.h>
#include <grp.h>

template<class entry_t>
EntCache<entry_t>::EntCache() :
	fillTime(0)
{
}

template<class entry_t>
EntCache<entry_t>::~EntCache()
{
}

template<class entry_t>
const typename EntCache<entry_t>::id_t &
EntCache<entry_t>::getID(const EntCache<entry_t>::name_t & u) const
{
	return getEntry(u)->id;
}

template<class entry_t>
const typename EntCache<entry_t>::name_t &
EntCache<entry_t>::getName(const EntCache<entry_t>::id_t & u) const
{
	return getEntry(u)->name;
}

template<class entry_t>
template<class key_t>
typename EntCache<entry_t>::entry_ptr
EntCache<entry_t>::getEntry(const key_t & key) const
{
	typename EntCache<entry_t>::entry_ptr ent;
	if (fillTime + 60 > time(NULL)) {
		ent = getEntryNoFill<key_t>(key);
	}
	if (!ent) {
		fillCache();
		ent = getEntryNoFill<key_t>(key);
	}
	if (!ent) {
		throw NetFS::SystemError(EPERM);
	}
	return ent;
}

template<class entry_t>
template<class key_t>
typename EntCache<entry_t>::entry_ptr
EntCache<entry_t>::getEntryNoFill(const key_t & key) const
{
	SharedLock(lock);
	auto & collection = idcache.template get<key_t>();
	auto i = collection.find(key);
	if (i != collection.end()) {
		return *i;
	}
	return NULL;
}

User::User(uid_t u, const std::string & n, gid_t g) :
	id(u),
	name(n),
	group(g)
{
}

const int BUFLEN = 8196;

template<>
void
EntCache<User>::fillCache() const
{
	Lock(lock);
	setpwent();
	idcache.clear();
	char buf[BUFLEN];
	struct passwd pwbuf, * pwp;
	while (getpwent_r(&pwbuf, buf, BUFLEN, &pwp) == 0) {
		idcache.insert(new User(pwp->pw_uid, pwp->pw_name, pwp->pw_gid));
	}
	endpwent();
	time(&fillTime);
}

Group::Group(gid_t g, const std::string & n) :
	id(g),
	name(n)
{
}

template<>
void
EntCache<Group>::fillCache() const
{
	Lock(lock);
	setgrent();
	char buf[BUFLEN];
	idcache.clear();
	struct group grpbuf, * grp;
	while (getgrent_r(&grpbuf, buf, BUFLEN, &grp) == 0) {
		auto g = new Group(grp->gr_gid, grp->gr_name);
		for (auto member = grp->gr_mem; *member; member++) {
			try {
				g->members.insert(EntCache<User>::instance.getID(*member));
			}
			catch (const NetFS::SystemError &) {
			}
		}
		idcache.insert(g);
	}
	endgrent();
	time(&fillTime);
}

bool
Group::hasMember(uid_t u) const
{
	return (members.find(u) != members.end());
}

template<class T> const EntCache<T> EntCache<T>::instance;
template class EntCache<User>;
template class EntCache<Group>;