bellatui.cpp

/*
 * BellaTUI - A Client-Server Rendering Application
 * 
 * This application provides a command-line interface for a rendering system called Bella.
 * It consists of two main parts:
 * 1. A server component that handles rendering operations
 * 2. A client component that sends commands and files to the server
 *
 * The application uses ZeroMQ (ZMQ) for secure network communication between client and server.
 * Key features:
 * - Secure communication using CURVE encryption
 * - File transfer capabilities (.bsz files)
 * - Real-time rendering status updates
 * - Heartbeat monitoring to check connection status
 */

#include <iostream>
#include <fstream>
#include <thread>
#include <zmq.hpp>
#include <vector>
#include <chrono>
#include <filesystem>
#include <cstdio>  // For sprintf

#include <string>
#include <sstream> // For string streams
#include <atomic>
#include <mutex> // Add this line for std::mutex and std::lock_guard
#include <map> // Add this line for std::map


#include <cstdlib> // For std::system
#include <stdexcept> // For std::runtime_error

#ifdef _WIN32
#include <windows.h> // For ShellExecuteW
#include <shellapi.h> // For ShellExecuteW
#include <codecvt> // For wstring_convert
#elif defined(__APPLE__) || defined(__linux__)
#include <unistd.h> // For fork, exec
#include <sys/wait.h> // For waitpid
#endif

#include <efsw/FileSystem.hpp> // For file watching
#include <efsw/System.hpp> // For file watching
#include <efsw/efsw.hpp> // For file watching

#include <iostream>
#include <signal.h>


#include "../bella_engine_sdk/src/bella_sdk/bella_engine.h" // For rendering
#include "../bella_engine_sdk/src/dl_core/dl_fs.h" // For rendering
using namespace dl;
using namespace dl::bella_sdk;

//#include "../oom/oom_bella_long.h"   
//#include "../oom/oom_bella_scene.h"   
//#include "../oom/oom_misc.h"         // common misc code
#include "../oom/oom_license.h"        // common license
//#include "../oom/oom_voxel_vmax.h"   // common vmax voxel code and structures
//#include "../oom/oom_voxel_ogt.h"    // common opengametools voxel conversion wrappers



//Forward declarations
std::string bellaSliderPreviewsHTML(); 
//dl::Mat4 oomer_orbit(dl::Mat4 beginCamXform, int currentFrame, int totalFrames);

/// A class that manages a queue of files to render with both FIFO order and fast lookups
class RenderQueue {
public:
    // Default constructor
    RenderQueue() = default;

    // Move constructor
    RenderQueue(RenderQueue&& other) noexcept {
        std::lock_guard<std::mutex> lock(other.mutex);
        pathVector = std::move(other.pathVector);
        pathMap = std::move(other.pathMap);
    }

    // Move assignment operator
    RenderQueue& operator=(RenderQueue&& other) noexcept {
        if (this != &other) {
            std::lock_guard<std::mutex> lock1(mutex);
            std::lock_guard<std::mutex> lock2(other.mutex);
            pathVector = std::move(other.pathVector);
            pathMap = std::move(other.pathMap);
        }
        return *this;
    }

    // Delete copy operations since mutexes can't be copied
    RenderQueue(const RenderQueue&) = delete;
    RenderQueue& operator=(const RenderQueue&) = delete;

    // Add a file to the queue if it's not already there
    bool push(const dl::String& path) {
        std::lock_guard<std::mutex> lock(mutex);
        if (pathMap.find(path) == pathMap.end()) {
            pathVector.push_back(path);
            pathMap[path] = true;
            return true;
        }
        return false;
    }

    // Get the next file to render (FIFO order)
    bool pop(dl::String& outPath) {
        std::lock_guard<std::mutex> lock(mutex);
        if (!pathVector.empty()) {
            outPath = pathVector.front();
            pathVector.erase(pathVector.begin());
            pathMap.erase(outPath);
            return true;
        }
        return false;
    }

    // Remove a specific file by name
    bool remove(const dl::String& path) {
        std::lock_guard<std::mutex> lock(mutex);
        if (pathMap.find(path) != pathMap.end()) {
            // Remove from vector using erase-remove idiom
            pathVector.erase(
                std::remove(pathVector.begin(), pathVector.end(), path),
                pathVector.end()
            );
            // Remove from map
            pathMap.erase(path);
            return true;
        }
        return false;
    }

    // Check if a file exists in the queue
    bool contains(const dl::String& path) const {
        std::lock_guard<std::mutex> lock(mutex);
        return pathMap.find(path) != pathMap.end();
    }

    // Get the number of files in the queue
    size_t size() const {
        std::lock_guard<std::mutex> lock(mutex);
        return pathVector.size();
    }

    // Check if the queue is empty
    bool empty() const {
        std::lock_guard<std::mutex> lock(mutex);
        return pathVector.empty();
    }

    // Clear all files from the queue
    void clear() {
        std::lock_guard<std::mutex> lock(mutex);
        pathVector.clear();
        pathMap.clear();
    }

private:
    std::vector<dl::String> pathVector;  // Maintains FIFO order
    std::map<dl::String, bool> pathMap;  // Enables fast lookups
    mutable std::mutex mutex;            // Thread safety
};

std::atomic<bool> active_render(false);
//bool active_render(false);
//RenderQueue renderQueue;  // Replace the old vector and map with our new class
//std::mutex renderQueueMutex;  // Add mutex for thread safety
//std::vector<dl::String> renderDelete; // This is the efsw queue for when we delete a file
//std::mutex renderDeleteMutex;  // Add mutex for thread safety

dl::String currentRender;
std::mutex currentRenderMutex;  // Add mutex for thread safety

// Queues for incoming files from the efsw watcher
RenderQueue incomingDeleteQueue;  
RenderQueue incomingRenderQueue;  
std::mutex incomingDeleteQueueMutex;  // Add mutex for thread safety
std::mutex incomingRenderQueueMutex;  // Add mutex for thread safety

/// Processes a file action libefsw
class UpdateListener : public efsw::FileWatchListener {
  public:
	UpdateListener() : should_stop_(false) {}

	void stop() {
		should_stop_ = true;
	}

	std::string getActionName( efsw::Action action ) {
		switch ( action ) {
			case efsw::Actions::Add:
				return "Add";
			case efsw::Actions::Modified:
				return "Modified";
			case efsw::Actions::Delete:
				return "Delete";
			case efsw::Actions::Moved:
				return "Moved";
			default:
				return "Bad Action";
		}
	}

	void handleFileAction( efsw::WatchID watchid, const std::string& dir,
						   const std::string& filename, efsw::Action action,
						   std::string oldFilename = "" ) override {
		if (should_stop_) return;  // Early exit if we're stopping
		
		std::string actionName = getActionName( action ); 
		/*std::cout << "Watch ID " << watchid << " DIR ("
				  << dir + ") FILE (" +
						 ( oldFilename.empty() ? "" : "from file " + oldFilename + " to " ) +
						 filename + ") has event "
				  << actionName << std::endl;*/
		if (actionName == "Delete") {
            dl::String belPath = (dir +  filename).c_str();
            if (belPath.endsWith(".bsz") || belPath.endsWith(".zip")) {
                {
                    std::lock_guard<std::mutex> lock(incomingDeleteQueueMutex);
                    if (!incomingDeleteQueue.contains(belPath)) {
                        incomingDeleteQueue.push(belPath);
                        std::cout << "\n==" << "STOP RENDER: " << belPath.buf() << "\n==" << std::endl;
                    }
                }
            }
		}
		if (actionName == "Add" || actionName == "Modified") {
			dl::String belPath = (dir + filename).c_str();
            dl::String parentPath = dir.c_str();
            //std::cout << "parentPath: " << parentPath.buf() << std::endl;
			if (should_stop_) return;  // Check again before starting render

            if (parentPath.endsWith("download")) {
                std::this_thread::sleep_for(std::chrono::milliseconds(1000));
                return;
            }

            if (belPath.endsWith(".bsz") || belPath.endsWith(".zip") && !parentPath.endsWith("download/")) {
                {
                    std::lock_guard<std::mutex> lock(incomingRenderQueueMutex);
                    if (!incomingRenderQueue.contains(belPath)) {
                        incomingRenderQueue.push(belPath);
                        std::cout << "\n==" << "RENDER QUEUED: " << belPath.buf() << "\n==" << std::endl;
                    }
                }
			}
		}
	}
  private:
	std::atomic<bool> should_stop_; // ctrl-c was not working, so we use this to stop the thread
};

