/* Copyright 2026, UCAR/Unidata.
   See the COPYRIGHT file for more information. */

/**
 * @file
 * @internal This file contains functions for loading UDF plugins from RC files.
 *
 * @author Ed Hartnett
 * @date 2/2/26
 */

#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "netcdf.h"
#include "netcdf_dispatch.h"
#include "nclog.h"
#include "ncrc.h"
#include "ncudfplugins.h"

/* Platform-specific dynamic loading headers */
#ifdef _WIN32
#include <windows.h>
#else
#include <dlfcn.h>
#endif

/**
 * Load a dynamic library (platform-specific).
 *
 * @param path Full path to the library file.
 * @return Handle to the loaded library, or NULL on failure.
 *
 * @author Edward Hartnett
 * @date 2/2/26
 */
static void*
load_library(const char* path)
{
    void* handle = NULL;
    
#ifdef _WIN32
    handle = (void*)LoadLibraryA(path);
    if (!handle) {
        DWORD err = GetLastError();
        nclog(NCLOGERR, "LoadLibrary failed for %s: error %lu", path, err);
    }
#else
    handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
    if (!handle) {
        nclog(NCLOGERR, "dlopen failed for %s: %s", path, dlerror());
    }
#endif
    
    return handle;
}

/**
 * Get a symbol from a loaded library (platform-specific).
 *
 * @param handle Handle to the loaded library.
 * @param symbol Name of the symbol to retrieve.
 * @return Pointer to the symbol, or NULL on failure.
 *
 * @author Edward Hartnett
 * @date 2/2/26
 */
static void*
get_symbol(void* handle, const char* symbol)
{
    void* sym = NULL;
    
#ifdef _WIN32
    sym = (void*)GetProcAddress((HMODULE)handle, symbol);
    if (!sym) {
        DWORD err = GetLastError();
        nclog(NCLOGERR, "GetProcAddress failed for %s: error %lu", symbol, err);
    }
#else
    sym = dlsym(handle, symbol);
    if (!sym) {
        nclog(NCLOGERR, "dlsym failed for %s: %s", symbol, dlerror());
    }
#endif
    
    return sym;
}

/**
 * Load a single UDF plugin library and call its initialization function.
 *
 * @param udf_number UDF slot number (0-9).
 * @param library_path Full path to the plugin library.
 * @param init_func Name of the initialization function.
 * @param magic Optional magic number string (can be NULL).
 * @return NC_NOERR on success, error code on failure.
 *
 * @author Edward Hartnett
 * @date 2/2/26
 */
