#include "cppc4group.hpp"

#include "cc4group.h"

CppC4Group::Data::Data() : data{nullptr}, size{0}
{

}

CppC4Group::Data::Data(const void* const data, const size_t size) : data{data}, size{size}
{

}

struct CppC4Group::Private {
	CC4Group* g;

	Private() : g{cc4group.new_()}
	{

	}

	~Private()
	{
		cc4group.delete_(g);
	}
};

namespace {
	CC4Group_TmpMemoryStrategy convertTmpMemoryStrategy(const CppC4Group::TmpMemoryStrategy strategy)
	{
		switch(strategy)
		{
			case CppC4Group::Auto:
				return cc4group.TmpMemoryStrategies.Auto;
			case CppC4Group::File:
				return cc4group.TmpMemoryStrategies.File;
			case CppC4Group::Memory:
				return cc4group.TmpMemoryStrategies.Memory;
		}
		return cc4group.TmpMemoryStrategies.Auto;
	}

	int convertMemoryManagement(const CppC4Group::MemoryManagement management)
	{
		switch(management)
		{
			case CppC4Group::Take:
				return cc4group.MemoryManagement.Take;
			case CppC4Group::Copy:
				return cc4group.MemoryManagement.Copy;
			case CppC4Group::Reference:
				return cc4group.MemoryManagement.Reference;
		}
		return cc4group.MemoryManagement.Copy;
	}
}

CppC4Group::CppC4Group() : p{new CppC4Group::Private{}}
{

}

CppC4Group::~CppC4Group()
{

}

void CppC4Group::create()
{
	cc4group.create(p->g);
}

bool CppC4Group::openExisting(const std::string& path)
{
	return cc4group.openExisting(p->g, path.c_str());
}

bool CppC4Group::save(const std::string& path, const bool overwrite)
{
	return (overwrite ? cc4group.saveOverwrite : cc4group.save)(p->g, path.c_str());
}

bool CppC4Group::extractAll(const std::string& path)
{
	return cc4group.extractAll(p->g, path.c_str());
}

bool CppC4Group::extractSingle(const std::string& entryPath, const std::string& targetPath)
{
	return cc4group.extractSingle(p->g, entryPath.c_str(), targetPath.c_str());
}

std::optional<CppC4Group::Data> CppC4Group::getEntryData(const std::string& path)
{
	const void* data;
	size_t size;
	if(cc4group.getEntryData(p->g, path.c_str(), &data, &size))
	{
		return std::make_optional<CppC4Group::Data>(data, size);
	}
	else
	{
		return {};
	}
}

std::string CppC4Group::getErrorMessage()
{
	return cc4group.getErrorMessage(p->g);
}

int32_t CppC4Group::getErrorCode()
{
	return cc4group.getErrorCode(p->g);
}

std::string CppC4Group::getErrorMethod()
{
	return cc4group.getErrorMethod(p->g);
}

std::string CppC4Group::getErrorCauser()
{
	return cc4group.getErrorCauser(p->g);
}

void CppC4Group::setTmpMemoryStrategy(const CppC4Group::TmpMemoryStrategy strategy)
{
	cc4group.setTmpMemoryStrategy(convertTmpMemoryStrategy(strategy));
}

bool CppC4Group::setMaker(const std::string& maker, const std::string& path, const bool recursive)
{
	return cc4group.setMaker(p->g, maker.c_str(), path.c_str(), recursive);
}

bool CppC4Group::setCreation(const int32_t creation, const std::string& path, const bool recursive)
{
	return cc4group.setCreation(p->g, creation, path.c_str(), recursive);
}

bool CppC4Group::setOfficial(const bool official, const std::string& path, const bool recursive)
{
	return cc4group.setOfficial(p->g, official, path.c_str(), recursive);
}

bool CppC4Group::setExecutable(const bool executable, const std::string& path)
{
	return cc4group.setExecutable(p->g, executable, path.c_str());
}

namespace {
	CppC4Group::EntryInfo& fillEntryInfo(CppC4Group::EntryInfo& info, const CC4Group_EntryInfo& entryInfo)
	{
		info.fileName = entryInfo.fileName;
		info.modified = entryInfo.modified;
		info.author = entryInfo.author;
		info.size = entryInfo.size;
		info.totalSize = entryInfo.totalSize;
		info.executable = entryInfo.executable;
		info.directory = entryInfo.directory;
		info.official = entryInfo.official;

		return info;
	}
};

std::optional<CppC4Group::EntryInfo> CppC4Group::getEntryInfo(const std::string& path)
{
	CC4Group_EntryInfo info;
	if(cc4group.getEntryInfo(p->g, path.c_str(), &info))
	{
		auto entryInfo = std::make_optional<CppC4Group::EntryInfo>();
		fillEntryInfo(*entryInfo, info);
		return entryInfo;
	}
	else
	{
		return {};
	}
}

std::optional<std::vector<CppC4Group::EntryInfo>> CppC4Group::getEntryInfos(const std::string& path)
{
	CC4Group_EntryInfo* infos;
	size_t infoCount;

	if(cc4group.getEntryInfos(p->g, path.c_str(), &infos, &infoCount))
	{
		auto entryInfos = std::make_optional<std::vector<CppC4Group::EntryInfo>>(infoCount);

		for(size_t i = 0; i < infoCount; ++i)
		{
			fillEntryInfo((*entryInfos)[i], infos[i]);
		}

		free(infos);

		return entryInfos;
	}
	else
	{
		return {};
	}
}

bool CppC4Group::deleteEntry(const std::string& path, const bool recursive)
{
	return cc4group.deleteEntry(p->g, path.c_str(), recursive);
}

bool CppC4Group::renameEntry(const std::string& oldPath, const std::string& newPath)
{
	return cc4group.renameEntry(p->g, oldPath.c_str(), newPath.c_str());
}

bool CppC4Group::createDirectory(const std::string& path)
{
	return cc4group.createDirectory(p->g, path.c_str());
}

bool CppC4Group::createFile(const std::string& path)
{
	return cc4group.createFile(p->g, path.c_str());
}

bool CppC4Group::setEntryData(const std::__cxx11::string& path, const void*const data, const size_t size, const MemoryManagement management)
{
	return cc4group.setEntryData(p->g, path.c_str(), data, size, convertMemoryManagement(management));
}