// Global state variables
//std::string initializeGlobalLicense();        // Function to return license text
//std::string initializeGlobalThirdPartyLicences(); // Function to return third-party licenses
std::atomic<bool> connection_state (false);   // Tracks if client/server are connected
std::atomic<bool> abort_state (false);        // Used to signal program termination
std::atomic<bool> server (true);             // Indicates if running in server mode
UpdateListener* global_ul = nullptr;          // Global pointer to UpdateListener

// Function declarations
std::string get_pubkey_from_srv(std::string server_address, uint16_t publickey_port);  // Gets server's public key for encryption


bool STOP = false;

void sigend( int ) {
	std::cout << std::endl << "Bye bye" << std::endl;
	STOP = true;
	if (global_ul) {  // Use the global pointer
		global_ul->stop();
	}
	// Give a short time for cleanup
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	exit(0);  // Force exit after cleanup
}

efsw::WatchID handleWatchID( efsw::WatchID watchid ) {
	switch ( watchid ) {
		case efsw::Errors::FileNotFound:
		case efsw::Errors::FileRepeated:
		case efsw::Errors::FileOutOfScope:
		case efsw::Errors::FileRemote:
		case efsw::Errors::WatcherFailed:
		case efsw::Errors::Unspecified: {
			std::cout << efsw::Errors::Log::getLastErrorLog().c_str() << std::endl;
			break;
		}
		default: {
			std::cout << "Added WatchID: " << watchid << std::endl;
		}
	}
	return watchid;
}


static int s_logCtx = 0;
static void log(void* /*ctx*/, LogType type, const char* msg)
{
    switch (type)
    {
    case LogType_Info:
        DL_PRINT("[INFO] %s\n", msg);
        break;
    case LogType_Warning:
        DL_PRINT("[WARN] %s\n", msg);
        break;
    case LogType_Error:
        DL_PRINT("[ERROR] %s\n", msg);
        break;
    case LogType_Custom:
        DL_PRINT("%s\n", msg);
        break;
    }
}

// Main client communication thread
void client_thread( std::string server_pkey, 
                    std::string client_pkey, 
                    std::string client_skey,
                    std::string server_address,
                    uint16_t command_port); 

// Utility function to open files with system default program
void openFileWithDefaultProgram(const std::string& filePath);

// Helper function to check file extensions
bool ends_with_suffix(const std::string& str, const std::string& suffix);

// Server function to handle initial key exchange
void pkey_server(const std::string& pub_key, uint16_t publickey_port);

/*
 * MyEngineObserver Class
 * This class receives callbacks from the Bella rendering engine to track rendering progress.
 * It implements the EngineObserver interface and provides methods to:
 * - Handle render start/stop events
 * - Track rendering progress
 * - Handle error conditions
 * - Store and retrieve the current progress state
 */
struct MyEngineObserver : public EngineObserver
{
public:
    // Called when a rendering pass starts
    void onStarted(String pass) override
    {
        std::cout << "Started pass " << pass.buf() << std::endl;
        logInfo("Started pass %s", pass.buf());
    }

    // Called to update the current status of rendering
    //void onStatus(String pass, String status) override
    //{
    //    logInfo("%s [%s]", status.buf(), pass.buf());
    //}

    // Called to update rendering progress (percentage, time remaining, etc)
    void onProgress(String pass, Progress progress) override
    {
        std::cout << progress.toString().buf() << std::endl;
        setString(new std::string(progress.toString().buf()));
        logInfo("%s [%s]", progress.toString().buf(), pass.buf());
    }

    //void onImage(String pass, Image image) override
    //{
    //    logInfo("We got an image %d x %d.", (int)image.width(), (int)image.height());
    //}  

    // Called when an error occurs during rendering
    void onError(String pass, String msg) override
    {
        logError("%s [%s]", msg.buf(), pass.buf());
    }

    // Called when a rendering pass completes
    void onStopped(String pass) override
    {
        logInfo("Stopped %s", pass.buf());
        active_render = false;
    }

    // Returns the current progress as a string
    std::string getProgress() const {
        std::string* currentProgress = progressPtr.load();
        if (currentProgress) {
            return *currentProgress;
        } else {
            return "";
        }
    }

    // Cleanup resources in destructor
    ~MyEngineObserver() {
        setString(nullptr);
    }
private:
    // Thread-safe pointer to current progress string
    std::atomic<std::string*> progressPtr{nullptr};

    // Helper function to safely update the progress string
    void setString(std::string* newStatus) {
        std::string* oldStatus = progressPtr.exchange(newStatus);
        delete oldStatus;  // Clean up old string if it exists
    }
};

// Main server thread that handles client requests
void server_thread(     std::string server_skey, 
                        uint16_t command_port,
                        bool test_render,
                        Engine engine,
                        MyEngineObserver& engineObserver);

void render_thread( Engine engine,
                    MyEngineObserver& engineObserver);

/*
 * Heartbeat Monitoring System
 * 
 * This function implements a heartbeat mechanism to monitor the connection between client and server.
 * It runs in a separate thread and:
 * - For server: listens for periodic messages from client
 * - For client: sends periodic messages to server
 * If either side stops receiving messages, it marks the connection as dead.
 *
 * Parameters:
 * - server_pkey: Server's public key (used by client)
 * - server_skey: Server's secret key (used by server)
 * - client_pkey: Client's public key (used by client)
 * - client_skey: Client's secret key (used by client)
 * - is_server: Boolean indicating if running in server mode
 * - server_address: Address of the server (used by client)
 * - heartbeat_port: Port number for heartbeat communication
 */
