#define LGS_MAX_MESSAGE_SIZE 256

struct lgs_context_t {};
struct lgs_connection_t {};
struct lgs_request_t {};

typedef struct {
    struct lgs_connection_t* connection;
    struct lgs_request_t* request;
    void* user_ptr;
    char message[LGS_MAX_MESSAGE_SIZE];
} lgs_result_info_t;

typedef struct {
    void* user_ptr;

    void(*callback_progress)(const lgs_result_info_t*);
    void(*callback_succeeded)(const lgs_result_info_t*);
    void(*callback_failed)(const lgs_result_info_t*);
} lgs_request_params_t;

typedef struct {
    uint32_t request_timeout;
    size_t list_capacity;
} lgs_device_enumeration_params_t;

typedef struct {
    lgs_connection_settings_t connection_settings;
    char name[128];
    char serial_number[32];
    char hw_version[32];
    char fw_version[32];
    bool is_compatible;
} lgs_enumerated_device_info_t;

struct lgs_request_t*
lgs_req_cmd_enumerate_devices(struct lgs_context_t* ctx,
    const lgs_request_params_t* request_params,
    const lgs_device_enumeration_params_t* enumeration_params,
    lgs_enumerated_device_info_t* list,
    size_t* list_size);

------------------------

class
APIWrapper
{
    init()
    {
        //  Set up the callbacks…

        self.reqParams.user_ptr = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())

        self.reqParams.callback_progress =
        { inInfo in
            let info = unsafeBitCast(inInfo, to: lgs_result_info_t.self)
            let this = Unmanaged<APIWrapper>.fromOpaque(info.user_ptr).takeUnretainedValue()
            this.callbackProgress(info: info)
        }

        self.reqParams.callback_succeeded =
        { inInfo in
            let info = unsafeBitCast(inInfo, to: lgs_result_info_t.self)
            let this = Unmanaged<APIWrapper>.fromOpaque(info.user_ptr).takeUnretainedValue()
            this.callbackFailed(info: info)
        }

        self.reqParams.callback_failed =
        { inInfo in
            let info = unsafeBitCast(inInfo, to: lgs_result_info_t.self)
            let this = Unmanaged<APIWrapper>.fromOpaque(info.user_ptr).takeUnretainedValue()
            this.callbackSucceeded(info: info)
        }
    }

    func
    enumerateDevices()
    {
        var params = lgs_device_enumeration_params_t()
        params.list_capacity = 10
        params.request_timeout = 2000

        var count: Int = 0
        let req = lgs_req_cmd_enumerate_devices(self.ctx,
                                                    &self.reqParams,
                                                    &params,
                                                    self.devices,
                                                    &count)
    }

    var         devices                     =   UnsafeMutablePointer<lgs_enumerated_device_info_t>.allocate(capacity: 10)

    var         ctx:        OpaquePointer?
    var         reqParams                   =   lgs_request_params_t()

    func
    callbackProgress(info inInfo: lgs_result_info_t)
    {
        debugLog("Progress")
    }

    func
    callbackSucceeded(info inInfo: lgs_result_info_t)
    {
        debugLog("Succeeded")
    }

    func
    callbackFailed(info inInfo: lgs_result_info_t)
    {
        debugLog("Failed")
    }
}