static int
load_udf_plugin(int udf_number, const char* library_path,
                const char* init_func, const char* magic)
{
    int stat = NC_NOERR;
    void* handle = NULL;
    int mode_flag;
#ifndef HAVE_NETCDF_UDF_SELF_REGISTRATION
    NC_Dispatch* dispatch_table = NULL;
    char magic_check[NC_MAX_MAGIC_NUMBER_LEN + 1];
#endif
    
    /* Determine mode flag from UDF number */
    if (udf_number == 0)
        mode_flag = NC_UDF0;
    else if (udf_number == 1)
        mode_flag = NC_UDF1;
    else
        mode_flag = NC_UDF2 << (udf_number - 2);
    
    /* Load the library */
    handle = load_library(library_path);
    if (!handle) {
        stat = NC_ENOTNC;
        goto done;
    }
    
#ifdef HAVE_NETCDF_UDF_SELF_REGISTRATION
    /* Self-registration mode: init function returns NC_Dispatch* */
    {
        NC_Dispatch* (*init_function)(void) = NULL;
        NC_Dispatch* table = NULL;
        
        /* Get the initialization function */
        init_function = (NC_Dispatch* (*)(void))get_symbol(handle, init_func);
        if (!init_function) {
            stat = NC_ENOTNC;
            goto done;
        }
        
        /* Call the initialization function to get the dispatch table */
        table = init_function();
        if (!table) {
            nclog(NCLOGERR, "Plugin init function %s returned NULL", init_func);
            stat = NC_ENOTNC;
            goto done;
        }
        
        /* Verify dispatch ABI version */
        if (table->dispatch_version != NC_DISPATCH_VERSION) {
            nclog(NCLOGERR, "Plugin dispatch ABI mismatch for UDF%d: expected %d, got %d",
                  udf_number, NC_DISPATCH_VERSION, table->dispatch_version);
            stat = NC_EINVAL;
            goto done;
        }
        
        /* Register the dispatch table returned by the plugin */
        if ((stat = nc_def_user_format(mode_flag, table, (char*)magic))) {
            nclog(NCLOGERR, "Failed to register dispatch table for UDF%d: %d",
                  udf_number, stat);
            goto done;
        }
    }
#else
    /* Legacy mode: init function returns int and registers itself */
    {
        int (*init_function)(void) = NULL;
        
        /* Get the initialization function */
        init_function = (int (*)(void))get_symbol(handle, init_func);
        if (!init_function) {
            stat = NC_ENOTNC;
            goto done;
        }
        
        /* Call the initialization function */
        if ((stat = init_function())) {
            nclog(NCLOGERR, "Plugin init function %s failed: %d", init_func, stat);
            goto done;
        }
        
        /* Verify the dispatch table was registered */
        memset(magic_check, 0, sizeof(magic_check));
        if ((stat = nc_inq_user_format(mode_flag, &dispatch_table, magic_check))) {
            nclog(NCLOGERR, "Plugin did not register dispatch table for UDF%d", udf_number);
            goto done;
        }
        
        if (dispatch_table == NULL) {
            nclog(NCLOGERR, "Plugin registered NULL dispatch table for UDF%d", udf_number);
            stat = NC_EINVAL;
            goto done;
        }
        
        /* Verify dispatch ABI version */
        if (dispatch_table->dispatch_version != NC_DISPATCH_VERSION) {
            nclog(NCLOGERR, "Plugin dispatch ABI mismatch for UDF%d: expected %d, got %d",
                  udf_number, NC_DISPATCH_VERSION, dispatch_table->dispatch_version);
            stat = NC_EINVAL;
            goto done;
        }
        
        /* Optionally verify magic number matches */
        if (magic != NULL && strlen(magic_check) > 0) {
            if (strcmp(magic, magic_check) != 0) {
                nclog(NCLOGWARN, "Plugin magic number mismatch for UDF%d: expected %s, got %s",
                      udf_number, magic, magic_check);
            }
        }
    }
#endif
    
    nclog(NCLOGNOTE, "Successfully loaded UDF%d plugin from %s", 
          udf_number, library_path);
    
done:
    /* Handles are intentionally not closed; the OS will reclaim at process exit.
     * The dispatch table and its functions must remain accessible. */
    return stat;
}

/**
 * Load and initialize all UDF plugins from RC file configuration.
 *
 * This function loops through all 10 UDF slots (0-9) and checks for
 * corresponding RC file entries. If both LIBRARY and INIT keys are
 * present for a slot, it attempts to load that plugin.
 *
 * @return NC_NOERR (always succeeds, even if plugins fail to load).
 *
 * @author Edward Hartnett
 * @date 2/2/26
 */
int
NC_udf_load_plugins(void)
{
    int stat = NC_NOERR;
    
    /* Loop through all 10 UDF slots */
    for (int i = 0; i < NC_MAX_UDF_FORMATS; i++) {
        char key_lib[64], key_init[64], key_magic[64];
        const char* lib = NULL;
        const char* init = NULL;
        const char* magic = NULL;
        
        /* Build RC key names for this UDF slot */
        snprintf(key_lib, sizeof(key_lib), "NETCDF.UDF%d.LIBRARY", i);
        snprintf(key_init, sizeof(key_init), "NETCDF.UDF%d.INIT", i);
        snprintf(key_magic, sizeof(key_magic), "NETCDF.UDF%d.MAGIC", i);
        
        /* Look up RC values */
        lib = NC_rclookup(key_lib, NULL, NULL);
        init = NC_rclookup(key_init, NULL, NULL);
        magic = NC_rclookup(key_magic, NULL, NULL);
        
        /* If both LIBRARY and INIT are present, try to load the plugin */
        if (lib && init) {
            if ((stat = load_udf_plugin(i, lib, init, magic))) {
                nclog(NCLOGWARN, "Failed to load UDF%d plugin from %s: %d", i, lib, stat);
            }
        } else if (lib || init) {
            /* Warn about partial configuration */
            nclog(NCLOGWARN, "Ignoring partial UDF%d configuration "
                  "(both NETCDF.UDF%d.LIBRARY and NETCDF.UDF%d.INIT are required)",
                  i, i, i);
        }
    }
    
    /* Always return success - plugin loading failures are not fatal */
    return NC_NOERR;
}