void heartbeat_thread(  std::string server_pkey, 
                        std::string server_skey, 
                        std::string client_pkey, 
                        std::string client_skey, 
                        bool is_server,  
                        std::string server_address,  
                        uint16_t heartbeat_port ) { 

    zmq::context_t ctx;  // Create ZMQ context
    zmq::socket_t heartbeat_sock; // Socket for heartbeat messages

    if(is_server) {
        // Server mode: Listen for client heartbeats
        heartbeat_sock = zmq::socket_t(ctx, zmq::socket_type::rep);
        heartbeat_sock.set(zmq::sockopt::curve_server, true);
        heartbeat_sock.set(zmq::sockopt::curve_secretkey, server_skey);
        std::string url = "tcp://*:" + std::to_string(heartbeat_port);
        heartbeat_sock.bind(url);
        
        while(true) {
            // Only check heartbeats when client is connected
            if (connection_state == true) {
                // Wait up to 5 seconds for client heartbeat
                zmq::pollitem_t response_item = { heartbeat_sock, 0, ZMQ_POLLIN, 0 };
                zmq::poll(&response_item, 1, 5000);

                if (response_item.revents & ZMQ_POLLIN) {
                    // Received heartbeat from client
                    zmq::message_t message;
                    heartbeat_sock.recv(message, zmq::recv_flags::none);
                    heartbeat_sock.send(zmq::message_t("ACK"), zmq::send_flags::dontwait);
                } else {
                    // No heartbeat received - mark connection as dead
                    std::cout << "Bella Client Lost" << std::endl;
                    connection_state = false;
                }
            } 
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        } 
    } else {
        // Client mode: Send heartbeats to server
        zmq::socket_t heartbeat_sock (ctx, zmq::socket_type::req);
        // Set up encryption keys
        heartbeat_sock.set(zmq::sockopt::curve_serverkey, server_pkey);
        heartbeat_sock.set(zmq::sockopt::curve_publickey, client_pkey);
        heartbeat_sock.set(zmq::sockopt::curve_secretkey, client_skey);
        heartbeat_sock.set(zmq::sockopt::linger, 1);
        
        std::string url = "tcp://" + server_address + ":" + std::to_string(heartbeat_port);
        heartbeat_sock.connect(url);

        while (true) {
            // Check if we should stop
            if(abort_state.load()==true) {
                break;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

            if(connection_state == true) {
                // Send heartbeat to server
                heartbeat_sock.send(zmq::message_t("ACK"), zmq::send_flags::none);
                
                // Wait for server response
                zmq::pollitem_t response_item = { heartbeat_sock, 0, ZMQ_POLLIN, 0 };
                zmq::poll(&response_item, 1, 5000);
                
                if (response_item.revents & ZMQ_POLLIN) {
                    // Got response from server
                    zmq::message_t msg_response;
                    heartbeat_sock.recv(msg_response, zmq::recv_flags::none);
                } else {
                    // No response - mark connection as dead
                    std::cout << "Bella Server is unavailable" << std::endl;
                    connection_state = false;
                    break;
                }
            }
        }
    }
    // Clean up resources
    heartbeat_sock.close();
    ctx.close();
}

void file_watcher_thread(const std::string& watch_path = "") {
    bool commonTest = true;
    bool useGeneric = false;
    
    global_ul = new UpdateListener();
    efsw::FileWatcher fileWatcher(useGeneric);

    fileWatcher.followSymlinks(false);
    fileWatcher.allowOutOfScopeLinks(false);

    if (!watch_path.empty() && dl::fs::exists(watch_path.data())) {
        commonTest = false;
        if (fileWatcher.addWatch(watch_path, global_ul, true) > 0) {
            fileWatcher.watch();
            std::cout << "Watching directory: " << watch_path << std::endl;
        } else {
            std::cout << "Error trying to watch directory: " << watch_path << std::endl;
            std::cout << efsw::Errors::Log::getLastErrorLog().c_str() << std::endl;
            return;
        }
    } else if (commonTest) {
        std::string CurPath(efsw::System::getProcessPath());
        std::cout << "CurPath: " << CurPath.c_str() << std::endl;
        fileWatcher.watch();
        handleWatchID(fileWatcher.addWatch(CurPath + "test", global_ul, true));
    }

    while(STOP == false) {
        efsw::System::sleep(500);
    }

    delete global_ul;
    global_ul = nullptr;
}

/*
 * Main Program Entry Point
 * 
 * This function initializes the application and handles command-line arguments.
 * It can run in either server or client mode:
 * - Server mode: Starts rendering engine and waits for client connections
 * - Client mode: Connects to server and sends commands
 *
 * Command-line arguments:
 * --server        : Run in server mode
 * --serverAddress : IP address of server (for client mode)
 * --commandPort   : Port for main command communication
 * --heartbeatPort : Port for connection monitoring
 * --publickeyPort : Port for initial key exchange
 * --testRender    : Use small resolution for testing
 * --thirdparty    : Show third-party licenses
 * --licenseinfo   : Show license information
 */
 #include "dl_core/dl_main.inl"
 #include "dl_core/dl_args.h"
int DL_main(Args& args)
{
    // Default configuration values
    const size_t chunk_size = 65536;
    std::string server_address = "localhost";
    uint16_t command_port = 5797;
    uint16_t heartbeat_port = 5798;
    uint16_t publickey_port = 5799;
    bool test_render = false;

    Engine engine;
    engine.scene().loadDefs();
    MyEngineObserver engineObserver;
    engine.subscribe(&engineObserver);

    // Very early on, we will subscribe to the global bella logging callback, and ask to flush
    // any messages that may have accumulated prior to this point.
    //
    subscribeLog(&s_logCtx, log);
    flushStartupMessages();


    // Register command-line arguments
    args.add("sa",  "serverAddress", "",   "Bella render server ip address");
    args.add("cp",  "commandPort",   "",   "tcp port for zmq server socket for commands");
    args.add("hp",  "heartbeatPort", "",   "tcp port for zmq server socket for heartbeats");
    args.add("pp",  "publickeyPort", "",   "tcp port for zmq server socket for server pubkey");
    args.add("c",   "client",        "",   "turn on client mode");
    args.add("tr",  "testRender",    "",   "force res to 100x100");
    args.add("tp",  "thirdparty",    "",   "prints third party licenses");
    args.add("li",  "licenseinfo",   "",   "prints license info");
    args.add("ef",  "efsw",   "",   "mode efsw");
    args.add("wd",  "watchdir",   "",   "mode file warch");

    // Handle special command-line options
    if (args.versionReqested())
    {
        printf("%s", bellaSdkVersion().toString().buf());
        return 0;
    }

    if (args.helpRequested())
    {
        printf("%s", args.help("SDK Test", fs::exePath(), bellaSdkVersion().toString()).buf());
        return 0;
    }
    std::string path=".";

    if (args.have("--watchdir")) {
        path = args.value("--watchdir").buf();
    }


    //EFSW mode alwys on
    // Create the file watcher thread
    std::thread watcher_thread(file_watcher_thread, path);
    // Don't wait for the thread to finish here, let it run in background
    watcher_thread.detach();
    
    // Show license information if requested
    if (args.have("--licenseinfo"))
    {
        std::cout << "bellatui Copyright (c) Harvey Fong 2025" << std::endl;
        std::cout << oom::license::printLicense() << std::endl;
        return 0;
    }
 
    // Show third-party licenses if requested
    if (args.have("--thirdparty"))
    {
        std::cout << oom::license::printBellaSDK() << "\n====\n" << std::endl;
        std::cout << oom::license::printLibSodium() << "\n====\n" << std::endl;
        std::cout << oom::license::printLibZMQ() << "\n====\n" << std::endl;
        std::cout << oom::license::printCppZMQ() << "\n====\n" << std::endl;
        std::cout << oom::license::printEFSW() << "\n====\n" << std::endl;
        return 0;
    }
 
    // Check if running in server mode
    // Check if running in server mode
    if (args.have("--client"))
    {
        server=false;
    }
    
    // Enable test rendering if requested
    if (args.have("--testRender"))
    {
        test_render=true;
    }

    // Parse server address (for client mode)
    if (args.have("--serverAddress")) 
    {
        server_address = args.value("--serverAddress").buf();
        server=false;
    }

    // Parse port numbers if provided
    if (args.have("--heartbeatPort")) 
    {
        String argString = args.value("--heartbeatPort");
        uint16_t u16; 
        if (argString.parse(u16)) {
            heartbeat_port = u16;
        } else {
            std::cerr << "invalid --heartbeatPort" << argString << std::endl;
        }
    }

    if (args.have("--commandPort")) 
    {
            String argString = args.value("--commandPort");
            uint16_t u16; 
            if (argString.parse(u16)) {
                command_port = u16;
            } else {
            std::cerr << "invalid --commandPort" << argString << std::endl;
            }
    }

    if (args.have("--publickeyPort")) 
    {
            String argString = args.value("--publickeyPort");
            uint16_t u16; 
            if (argString.parse(u16)) {
                publickey_port = u16;
            } else {
            std::cerr << "invalid --commandPort" << argString << std::endl;
            }
    }


    // Generate brand new keypair on launch
    // [TODO] Add client side public key fingerprinting for added security
    if(server.load()) {
        std::cout << "BellaTUI server started ..." << std::endl;
        char server_skey[41] = { 0 };
        char server_pkey[41] = { 0 };
        if ( zmq_curve_keypair(&server_pkey[0], &server_skey[0])) {
            // 1 is fail
            std::cout << "\ncurve keypair gen failed.";
            exit(EXIT_FAILURE);
        }

        std::thread server_t(server_thread, server_skey, command_port, test_render, engine, std::ref(engineObserver));
        std::thread render_t(render_thread, engine, std::ref(engineObserver));

        std::thread heartbeat_t(heartbeat_thread,   //function
                                "",                 //NA Public server key 
                                server_skey,        //Secret servery key 
                                "",                 //NA Public client key 
                                "",                 //NA Secret client key 
                                true,               //is server 
                                "",                 //FQDN or ip address of server 
                                heartbeat_port);              //bind port
                                       //
        while(true) { // awaiting new client loop
            std::cout << "Awaiting new client ..." << std::endl;
            pkey_server(server_pkey, publickey_port); // blocking wait client to get public key
            std::cout << "Client connected" << std::endl; 
            connection_state = true;

            while(true) { // inner loop
                if (connection_state.load()==false) { 
                    std::cout << "Client connection dead" << std::endl;
                    break; // Go back to awaiting client
                }
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
            }
        }
        //abort_state==true;
        server_t.join();
        heartbeat_t.join();
        return 0;      

    } else { //Client
        char client_skey[41] = { 0 };
        char client_pkey[41] = { 0 };
        if ( zmq_curve_keypair(&client_pkey[0], &client_skey[0])) {
            // 1 is fail
            std::cout << "\ncurve keypair gen failed.";
            exit(EXIT_FAILURE);
        }

        std::string server_pkey = get_pubkey_from_srv(server_address, publickey_port);
        std::string client_pkey_str(client_pkey);
        std::string client_skey_str(client_skey);

        // Multithreaded
        std::thread command_t(  client_thread, 
                                server_pkey, 
                                client_pkey_str, 
                                client_skey_str,
                                server_address,
                                command_port);
        //std::thread heartbeat_t(heartbeat_thread, server_pkey, client_pkey_str, client_skey_str);
        std::thread heartbeat_t(heartbeat_thread,   //function
                                server_pkey,        //Public server key  
                                "",                 //NA Secret server key
                                client_pkey_str,    //Public client key
                                client_skey_str,    //Secret client key
                                false,              //is server
                                server_address,         //Server FQDN or ip address
                                heartbeat_port);              //connect port

        while (true) {
            /*if (!heartbeat_state.load()) {
                std::cout << "Dead" << std::endl;
                abort_state==true;
                break;
            }*/
            if (connection_state.load() ==  false) {
                std::cout << "Dead2" << std::endl;
                abort_state==true;
                break;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        }
    }
}

std::string get_pubkey_from_srv(std::string server_address, uint16_t publickey_port) {
    // No authentication is used, server will give out pubkey to anybody
    // Could use a unique message but since socket is unencrypted this provides
    // no protection. In main loop we establish an encrypted connection with the server
    // now that we have the pubkey and in combo with the client_secret_key we can
    // be secure. 0MQ uses PFS perfect forward security, because this initial
    // back and forth is extended with behind the scenes new keypairs taken care of by
    // 0MQ after we establish our intitial encrypted socket
    zmq::context_t ctx;
    zmq::socket_t pubkey_sock(ctx, zmq::socket_type::req);
    std::string url = "tcp://" + server_address + ":" + std::to_string(publickey_port);
    pubkey_sock.connect(url);
    zmq::message_t z_out(std::string("Bellarender123"));

    try {
        zmq::send_result_t send_result = pubkey_sock.send(z_out, zmq::send_flags::none);
    } catch (const zmq::error_t& e) {
        std::cout << "ERROR" << std::endl;
    }

    std::cout << "\nbellatui connecting to " << server_address << " ..." << std::endl;
    zmq::message_t z_in;
    pubkey_sock.recv(z_in);
    std::string pub_key = z_in.to_string();
    pubkey_sock.close();
    ctx.close();
    std::cout << "Connection to " << server_address << " successful" << std::endl;
    connection_state = true;
    return pub_key;
}

void client_thread( std::string server_pkey, 
                    std::string client_pkey, 
                    std::string client_skey,
                    std::string server_address,
                    uint16_t command_port ) {
    //std::cout << "client thread: " << server_address << " " << command_port << std::endl;
    const size_t chunk_size = 65536;
    zmq::context_t ctx;
    zmq::socket_t command_sock (ctx, zmq::socket_type::req);
    //command_sock.set(zmq::sockopt::sndtimeo, 10000);
    //command_sock.set(zmq::sockopt::rcvtimeo, 10000);
    command_sock.set(zmq::sockopt::curve_serverkey, server_pkey);
    command_sock.set(zmq::sockopt::curve_publickey, client_pkey);
    command_sock.set(zmq::sockopt::curve_secretkey, client_skey);
    command_sock.set(zmq::sockopt::linger, 1); // Close immediately on disconnect
    
    //std::string url = "tcp://" + server_address+ ":" + std::to_string(command_port);
    std::string url = "tcp://" + server_address + ":" + std::to_string(command_port);
    //std::cout << "client thread " << url << std::endl;
    command_sock.connect(url);
    
    std::string input;
    while (true) {
        if(abort_state.load()==true) {
            break;
        }
        std::getline(std::cin, input);
        std::stringstream ss(input);
        std::string arg;
        std::vector<std::string> args;
        while (ss >> arg) {
            args.push_back(arg);
        }

        // Sanity checks on input before sending to server
        int num_args = args.size();
        std::string command;
        if (num_args > 0) {
            command = args[0];
            if ( command == "send") {
                if(num_args == 1) {
                    std::cout << "Please provide a .bsz file" << std::endl;
                    continue;
                }
                if(!ends_with_suffix(args[1],".bsz")) {
                    std::cout << "Only .bsz files can be sent" << std::endl;
                    continue;
                }

                if(!dl::fs::exists(args[1].data())) {
                    std::cout << args[1] << " cannot be found" << std::endl;
                    continue;
                }
                std::cout << "Sending:" << args[1] << std::endl;
            } else if (command == "get") {
                if(num_args == 1) {
                    std::cout << "Please provide image filename" << std::endl;
                    continue;
                }
            } else if (command == "exit") {
                ;
            } else if (command == "render") {
                std::string compoundArg;
                if(num_args > 1) {
                    for (size_t i = 1; i < args.size(); ++i) {
                        compoundArg += args[i];
                        if (i < args.size() - 1) {
                            compoundArg += " "; // Add spaces between arguments
                        }
                    }
                    std::cout << compoundArg << std::endl;
                }
            } else if (command == "hello") {
                ;
            } else if (command == "stat") {
                ;
            } else if (command == "help") {
                std::cout << "\033[32msend file.bsz\033[0m upload bella scene to server\n";
                std::cout << "\033[32mrender\033[0m start render on server\n";
                std::cout << "\033[32mget file.png\033[0m download png from server\n";
                std::cout << "\033[32mstop\033[0m stop render on server\n";
                std::cout << "\033[32mstat\033[0m display progress\n";
                continue;
            } else if (command == "stop") {
                ;
            } else {
                std::cout << "unknown" << std::endl;
                continue;
            }        
        }

        // Sanity check input complete
        // Push to server over encrypted socket
        zmq::message_t server_response;
        zmq::message_t msg_command(command);
        //>>>ZOUT
        command_sock.send(msg_command, zmq::send_flags::none); //SEND
        //std::cout << "Sent: " << input.data() << std::endl;

        //ZIN<<<
        command_sock.recv(server_response, zmq::recv_flags::none); //RECV
        std::string response_str(static_cast<char*>(server_response.data()), server_response.size()-1);
        std::string response_str2(static_cast<char*>(server_response.data()), server_response.size());

        if(response_str=="RDY") { // Server acknowledges readiness for multi message commands
            std::cout << "Server Readiness: " << response_str << std::endl;
            if(command == "exit") {
                exit(0);
            // RENDER
            } else if(command == "render") {
                std::string compoundArg;
                if(num_args > 1) {
                    for (size_t i = 1; i < args.size(); ++i) {
                        compoundArg += args[i];
                        if (i < args.size() - 1) {
                            compoundArg += " "; // Add spaces between arguments
                        }
                    }
                    std::cout << compoundArg << std::endl;
                }
                //>>>ZOUT
                command_sock.send(zmq::message_t("render"), zmq::send_flags::none);
                //ZIN<<<
                command_sock.recv(server_response, zmq::recv_flags::none);
            } else if(command == "stat") {
                //>>>ZOUT
                command_sock.send(zmq::message_t("stat"), zmq::send_flags::none);
                //ZIN<<<
                command_sock.recv(server_response, zmq::recv_flags::none);

            // GET
            } else if(command == "get") {
                std::ofstream output_file(args[1], std::ios::binary); // Open file in binary mode
                if (!output_file.is_open()) {
                    std::cerr << "Error opening file for writing" << std::endl;
                    std::cout << "ERR" << std::endl;
                    continue; // Don't bother server
                } else {
                    while (true) {
                        //>>>ZOUT
                        command_sock.send(zmq::message_t("GO"), zmq::send_flags::none); 
                        zmq::message_t recv_data;
                        //ZIN<<<
                        command_sock.recv(recv_data, zmq::recv_flags::none); // data transfer

                        // inline messaging with data, breaks to exit loop
                        if (recv_data.size() < 8) {
                            std::string recv_string(static_cast<const char*>(recv_data.data()), recv_data.size()-1);
                            //std::string recv_string = recv_data.to_string();
                            if (recv_string == "EOF") {
                                std::cout << "EOF" << std::endl;
                                break; // End of file 
                            } else if(recv_string == "ERR")  { //LIKELY ERR\0 from client, can't find file
                                std::cout << "ERR client read ACK" << std::endl;
                                break; // Err
                            } else {
                                std::cout << "HUH" << recv_string << std::endl;
                                break;
                            }
                        }
                        // by reaching this point we assume binary data ( even 8 bytes will reach here )
                        std::cout << "\033[32m.\033[0m";
                        output_file.write(static_cast<char*>(recv_data.data()), recv_data.size());
                    }
                    output_file.close();
                    try {
                        openFileWithDefaultProgram(args[1]); // Replace with your file path
                        std::cout << "File opened successfully." << std::endl;
                    } catch (const std::runtime_error& e) {
                        std::cerr << "Error: " << e.what() << std::endl;
                    }
                }
            // SEND
            } else if(command == "send") {
                std::string read_file = args[1];
                std::cout << "sending\n";
                std::ifstream binaryInputFile;
                binaryInputFile.open(read_file, std::ios::binary);// for reading
                if (!binaryInputFile.is_open()) {
                    std::cerr << "Error opening file for read" << std::endl;
                    //>>>ZOUT
                    command_sock.send(zmq::message_t("ERR"), zmq::send_flags::none); 
                    ///ZIN<<<
                    command_sock.recv(server_response, zmq::recv_flags::none);
                } else {
                    std::vector<char> send_buffer(chunk_size);
                    std::streamsize bytes_read_in_chunk;
                    while (true) {
                        binaryInputFile.read(send_buffer.data(), chunk_size); // read the file into the buffer
                        bytes_read_in_chunk = binaryInputFile.gcount(); // Actual bytes read
                        if(bytes_read_in_chunk > 0){
                            std::cout << "\033[32m.\033[0m";
                            zmq::message_t message(send_buffer.data(), bytes_read_in_chunk);
                            //>>>ZOUT 
                            command_sock.send(message, zmq::send_flags::none);
                            //ZIN<<<
                            command_sock.recv(server_response, zmq::recv_flags::none);
                        } else {
                            std::cout << "\n";
                            break;
                        }
                    }
                    //<<<ZOUT
                    command_sock.send(zmq::message_t("EOF"), zmq::send_flags::none);
                    //ZIN>>>
                    command_sock.recv(server_response, zmq::recv_flags::none);
                }
            }
        } else {
            std::cout << "Server response: \033[32m" << response_str2 << "\033[0m" << std::endl;
        }
    }
    command_sock.close();
    ctx.close();
}

void server_thread(     std::string server_skey, 
                        uint16_t command_port,
                        bool test_render,
                        Engine engine,
                        MyEngineObserver& engineObserver) {
    //MyEngineObserver engineObserver;
    //engine.subscribe(&engineObserver);

    zmq::context_t ctx;
    zmq::socket_t command_sock(ctx, zmq::socket_type::rep);  
    //command_sock.set(zmq::sockopt::sndtimeo, 10000);
    //command_sock.set(zmq::sockopt::rcvtimeo, 10000);
    command_sock.set(zmq::sockopt::curve_server, true);
    command_sock.set(zmq::sockopt::curve_secretkey, server_skey);
    //command_sock.set(zmq::sockopt::linger, 100); // Close immediately on disconnect
    std::string url = "tcp://*:" + std::to_string(command_port);
    command_sock.bind(url);
    zmq::message_t client_response; 

    try {
        std::string write_file = "./oomer.bsz";            
        std::string read_file = "./oomer.png";            
        const size_t chunk_size = 65536;
        std::vector<char> sftp_buffer(chunk_size); // Buffer to hold each chunk
        std::ofstream binaryOutputFile;// for writing
        std::ifstream binaryInputFile;// for reading
        while (true) {
            zmq::message_t msg_command; 
            //ZIN<<<
            command_sock.recv(msg_command, zmq::recv_flags::none);
            std::string client_command = msg_command.to_string();
            std::cout << "\033[32mCommand: " << client_command << "\033[0m"<< std::endl;

            if(client_command == "hello"){
                std::cout << "bye" << std::endl;
                //>>>ZOUT
                command_sock.send(zmq::message_t("bye"), zmq::send_flags::none); 
            } else if (client_command == "exit") {
                std::cout << "Client disconnecting..." << std::endl;
                //>>>ZOUT
                command_sock.send(zmq::message_t("RDY"), zmq::send_flags::none); 
                connection_state = false; //<<
            // RENDER
            } else if (client_command == "xxxxrender") {
                std::cout << "start render" << std::endl;

                //>>>ZOUT
                command_sock.send(zmq::message_t("render started...type stat to get progress"), zmq::send_flags::none); 
            } else if (client_command == "stop") {
                std::cout << "stop render" << std::endl;
                engine.stop();
                //>>>ZOUT
                command_sock.send(zmq::message_t("render stopped"), zmq::send_flags::none); 

            //GET
            } else if (client_command == "get") { //REP mode
                std::string read_file = "./oomer.png";
                std::cout << "Executing get command\n";
                std::ifstream binaryInputFile;
                binaryInputFile.open(read_file, std::ios::binary);// for reading
                if (!binaryInputFile.is_open()) {
                    std::cerr << "Error opening file for read" << std::endl;
                    //>>>ZOUT
                    command_sock.send(zmq::message_t("ERR"), zmq::send_flags::none); 
                } else {
                    //>>>ZOUT
                    command_sock.send(zmq::message_t("RDY"), zmq::send_flags::none); 
                    std::vector<char> send_buffer(chunk_size);
                    std::streamsize bytes_read_in_chunk;
                    while (true) {
                        zmq::message_t z_in;
                        //ZIN
                        command_sock.recv(z_in);  // Block until zGo, or any message
                        binaryInputFile.read(send_buffer.data(), chunk_size); // read the file into the buffer
                        bytes_read_in_chunk = binaryInputFile.gcount(); // Actual bytes read
                        if(bytes_read_in_chunk > 0){
                            std::cout << bytes_read_in_chunk << std::endl;
                            zmq::message_t message(send_buffer.data(), bytes_read_in_chunk);
                            //ZOUT
                            command_sock.send(message, zmq::send_flags::none); 
                        } else {
                            //ZOUT
                            command_sock.send(zmq::message_t("EOF"), zmq::send_flags::none); 
                            std::cout << "EOF" << std::endl;
                            break; // Exit when 0 bytes read
                        }
                    }
                }

            } else if (client_command == "stat") {
                //std::string currentProgress = engineObserver.getProgress();
                std::string currentProgress = "100%";
                if (!currentProgress.empty()) {
                    std::cout << "Current Progress: " << currentProgress << std::endl;
                    command_sock.send(zmq::message_t(currentProgress), zmq::send_flags::none); 
                } else {
                    command_sock.send(zmq::message_t("ACK"), zmq::send_flags::none); 
                }
            } else if (client_command == "send") {
                std::ofstream output_file("oomer.bsz", std::ios::binary); // Open file in binary mode
                if (!output_file.is_open()) {
                    std::cerr << "Error opening file for writing" << std::endl;
                    //>>>ZOUT
                    command_sock.send(zmq::message_t("ERR"), zmq::send_flags::none); 
                } else { // File handle open and ready
                    //>>>ZOUT
                    command_sock.send(zmq::message_t("RDY"), zmq::send_flags::none); 
                    while (true) {
                        zmq::message_t recv_data;
                        //ZIN<<<
                        command_sock.recv(recv_data, zmq::recv_flags::none);
                        if(recv_data.size() < 8) { // data and signals sent on same socket
                            // Allow for signals up to 8 bytes, EOF, ERR
                            // messages are null terminated requiring -1
                            std::string response_str(static_cast<char*>(recv_data.data()), recv_data.size()-1);
                            if (response_str=="EOF") {
                                //>>>ZOUT
                                command_sock.send(zmq::message_t("ACK"), zmq::send_flags::none);
                                break; // End of file
                            } else if(response_str=="ERR")  {
                                std::cout << "ERR on client" << std::endl;
                                //>>>ZOUT
                                command_sock.send(zmq::message_t("ACK"), zmq::send_flags::none);
                                break; // End of file
                            }
                        }
                        // File write
                        output_file.write(static_cast<char*>(recv_data.data()), recv_data.size());
                        //>>ZOUT
                        command_sock.send(zmq::message_t("ACK"), zmq::send_flags::none);
                    }
                    output_file.close();
                    std::cout << "\033[32mClient uploaded .bsz successfully saved\033[0m" << std::endl;
                    engine.scene().read("oomer.bsz");
                    engine.scene().beautyPass()["outputExt"] = ".png";
                    engine.scene().beautyPass()["outputName"] = "";
                    engine.scene().beautyPass()["overridePath"] = bella_sdk::Node();
                }
            } else { // A unknown REQ sent, acknowledge because req-rep pattern is blocking
                //>>ZOUT
                command_sock.send(zmq::message_t("ACK"), zmq::send_flags::none); 
            }



            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }

    } catch (const zmq::error_t& e) {
        // Handle ZMQ-specific exceptions
        std::cerr << "ZMQ error: " << e.what() << std::endl;
        ctx.close();
        command_sock.close();
        //Potentially close sockets, clean up etc.
    } catch (const std::exception& e) {
        // Handle standard exceptions (e.g., std::bad_alloc)
        std::cerr << "Standard exception: " << e.what() << std::endl;
    } catch (...) {
        // Catch any other exceptions
        std::cerr << "Unknown exception caught." << std::endl;
    }
    command_sock.close();
    ctx.close();
}


void render_thread( Engine engine,
                    MyEngineObserver& engineObserver) {
    // Create persistent instances outside the loop
    RenderQueue renderThreadQueue;
    RenderQueue renderThreadDeleteQueue;

    while (true) {
        // Append items from incoming queues to our persistent queues for thread safety
        {
            std::lock_guard<std::mutex> lock(incomingRenderQueueMutex);
            dl::String path;
            while (incomingRenderQueue.pop(path)) {
                renderThreadQueue.push(path);
            }
            incomingRenderQueue.clear();
        }
        
        {
            std::lock_guard<std::mutex> lock(incomingDeleteQueueMutex);
            dl::String path;
            while (incomingDeleteQueue.pop(path)) {
                renderThreadDeleteQueue.push(path);
            }
            incomingDeleteQueue.clear();
        }

        // Process the files without holding the mutex
        bool expected = false;
        
        // This is an atomic operation that does two things at once:
        // 1. Checks if active_render equals expected (false)
        // 2. If they are equal, sets active_render to true
        // 
        // The operation is atomic, meaning no other thread can interfere
        // between the check and the set. This prevents two threads from
        // both thinking they can start rendering at the same time.
        //
        // Returns true if the exchange was successful (we got the render slot)
        // Returns false if active_render was already true (someone else is rendering)
        dl::String belPath;
        if (active_render.compare_exchange_strong(expected, true)) {
            // We successfully got the render slot - no one else is rendering
            if (renderThreadQueue.pop(belPath)) {
                std::cout << "\n==" << "RENDERING: " << belPath.buf() << "\n==" << std::endl;
                if (belPath.endsWith(".bsz")) {
                    engine.loadScene(belPath);
                    //engine.scene().camera()["resolution"]= Vec2 {100, 100};
                    engine.start();
                    {
                        std::lock_guard<std::mutex> lock(currentRenderMutex);
                        currentRender = belPath; 
                    }
                } else if (belPath.endsWith(".zip")) {
                    dl::Path fooPath = dl::Path(belPath);
                    dl::String justDir = fooPath.dir();
                    dl::String justName = fooPath.file(false);
                    //auto previewPath = args.iPath().canonical();;
                    dl::String previewPath = bella_sdk::previewPath();
                    engine.loadScene(previewPath);
                    auto oomerOutputPath = engine.scene().createNode("outputImagePath", "oomerOutputPath");
                    oomerOutputPath["ext"] = ".jpg";
                    auto oomerPBR = engine.scene().createNode("pbr", "oomerPBR");
                    oomerPBR["file"] = justName;
                    oomerPBR["ext"] = ".zip";
                    oomerPBR["dir"] = justDir;
                    auto oomerPreview = engine.scene().findNode("__preview__");
                    auto oomerCamXform = engine.scene().findNode("__camera__");
                    oomerPreview["material"] = oomerPBR;
                    std::filesystem::path dirPath = std::string(justDir.buf())+"/"+std::string(justName.buf());
                    bool success = std::filesystem::create_directory(dirPath);
                    oomerOutputPath["dir"] = dirPath.string().c_str();
                    //engine.scene().beautyPass()["outputExt"] = ".jpg";
                    engine.scene().beautyPass()["targetNoise"] = dl::Int(10);
                    engine.scene().beautyPass()["saveImage"] = dl::Int(0);
                    engine.scene().beautyPass()["overridePath"] = oomerOutputPath;
                    engine.scene().camera()["resolution"]= Vec2 {320, 320};

                    std::ofstream outFile(dirPath.string()+"/bella.js");
                    outFile << std::string("bellaScene=\"") << justName.buf() << std::string("\";") << std::endl;
                    outFile << std::string("bellaNodeType=\"") << "foo1" << std::string("\";") << std::endl;
                    outFile << std::string("bellaNode=\"") << "foo2" << std::string("\";") << std::endl;
                    outFile << std::string("bellaNodeAttribute=\"") << "hhh" << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps=[];") << std::endl;
                    outFile << std::string("bellaSteps[1]=\"") << -1.00000f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[2]=\"") << -0.93104f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[3]=\"") << -0.86208f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[4]=\"") << -0.79312f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[5]=\"") << -0.72414f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[6]=\"") << -0.65518f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[7]=\"") << -0.58622f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[8]=\"") << -0.51726f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[9]=\"") << -0.44828f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[10]=\"") << -0.37932f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[11]=\"") << -0.31036f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[12]=\"") << -0.24138f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[13]=\"") << -0.17242f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[14]=\"") << -0.10346f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[15]=\"") << -0.03450f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[16]=\"") << 0.03448f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[17]=\"") << 0.10344f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[18]=\"") << 0.17240f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[19]=\"") << 0.24136f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[20]=\"") << 0.31034f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[21]=\"") << 0.37930f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[22]=\"") << 0.44826f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[23]=\"") << 0.51724f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[24]=\"") << 0.58620f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[25]=\"") << 0.65516f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[26]=\"") << 0.72412f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[27]=\"") << 0.79310f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[28]=\"") << 0.86206f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[29]=\"") << 0.93102f << std::string("\";") << std::endl;
                    outFile << std::string("bellaSteps[30]=\"") << 1.00000f << std::string("\";") << std::endl;
                    outFile << std::string("bellaQueue=[];") << std::endl;
                    outFile.close();    
                    std::ofstream outFile2(dirPath.string()+"/index.html");
                    outFile2 << bellaSliderPreviewsHTML();
                    outFile2.close();
                    {
                        std::lock_guard<std::mutex> lock(currentRenderMutex);
                        currentRender = belPath; 
                        active_render = true;
                    }

                    bool stop_loop = false;
                    for (int i = 1; i <= 30; i++) {
                        auto offset = dl::Vec2 {i*0.1, 0.0};
                        dl::bella_sdk::orbitCamera(engine.scene().cameraPath(),offset);
                        oomerOutputPath["file"] = dl::String::format("bella%04d",i);


                        engine.start();
                        while (engine.rendering()) { //blocking so we only do one frame at a time
                            // since we are looping here we don't check for file dequeing
                            {
                                std::lock_guard<std::mutex> lock(incomingDeleteQueueMutex);
                                dl::String path;
                                while (incomingDeleteQueue.pop(path)) { // transfer to this thread's delete queue
                                    renderThreadDeleteQueue.push(path);
                                }
                                incomingDeleteQueue.clear(); // empty file queue    
                                if (renderThreadDeleteQueue.contains(belPath)) {
                                    renderThreadDeleteQueue.remove(belPath);
                                    active_render = false;
                                    engine.stop();
                                    stop_loop = true;
                                    break;
                                }
                            }
                            std::this_thread::sleep_for(std::chrono::milliseconds(100));
                        }
                        if (stop_loop) {
                            break;
                        }
                    }
                } else {
                    active_render = false;  // Release the render slot
                }
            } else {
                active_render = false;  // Release the render slot
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        } else { // someone else is rendering
            //std::cout << "Waiting for render slot" << std::endl;

            //std::cout << "Render Queue size: " << renderThreadQueue.size() << std::endl;
            //std::cout << "Delete Queue size: " << renderThreadDeleteQueue.size() << std::endl;
            while (renderThreadDeleteQueue.pop(belPath)) { // pop all the deletes
                //std::cout << "renderThreadDeleteQueue contains " << belPath.buf() << " " << renderThreadDeleteQueue.contains(belPath) << std::endl;
                if (belPath == currentRender) {
                    std::cout << "/n==/nStopping render" << belPath.buf() << std::endl;
                    engine.stop();
                    active_render = false;
                } else if (renderThreadQueue.contains(belPath)) { // dequeue deletes
                    renderThreadQueue.remove(belPath);
                } 
            }

            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void openFileWithDefaultProgram(const std::string& filePath) {
#ifdef _WIN32
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
    std::wstring wideFilePath = converter.from_bytes(filePath);

    HINSTANCE result = ShellExecuteW(nullptr, nullptr, wideFilePath.c_str(), nullptr, nullptr, SW_SHOW);

    if ((intptr_t)result <= 32) {
        throw std::runtime_error("Failed to open file: ShellExecuteW returned " + std::to_string((intptr_t)result));
    }

#elif defined(__APPLE__)
    pid_t pid = fork();
    if (pid == 0) {
        // Child process
        execl("/usr/bin/open", "open", filePath.c_str(), nullptr);
        // If execl fails:
        std::cerr << "Failed to open file: execl failed" << std::endl;
        exit(1); // Exit child process on error
    } else if (pid > 0) {
        // Parent process
        int status;
        waitpid(pid, &status, 0);
        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
            throw std::runtime_error("Failed to open file: open command failed");
        }
    } else {
        throw std::runtime_error("Failed to open file: fork failed");
    }

#elif defined(__linux__)
    pid_t pid = fork();
    if (pid == 0) {
        // Child process
        execl("/usr/bin/xdg-open", "xdg-open", filePath.c_str(), nullptr);
        // If execl fails:
        std::cerr << "Failed to open file: execl failed" << std::endl;
        exit(1); // Exit child process on error
    } else if (pid > 0) {
        // Parent process
        int status;
        waitpid(pid, &status, 0);
        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
            throw std::runtime_error("Failed to open file: xdg-open command failed");
        }
    } else {
        throw std::runtime_error("Failed to open file: fork failed");
    }

