/*
 * 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 <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;

/// 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);
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
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") {
            if (active_render || !incomingRenderQueue.empty()) { 
                dl::String belPath = (dir +  filename).c_str();
                if (belPath.endsWith(".bsz")) {
                    {
                        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();
			if (should_stop_) return;  // Check again before starting render
			if (belPath.endsWith(".bsz")) {
                {
                    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"
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 << initializeGlobalLicense() << std::endl;
        return 0;
    }
 
    // Show third-party licenses if requested
    if (args.have("--thirdparty"))
    {
        std::cout << initializeGlobalThirdPartyLicences() << std::endl;
        return 0;
    }
 
    // 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, std::ref(engine), std::ref(engineObserver));
        std::thread render_t(render_thread, std::ref(engine), std::ref(engineObserver));
        ///std::thread heartbeat_t(heartbeat_thread, server_skey, server.load(), 5555);
        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();
                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
        {
            std::lock_guard<std::mutex> lock(incomingRenderQueueMutex);
            // Process each item in the incoming queue and add it to our persistent queue
            dl::String path;
            while (incomingRenderQueue.pop(path)) {
                renderThreadQueue.push(path);
            }
            incomingRenderQueue.clear();
        }
        
        {
            std::lock_guard<std::mutex> lock(incomingDeleteQueueMutex);
            // Process each item in the incoming queue and add it to our persistent queue
            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;
                engine.loadScene(belPath);
                //engine.scene().camera()["resolution"]= Vec2 {100, 100};
                engine.start();
                {
                    std::lock_guard<std::mutex> lock(currentRenderMutex);
                    currentRender = belPath; 
                }
            } 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 initializeGlobalLicense() {
    return R"(
bellatui

Copyright (c) 2025 Harvey Fong

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.)"; }

std::string initializeGlobalThirdPartyLicences() {
return R"(
====

Bella SDK (Software Development Kit)

Copyright Diffuse Logic SCP, all rights reserved.

Permission is hereby granted to any person obtaining a copy of this software
(the "Software"), to use, copy, publish, distribute, sublicense, and/or sell
copies of the Software.

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL
IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY
ARE HEREBY DISCLAIMED.

====

CppZMQ

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.

====

libsodium


ISC License

Copyright (c) 2013-2025
Frank Denis <j at pureftpd dot org>

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 =====

 libzmq is free software; you can redistribute it and/or modify it under the terms of the Mozilla Public License Version 2.0.)"; }