#include <iostream>
#include "helpers.hpp"
#include "Base64Converter.hpp"

/*
constexpr short ARG_COUNT = 4;

bool Worker();
bool Worker(char** argv);


int main(const int argc, char* argv[])
{
	if (argc == ARG_COUNT)
	{
		//RUN THE COMMAND LINE VERSION
		Worker(argv);
	}
	//RUN THE CONSOLE APP VERSION
	return Worker();
}

bool Worker()
{
	return false;
}

bool Worker(char** argv)
{
	const char* arg1 = argv[1]; //-e -d
	const char* arg2 = argv[2];
	const char* arg3 = argv[3];

	const char option = std::tolower(arg1[1]); //e or d
	char* buffer = nullptr;

	try {
		switch (option)
		{
		case 'e':
		{
			size_t size = 1;
			buffer = ReadFileAsBinary("FindingPi.exe", buffer, size);

			char* encodedBuffer = Base64Encode(buffer, size);

			bool success = WriteTextToFile(arg3, encodedBuffer);

			delete[] buffer;
			delete[] encodedBuffer;

			return success;
		}
		case 'd':
		{
			size_t size = 0;
			buffer = ReadTextFromFile(arg2, buffer);

			size_t decodedSize = 0;
			char* decodedBuffer = Base64Decode(buffer, decodedSize);
			bool success = WriteFileFromBinary(arg3, decodedBuffer, decodedSize);
			delete[] buffer;
			delete[] decodedBuffer;

			return success;
		}
		default:
			std::cerr << "Invalid command option\n" <<
				"Valid commands:\n" <<
				"\t-e source_file.exe destination_file.exe" <<
				"\t\tEncodes file in source into text in destination txt file." <<
				"\t-d source_file.txt destination_file.exe" <<
				"\t\tDecodes text in source file into the destination file.\n\n";

			return false;
		}

	} catch (const std::exception& ex) {
			std::cerr << "Exception: " << ex.what() << std::endl;
			delete[] buffer;
			return false;
	}
}
*/

void displayMenu() {
    std::cout << "\nWelcome to the Base64 Encoder/Decoder:\n";
    std::cout << "1. Encode\n";
    std::cout << "2. Decode\n";
    std::cout << "3. Exit\n";
}

int main() {
    char choice;
    bool exitProgram = false;

    do {
        displayMenu();
        std::cout << "\nEnter your choice: ";
        std::cin >> choice;

        switch (choice) {
        case '1': {
            std::string sourceFile, destinationFile;
            std::cout << "Enter source file name: ";
            std::cin >> sourceFile;
            std::cout << "Enter destination file name: ";
            std::cin >> destinationFile;

            size_t size = 1;
            char* buffer = nullptr;
            buffer = ReadFileAsBinary(sourceFile.c_str(), buffer, size);

            if (buffer) {
                char* encodedBuffer = Base64Encode(buffer, size);
                if (encodedBuffer) {
                    bool success = WriteTextToFile(destinationFile.c_str(), encodedBuffer);
                    delete[] encodedBuffer;
                    if (success)
                        std::cout << "File encoded successfully.\n";
                    else
                        std::cerr << "Error: Unable to write to destination file.\n";
                }
                else {
                    std::cerr << "Error: Unable to encode file.\n";
                }
                delete[] buffer;
            }
            else {
                std::cerr << "Error: Unable to read from source file.\n";
            }
            break;
        }
        case '2': {
            std::string sourceFile, destinationFile;
            std::cout << "Enter source file name: ";
            std::cin >> sourceFile;
            std::cout << "Enter destination file name: ";
            std::cin >> destinationFile;

            size_t size = 0;
            char* buffer = nullptr;
            buffer = ReadTextFromFile(sourceFile.c_str(), buffer);

            if (buffer) {
                size_t decodedSize = 0;
                char* decodedBuffer = Base64Decode(buffer, decodedSize);
                if (decodedBuffer) {
                    bool success = WriteFileFromBinary(destinationFile.c_str(), decodedBuffer, decodedSize);
                    delete[] decodedBuffer;
                    if (success)
                        std::cout << "File decoded successfully.\n";
                    else
                        std::cerr << "Error: Unable to write to destination file.\n";
                }
                else {
                    std::cerr << "Error: Unable to decode file.\n";
                }
                delete[] buffer;
            }
            else {
                std::cerr << "Error: Unable to read from source file.\n";
            }
            break;
        }
        case '3':
            std::cout << "Thank you for using the Base64 Encoder/Decoder! Goodbye.\n";
            exitProgram = true;
            break;
        default:
            std::cout << "Invalid choice. Please try again.\n";
        }
    } while (!exitProgram);

    return 0;
}