#else
    // Fallback: Use system, but this is less reliable and secure.
    std::string command = "open \"" + filePath + "\""; // May need to adapt quoting
    int result = std::system(command.c_str());
    if (result != 0) {
        throw std::runtime_error("Failed to open file: system command failed");
    }
#endif
}

bool ends_with_suffix(const std::string& str, const std::string& suffix) {
    if (str.length() >= 4) {
        return str.substr(str.length() - 4) == suffix;
    }
    return false;
}

// Blocking zmq rep socket to pass server_public_key
void pkey_server(const std::string& pub_key, uint16_t publickey_port) {
    zmq::context_t ctx;
    zmq::socket_t sock(ctx, zmq::socket_type::rep);
    std::string url = "tcp://*:" + std::to_string(publickey_port);
    sock.bind(url); 

    zmq::message_t z_in;
    //ZIN<<<
    sock.recv(z_in);
    if (z_in.to_string().compare("Bellarender123") == 0) {
        zmq::message_t z_out(pub_key);
        //ZOUT>>>
        sock.send(z_out, zmq::send_flags::none);
        connection_state = true;
    }
    sock.close();
    ctx.close();
}

std::string bellaSliderPreviewsHTML() {
return R"HTML(
<html>
  <head>
    <style type='text/css'>
      body {
        margin: 0;
        background: #555;
        font-family: sans-serif;
        color: #ddd;
      }
      .container {
        padding: 0.25em;
      }
      .image-panel {
        padding: 0.5em;
        background: #666;
        border-radius: 0.35em;
        margin: 8px;
        display: inline-grid;
        min-width: max-content;
      }
      .select {
        margin-bottom: 1em;
        background: #333;
        color: #ddd;
        border: none;
        border-radius: 0.2em;
        padding: 0.5em 0.75em;
        font-size: .5em;
      }
      .image {
        margin: auto;
        background: #222;
        min-width: 200px;
        min-height: 200px;
      }
      .step {
        font-size: 1.25em;
        margin: -1.75em auto auto auto;
        padding: 0.125em 0.5em;
        border-radius: 0.2em;
        background: #0004;
        color: #fff;
      }
      .slider {
        margin-top: 1.25em;
      }
      * {
        box-sizing: border-box;
      }   
      .row {
      float: top;
      padding-top: 5px;
      padding-left: 8px;
      padding-right: 8px;
      width: 100%;
      }
      .upper {
        height: 5%;
      }
      .lower {
        height: 95%;
      }
      .column:after {
        content: "";
        display: table;
        clear: both;
      }
      a {
      font-size: 14px; color: #f7f2eb; text-decoration: none;
      }
      a:active {
      font-size: 14px; color: #ffffff; text-decoration: none;
      }
      a:hover {
      font-size: 14px; color: #a77d9f; text-decoration: underline;
      }
      pre {
      padding-left: 2em;
      margin-top: 0px;
      font-size: 12px;
      font-family: sans-serif;
      color: #999;
      }
    </style>
    <script type='text/javascript'>
    
      // I guess the bella.js must be a generated file and these could be moved there.
      //
      //var steps = [];
      //var bella_type = "unknown_type"
      //var bella_node = "unknown_node"
      //var bella_attribute = "unknown_attr"
      
      // So, script tags call this with the image prefix they want; we create all the elements,
      // load the initial image, wire up events, and preload the other images for this prefix.
      //
      var createImagePanel = (prefix, firstStep, lastStep) => {
      
        // Load the steps array. We expect the .js file to contain an array of step labels, in
        // an array named for the prefix (e.g. 'var bellaSteps = [];'), which we will use below
        // to make sure we look up the step label values from the correct array.
        //
        var script = document.createElement('script');
        script.src = prefix + '.js';
        document.head.appendChild(script);

        script.onerror = () => {
          
          var errorText = `File '${prefix}.js' was not found.`;
          console.error(errorText);
          
          var container = document.scripts[document.scripts.length-1].parentNode;
          var panel = document.createElement('div');
          container.appendChild(panel);
          panel.className = 'image-panel error';
          panel.innerText = errorText;
        };

        script.onload = () => {
          
          var debugPreloading = false;
          
          // The step labels for this prefix have been loaded, so we look for them by name.
          //
          var stepLabels = () => window[prefix + 'Steps'];
        
          // Build an image path given a prefix and index.
          //
          var imageFilename = (prefix, idx) => {
            return prefix+idx.toString().padStart(4, '0')+'.jpg';
          };
          
          // Not really tested but this should handle the preloading.
          //
          var preloadImage = (prefix, step) => {
            var img = document.createElement('img');
            var preloadNextImage = () => {
              if (step < lastStep) {
                preloadImage(prefix, step+1);
              } else {
                if (debugPreloading) {
                  console.log(`Finished preloading prefix '${prefix}' at step ${step}.`);
                }
              }
            };
            img.onload = () => {
              if (debugPreloading) {
                console.log(`Loaded step ${step} for prefix '${prefix}'.`);
              }
              preloadNextImage();
            };
            img.onerror = () => {
              console.error(`Failed to load step ${step} for prefix '${prefix}'.`);
              preloadNextImage();
            };
            img.src = imageFilename(prefix, step);
          };
          
          // Now actually create the elements.
          //
          var container = document.scripts[document.scripts.length-1].parentNode;
          var panel = document.createElement('div');
          container.appendChild(panel);
          panel.className = 'image-panel';
          
          var dropdown = document.createElement('select');
          panel.appendChild(dropdown);
          dropdown.className = 'select';
          dropdown.autocomplete = 'off';
          
          for (var i = 0; i < 7; ++i) {
            if (i == 0) {
              var option = document.createElement('option');
              dropdown.appendChild(option);
              option.value = '';
              option.selected = '';
              option.innerText = 'Auto (actual image size)';
            } else if (i > 2) {
              var option = document.createElement('option');
              dropdown.appendChild(option);
              option.value = i + '00px';
              option.innerText = i + '00 px';
            }
          }
          
          var image = document.createElement('img');
          panel.appendChild(image);
          image.className = 'image';
          
          var step = document.createElement('div');
          panel.appendChild(step);
          step.className = 'step';
          
          var slider = document.createElement('input');
          panel.appendChild(slider);
          slider.className = 'slider';
          slider.type = 'range';
          slider.autocomplete = 'off';
          slider.min = firstStep;
          slider.max = lastStep;
          slider.step = '1';
          slider.value = firstStep;
          
          var selectSize = () => {
            image.style.width = dropdown.value;
          };
          
          var selectImage = () => {
            step.innerText = stepLabels()[slider.value];
            image.onerror = () => { image.src = 'missing.jpg'; }
            image.src = imageFilename(prefix, slider.value);
          };
          
          // Select new image size & images on events.
          //
          dropdown.onchange = () => selectSize();
          slider.oninput = () => selectImage();
          
          // Load the first image for this panel.
          //
          selectImage(slider);
          
          // Give awhile for each panel to load its first image before preloading the rest.
          //
          setTimeout(() => preloadImage(prefix, firstStep+1), 1000);
        };
      };
    function bella_strings() {
      document.getElementById("bella_scene").innerHTML = bellaScene;
      document.getElementById("bella_type").innerHTML = bellaNodeType;
      document.getElementById("bella_node").innerHTML = bellaNode;
      document.getElementById("bella_attribute").innerHTML = bellaNodeAttribute;
      htmlFragment="";
      bellaQueue.forEach(item => htmlFragment+=item+"<br>");
      document.getElementById("bellaFragment").innerHTML = htmlFragment;
    };
    </script>
    <script src='bella.js'></script>
  </head>
  <body onload="bella_strings()">

    <div class="column">
      <div class="row upper" style="background-color:#444;">
        <a href=../directory.html id="bella_scene"></a> &nbsp; > &nbsp;
        <a href=../directory.html id="bella_type"></a> &nbsp; > &nbsp;
        <a href=../directory.html id="bella_node"></a> &nbsp; > &nbsp; <a href=../directory.html id="bella_attribute"></a>  

      </div>

      <div class="row lower" style="background-color:#555;">
        <div class='container'>
          
          <!-- Here is what the panels look like -->
          
          <!--div class='image-panel'>
            <select class='select' autocomplete='off' onchange='selectSize(this)'>
              <option value='' selected >Auto (actual image size)</option>
              <option value='400px'>400 px</option>
              <option value='500px'>500 px</option>
              <option value='600px'>600 px</option>
            </select>
            <img class='image' />
            <div class='step'></div>
            <input class='slider' type='range' autocomplete='off' step='1' oninput="selectImage(this)" />
          </div-->
          
          <!-- but we create them like this instead; each would refer to a different image set -->
          
          <script type='text/javascript'>createImagePanel('bella', 1, 30);</script>
          <script type='text/javascript'>createImagePanel('bella', 1, 30);</script>
        </div>
        <pre id="bellaFragment"></pre>
      </div> 
    </div> 
  </body>
</html>
)HTML"; }