platform_utils.cpp

#include "platform_utils.h"
#include "logging.h"
#include <iostream>
#include <filesystem>

// Platform-specific includes
#ifdef _WIN32
#include <conio.h>
#include <windows.h>
#include <cstdlib>
#elif __linux__
#include <unistd.h>
#include <termios.h>
#include <sys/select.h>
#include <pwd.h>
#endif

namespace PlatformUtils {

    const int KEY_UP = 1000;
    const int KEY_DOWN = 1001;
    const int KEY_ENTER = 10;

    std::string getDocumentsPath() {
#ifdef _WIN32
        // Windows implementation - your existing code
        char* homeDirCStr = nullptr;
        size_t len = 0;
        if (_dupenv_s(&homeDirCStr, &len, "USERPROFILE") == 0 && homeDirCStr) {
            std::string documentsPath = std::string(homeDirCStr) + "\\Documents";
            free(homeDirCStr);  // Important: free the memory allocated by _dupenv_s
            return documentsPath;
        }
        return "";  // Return empty string on error

#elif __linux__
        // Linux implementation
        const char* homeDir = getenv("HOME");
		dbg(LOG_NOTE, "Detected HOME environment variable as: " + std::string(homeDir ? homeDir : "NULL"));
        if (homeDir) {
            // On most Linux distributions, Documents is in the home directory
            std::string documentsPath = std::string(homeDir) + "/Documents";

            // Check if Documents directory exists, if not, fall back to home directory
            if (std::filesystem::exists(documentsPath)) {
                return documentsPath;
            }
            else {
                // Some systems might not have a Documents folder, so return home directory
				dbg(LOG_NOTE, "Documents directory does not exist, falling back to home directory.");
                return std::string(homeDir);
            }
        }

        // Fallback: try to get user info from password database
        struct passwd* pw = getpwuid(getuid());
        if (pw && pw->pw_dir) {
            std::string documentsPath = std::string(pw->pw_dir) + "/Documents";
            if (std::filesystem::exists(documentsPath)) {
                return documentsPath;
            }
            return std::string(pw->pw_dir);
        }

        return "";  // Return empty string if all methods fail
#else
#error "Unsupported platform"
#endif
    }

    int getch() {
#ifdef _WIN32
        // Windows implementation - use the existing conio.h function
        int c = _getch();
        if (c == 72) {  // Up arrow
            return KEY_UP;
        }
        else if (c == 80) {  // Down arrow
            return KEY_DOWN;
        }
        else if (c == 13) {  // Enter key
            return KEY_ENTER;
		}
        return c;

#elif __linux__
        struct termios oldTermios, newTermios;
        int ch;

        tcgetattr(STDIN_FILENO, &oldTermios);
        newTermios = oldTermios;
        newTermios.c_lflag &= ~(ICANON | ECHO);
        tcsetattr(STDIN_FILENO, TCSANOW, &newTermios);

        ch = getchar();

        // Handle arrow keys: ESC[A (up) and ESC[B (down)
        if (ch == 27) {  // ESC character
            getchar(); // consume '['
            int arrow = getchar();
            if (arrow == 65) {  // 'A' - up arrow
                ch = KEY_UP;
            }
            else if (arrow == 66) {  // 'B' - down arrow  
                ch = KEY_DOWN;
            }
        }

        tcsetattr(STDIN_FILENO, TCSANOW, &oldTermios);
        return ch;
#else
#error "Unsupported platform"
        return -1;
#endif
    }

}  // namespace PlatformUtils