#ifndef BASE64_HELPER_HPP
#define BASE64_HELPER_HPP
#include <fstream>
#include <iostream>
using std::numeric_limits;
using std::streamsize;
constexpr size_t MAX_STREAM_SIZE = numeric_limits<streamsize>::max();

inline const size_t& SizeOfFile(const char* fileName) 
{
	std::fstream MyFile(fileName, std::ios::in | std::ios::binary | std::ios::ate);
	std::streampos Sizer;

	if (MyFile.is_open())
	{
		Sizer = MyFile.tellg();
		const size_t size = Sizer;
		MyFile.close();

		return size;
	}
	else
	{
		std::cerr << "Unable to open file: " << fileName;
		return 0;
	}
}


inline char* ReadTextFromFile(const char* fileName, char* buffer)
{
	std::ifstream File(fileName);

	if (!File.is_open())
	{
		std::cerr << "Unable to open file for reading: " << fileName;
	}

	File >> buffer;
	File.close();

	return buffer;
}

inline char* ReadFileAsBinary(const char* fileName, char* buffer, const size_t& size)
{
	try
	{

		std::fstream File(fileName,std::ios::in| std::ios::binary);

		if (!File.is_open())
		{
			std::cerr << "Could not open file for binary input: " << fileName;
			return buffer;
		}
		
		delete[] buffer;
		buffer = nullptr;

		buffer = new char[size];
		File.read(buffer, size);
		File.close();
		return buffer;
	}
	catch (const std::exception& ex)
	{
		std::cerr << "Exception during binary file input. " << fileName
			<< " was not successfully streamed to binary. " <<
			ex.what();
		return nullptr;
	}
}

inline bool WriteFileFromBinary(const char* fileName, const char* buffer, std::string fileContents)
{
	try
	{
		std::fstream File(fileName, std::ios::binary | std::ios::out);
		
		if (!File.is_open())
		{
			std::cerr << "Could not open file for binary output: " << fileName;
		}
		
		buffer = nullptr;
		buffer = fileContents.c_str();
		size_t NewSize = fileContents.size() - 1;
		File.write(buffer, NewSize);
		File.close();
		
		return true;
	}
	catch (const std::exception& ex)
	{
		std::cerr << "Exception during binary file input. " << fileName
			<< " was not successfully streamed to binary. " <<
			ex.what();
	}
	

	return false;
}

inline bool WriteTextToFile(const char* fileName, std::string fileContents)
{
	std::ofstream File(fileName);


	if (!File.is_open())
	{
		std::cerr << "Unable to open the file: " << fileName << std::endl;
		return false;
	}
	File << fileContents;

	File.close();

	return false;
}

inline void Prompts(const char* Prompt)
{
	std::cout << Prompt;
}

inline const char* InputFileName(const char* Prompt)
{
	
	char* FileName = nullptr;
	FileName = new char[101];

	Prompts(Prompt);

	std::cout.flush();

	std::cin >> FileName;

	while (!std::cin)
	{
		std::cout << Prompt << std::endl;
		std::cin.clear();

		std::cin.ignore(MAX_STREAM_SIZE, '\n');
		std::cin >> FileName;

	}

	return FileName;
}


#endif