#include "load-manager.h"

// Data

UserData_t *UserData;
GSXData_t *GSXData;
paxPayloadData_t *livePaxPayloadData;
paxPayloadData_t* targetPaxPayloadData;
fPayloadData_t *liveFPayloadData;
fPayloadData_t *targetFPayloadData;
FuelData_t *liveFuelData;

// Operational
bool commBusCallbackRegistered;
HANDLE simConnect;
FILE* logFile;

// Init
extern "C" MSFS_CALLBACK void module_init(void) {
    log(stdout, MODULE_NAME"Starting init\n");

    logFile = fopen("\\work\\log.txt", "w");
    if (logFile == NULL)
    {
        log(stderr, MODULE_NAME"Error creating logfile\n");
    }

    UserData = new UserData_t();
    GSXData = new GSXData_t();
    livePaxPayloadData = new paxPayloadData_t();
    targetPaxPayloadData = new paxPayloadData_t();
    liveFPayloadData = new fPayloadData_t();
    targetFPayloadData = new fPayloadData_t();
    liveFuelData = new FuelData_t();

    // SimConnect open
    HRESULT hr;
    hr = SimConnect_Open(&simConnect, "KHOFMANN TFDi MD-11 Load Manager", nullptr, 0, 0, 0);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not open SimConnect connection, terminating.\n");
        return;
    }
    // SimConnect Empty Weight data definition
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_EMPTY_WEIGHT, "EMPTY WEIGHT", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add EMPTY WEIGHT to data definition, terminating.\n");
        return;
    }
    // SimConnect Pax/F Weight data definition
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:1", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:1 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:1", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:1 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:2", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:2 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:2", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:2 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:3", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:3 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:3", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:3 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:4", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:4 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:4", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:4 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:5", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:5 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:5", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:5 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:6", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:6 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:6", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:6 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:7", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:7 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:7", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:7 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:8", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:8 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:8", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:8 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:9", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:9 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:9", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:9 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:10", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:10 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:10", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:10 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:11", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:11 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:11", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:11 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:12", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:12 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:12", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:12 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:13", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:13 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:13", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:13 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:14", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:14 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:14", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:14 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:15", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:15 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:15", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:15 to F data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:16", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:16 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:17", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:17 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:18", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:18 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:19", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:19 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:20", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:20 to PAX data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:21", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:21 to PAX data definition, terminating.\n");
        return;
    }
    // SimConnect Fuel data definition
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL WEIGHT PER GALLON", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL WEIGHT PER GALLON to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK LEFT MAIN QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK LEFT MAIN QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK RIGHT MAIN QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK RIGHT MAIN QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK CENTER QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK CENTER QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK CENTER2 QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK CENTER2 QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK CENTER3 QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK CENTER3 QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK LEFT TIP QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK LEFT TIP QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK RIGHT TIP QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK RIGHT TIP QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK EXTERNAL1 QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK EXTERNAL1 QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK LEFT AUX QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK LEFT AUX QUANTITY to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK RIGHT AUX QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add FUEL TANK RIGHT AUX QUANTITY to data definition, terminating.\n");
        return;
    }
    // GSX LVars
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_BOARDING_STATE", "number", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_BOARDING_STATE to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_DEBOARDING_STATE", "number", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_DEBOARDING_STATE to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_NUMPASSENGERS_BOARDING_TOTAL", "number", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_NUMPASSENGERS_BOARDING_TOTAL to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_NUMPASSENGERS_DEBOARDING_TOTAL", "number", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_NUMPASSENGERS_DEBOARDING_TOTAL to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_BOARDING_CARGO_PERCENT", "number", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_BOARDING_CARGO_PERCENT to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_DEBOARDING_CARGO_PERCENT", "number", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_DEBOARDING_CARGO_PERCENT to data definition, terminating.\n");
        return;
    }
    // User LVars
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_USER_DATA, "L:MD11_EFB_IS_CARGO", "bool", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:MD11_EFB_IS_CARGO to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_USER_DATA, "L:MD11_OPT_ER", "bool", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:MD11_OPT_ER to data definition, terminating.\n");
        return;
    }
    hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_USER_DATA, "L:MD11_EFB_OPTIONS_GENERAL", "number", SIMCONNECT_DATATYPE_FLOAT64);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not add L:MD11_EFB_OPTIONS_GENERAL to data definition, terminating.\n");
        return;
    }
    // SimConnect Requests
    hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_EMPTY_WEIGHT, DATA_DEFINITION_EMPTY_WEIGHT, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not request empty weight\n");
        return;
    }
    hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_PAYLOAD_PAX, DATA_DEFINITION_PAYLOAD_PAX, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not request payload pax\n");
        return;
    }
    hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_PAYLOAD_F, DATA_DEFINITION_PAYLOAD_F, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not request payload f\n");
        return;
    }
    hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_FUEL, DATA_DEFINITION_FUEL, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not request fuel\n");
        return;
    }
    hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_GSX, DATA_DEFINITION_GSX, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not request GSX\n");
        return;
    }
    hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_USER_DATA, DATA_DEFINITION_USER_DATA, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not request user data\n");
        return;
    }
    hr = SimConnect_CallDispatch(simConnect, MyDispatchProc, nullptr);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Could not set dispatch proc, terminating.\n");
        return;
    }

    // CommBus
    commBusCallbackRegistered = fsCommBusRegister(COMM_BUS_UPDATE_TARGET_EVENT, commBusUpdateTargetCallback);
}

// Deinit
extern "C" MSFS_CALLBACK void module_deinit(void) {
    HRESULT hr;
    hr = SimConnect_Close(simConnect);
    if (hr != S_OK) {
        log(stderr, MODULE_NAME"Failed to close SimConnect.\n");
    }

    delete UserData;
    delete GSXData;
    delete livePaxPayloadData;
    delete targetPaxPayloadData;
    delete liveFPayloadData;
    delete targetFPayloadData;
    delete liveFuelData;
}

// Main loop
extern "C" MSFS_CALLBACK bool Load_Manager_gauge_callback(FsContext ctx, int service_id, void* pData) {
    switch (service_id) {
        case PANEL_SERVICE_PRE_UPDATE: {
            sendLiveData();
        }
        default:
            break;
    }

    return true;
}

// CommBus
void commBusUpdateTargetCallback(const char* args, unsigned int size, void* ctx) {
    printf("Target payload update request: %d", parseData(args));
}

// JSON
static int parseData(const char* buf) {
    rapidjson::Document document;
    document.Parse(buf);
    if (document.HasParseError()) {
        return document.GetParseError();
    }

    // Shared part 1
    targetFPayloadData->empty = targetPaxPayloadData->empty = liveFPayloadData->empty;
    targetFPayloadData->pilot = targetPaxPayloadData->pilot = PILOT_WEIGHT(UserData->isImperial);
    targetFPayloadData->firstOfficer = targetPaxPayloadData->firstOfficer = PILOT_WEIGHT(UserData->isImperial);
    targetFPayloadData->engineer = targetPaxPayloadData->engineer = PILOT_WEIGHT(UserData->isImperial);

    // Cargo only
    if (UserData->isCargo) {
        if (document.HasMember("upper1"))
            targetFPayloadData->upper1Left = targetFPayloadData->upper1Right = TO_POUNDS(UserData->isImperial, document["upper1"].GetDouble() / 2.0);
        if (document.HasMember("upper2"))
            targetFPayloadData->upper2Left = targetFPayloadData->upper2Right = TO_POUNDS(UserData->isImperial, document["upper2"].GetDouble() / 2.0);
        if (document.HasMember("upper3"))
            targetFPayloadData->upper3Left = targetFPayloadData->upper3Right = TO_POUNDS(UserData->isImperial, document["upper3"].GetDouble() / 2.0);
        if (document.HasMember("upper4"))
            targetFPayloadData->upper4Left = targetFPayloadData->upper4Right = TO_POUNDS(UserData->isImperial, document["upper4"].GetDouble() / 2.0);
        if (document.HasMember("lowerForward"))targetFPayloadData->lowerForward = TO_POUNDS(UserData->isImperial, document["lowerForward"].GetDouble());
        if (document.HasMember("lowerRear")) targetFPayloadData->lowerRear = TO_POUNDS(UserData->isImperial, document["lowerRear"].GetDouble());
    }
    // Pax only (converted from passengers)
    else {
        if (document.HasMember("cabinCrewFront")) targetPaxPayloadData->cabinCrewFront = TO_POUNDS(UserData->isImperial, document["cabinCrewFront"].GetDouble());
        if (document.HasMember("business1")) 
            targetPaxPayloadData->business1Left = targetPaxPayloadData->business1Center = 
            targetPaxPayloadData->business1Right = TO_POUNDS(UserData->isImperial, (document["business1"].GetDouble() * PAX_WEIGHT(UserData->isImperial)) / 3.0);
        if (document.HasMember("business2"))
            targetPaxPayloadData->business2Left = targetPaxPayloadData->business2Center =
            targetPaxPayloadData->business2Right = TO_POUNDS(UserData->isImperial, (document["business2"].GetDouble() * PAX_WEIGHT(UserData->isImperial)) / 3.0);
        if (document.HasMember("economy1"))
            targetPaxPayloadData->economy1Left = targetPaxPayloadData->economy1Center =
            targetPaxPayloadData->economy1Right = TO_POUNDS(UserData->isImperial, (document["economy1"].GetDouble() * PAX_WEIGHT(UserData->isImperial)) / 3.0);
        if (document.HasMember("economy2"))
            targetPaxPayloadData->economy2Left = targetPaxPayloadData->economy2Center =
            targetPaxPayloadData->economy2Right = TO_POUNDS(UserData->isImperial, (document["economy2"].GetDouble() * PAX_WEIGHT(UserData->isImperial)) / 3.0);
        if (document.HasMember("cabinCrewRear")) targetPaxPayloadData->cabinCrewRear = TO_POUNDS(UserData->isImperial, document["cabinCrewRear"].GetDouble());
        if (document.HasMember("forwardCargo")) targetPaxPayloadData->forwardCargo = TO_POUNDS(UserData->isImperial, document["forwardCargo"].GetDouble());
        if (document.HasMember("rearCargo")) targetPaxPayloadData->rearCargo = TO_POUNDS(UserData->isImperial, document["rearCargo"].GetDouble());

        if (document.HasMember("paxCount")) {
            auto paxCount = document["paxCount"].GetObject();

            if (paxCount.HasMember("businnes1")) targetPaxPayloadData->paxCount.business1 = paxCount["businnes1"].GetUint();
            if (paxCount.HasMember("businnes2")) targetPaxPayloadData->paxCount.business2 = paxCount["businnes2"].GetUint();
            if (paxCount.HasMember("economy1")) targetPaxPayloadData->paxCount.economy1 = paxCount["economy1"].GetUint();
            if (paxCount.HasMember("economy2")) targetPaxPayloadData->paxCount.economy2 = paxCount["economy2"].GetUint();
            targetPaxPayloadData->paxCount.total = targetPaxPayloadData->paxCount.business1 + targetPaxPayloadData->paxCount.business2 +
                                                  targetPaxPayloadData->paxCount.economy1 + targetPaxPayloadData->paxCount.economy2;
        }
        
    }

    // Shared part 2
    targetFPayloadData->leftAux = targetPaxPayloadData->leftAux = UserData->isER ? AUX_WEIGHT(UserData->isImperial) : 0;
    targetFPayloadData->rightAux = targetPaxPayloadData->rightAux = UserData->isER ? AUX_WEIGHT(UserData->isImperial) : 0;

    return 0;
}

static void sendLiveData () {
    rapidjson::Document document;
    rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
    document.SetObject();

    rapidjson::Value payload;
    payload.SetObject();
    rapidjson::Value GSX;
    GSX.SetObject();

    rapidjson::StringBuffer strbuf;
    rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);

    // Shared part 1
    payload.AddMember("empty",
                      FROM_POUNDS(UserData->isImperial, UserData->isCargo ? liveFPayloadData->empty : livePaxPayloadData->empty),
                      allocator);
    payload.AddMember("pilot",
                      FROM_POUNDS(UserData->isImperial, UserData->isCargo ? liveFPayloadData->pilot : livePaxPayloadData->pilot),
                      allocator);
    payload.AddMember("firstOfficer",
                      FROM_POUNDS(UserData->isImperial, UserData->isCargo ? liveFPayloadData->firstOfficer : livePaxPayloadData->firstOfficer),
                      allocator);
    payload.AddMember("engineer",
                      FROM_POUNDS(UserData->isImperial, UserData->isCargo ? liveFPayloadData->engineer : livePaxPayloadData->engineer),
                      allocator);

    // Cargo only
    if (UserData->isCargo) {
        payload.AddMember("upper1", FROM_POUNDS(UserData->isImperial, liveFPayloadData->upper1Left + liveFPayloadData->upper1Right), allocator);
        payload.AddMember("upper2", FROM_POUNDS(UserData->isImperial, liveFPayloadData->upper2Left + liveFPayloadData->upper2Right), allocator);
        payload.AddMember("upper3", FROM_POUNDS(UserData->isImperial, liveFPayloadData->upper3Left + liveFPayloadData->upper3Right), allocator);
        payload.AddMember("upper4", FROM_POUNDS(UserData->isImperial, liveFPayloadData->upper4Left + liveFPayloadData->upper4Right), allocator);
        payload.AddMember("lowerForward", FROM_POUNDS(UserData->isImperial, liveFPayloadData->lowerForward), allocator);
        payload.AddMember("lowerRear", FROM_POUNDS(UserData->isImperial, liveFPayloadData->lowerRear), allocator);
    }
    // Pax only (converted to passengers)
    else {
        payload.AddMember("cabinCrewFront", FROM_POUNDS(UserData->isImperial, livePaxPayloadData->cabinCrewFront), allocator);

        payload.AddMember("businnes1", 
                          (short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->business1Left + livePaxPayloadData->business1Center +
                                             livePaxPayloadData->business1Right) / PAX_WEIGHT(UserData->isImperial)),
                          allocator);
        payload.AddMember("business2", 
                          (short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->business2Left + livePaxPayloadData->business2Center +
                                             livePaxPayloadData->business2Right) / PAX_WEIGHT(UserData->isImperial)),
                          allocator);
        payload.AddMember("economy1",
                          (short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->economy1Left + livePaxPayloadData->economy1Center +
                                             livePaxPayloadData->economy1Right) / PAX_WEIGHT(UserData->isImperial)),
                          allocator);
        payload.AddMember("economy2",
                          (short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->economy2Left + livePaxPayloadData->economy2Center +
                                             livePaxPayloadData->economy2Right) / PAX_WEIGHT(UserData->isImperial)),
                          allocator);
        payload.AddMember("cabinCrewRear", FROM_POUNDS(UserData->isImperial, livePaxPayloadData->cabinCrewRear), allocator);
        payload.AddMember("forwardCargo", FROM_POUNDS(UserData->isImperial, livePaxPayloadData->forwardCargo), allocator);
        payload.AddMember("rearCargo", FROM_POUNDS(UserData->isImperial, livePaxPayloadData->rearCargo), allocator);
    }

    // Shared part 2
    payload.AddMember("leftAux",
                      FROM_POUNDS(UserData->isImperial, UserData->isCargo ? liveFPayloadData->leftAux : livePaxPayloadData->leftAux),
                      allocator);
    payload.AddMember("rightAux",
                      FROM_POUNDS(UserData->isImperial, UserData->isCargo ? liveFPayloadData->rightAux : livePaxPayloadData->rightAux),
                      allocator);
    payload.AddMember("fuel",
                      FROM_POUNDS(UserData->isImperial, 
                                  (liveFuelData->main1 + liveFuelData->main3 + liveFuelData->main2 + liveFuelData->upperAux + liveFuelData->lowerAux + 
                                   liveFuelData->main1Tip + liveFuelData->main3Tip + liveFuelData->tail + liveFuelData->forwardAux1 + liveFuelData->forwardAux2) * 
                                  liveFuelData->poundsPerGallon),
                      allocator);

    // GSX
    GSX.AddMember("boardingState", GSXData->boardingState, allocator);
    GSX.AddMember("deboardingState", GSXData->deboardingState, allocator);
    GSX.AddMember("passengersBoarded", GSXData->passengersBoarded, allocator);
    GSX.AddMember("passengersDeboarded", GSXData->passengersDeboarded, allocator);
    GSX.AddMember("cargoBoarded", GSXData->cargoBoarded, allocator);
    GSX.AddMember("cargoDeboarded", GSXData->cargoDeboarded, allocator);

    // Construct document
    document.AddMember("payload", payload.Move(), allocator);
    document.AddMember("GSX", GSX.Move(), allocator);

    // Write to CommBus
    document.Accept(writer);

    fsCommBusCall(COMM_BUS_LIVE_DATA_EVENT, strbuf.GetString(), strbuf.GetSize(), FsCommBusBroadcast_JS);
}

// Setting weights
static void setWeights() {
    // Prep
    if (UserData->isCargo) {
    }
}

// Logfile
void log(FILE* file, const char* format, void* optionalElement)
{
    if (logFile != NULL)
    {
        fprintf(logFile, format, optionalElement);
        fflush(logFile);
    }
    fprintf(file, format, optionalElement);
}

// SimConnect
void CALLBACK MyDispatchProc(SIMCONNECT_RECV* pData, DWORD cbData, void* pContext) {
    switch (pData->dwID) {
        case SIMCONNECT_RECV_ID_SIMOBJECT_DATA: {
            SIMCONNECT_RECV_SIMOBJECT_DATA* pObjData = (SIMCONNECT_RECV_SIMOBJECT_DATA*)pData;
            switch (pObjData->dwRequestID) {
                case DATA_REQUEST_EMPTY_WEIGHT: {
                    liveFPayloadData->empty = livePaxPayloadData->empty = *((double*)&pObjData->dwData);
                    break;
                }
                case DATA_REQUEST_PAYLOAD_F: {
                    fPayloadData_t* data = (fPayloadData_t*)&pObjData->dwData;
                    data->empty = liveFPayloadData->empty;
                    memcpy(liveFPayloadData, data, sizeof(fPayloadData_t));
                    break;
                }
                case DATA_REQUEST_PAYLOAD_PAX: {
                    paxPayloadData_t* data = (paxPayloadData_t*)&pObjData->dwData;
                    data->empty = livePaxPayloadData->empty;
                    memcpy(livePaxPayloadData, data, sizeof(paxPayloadData_t));
                    break;
                }
                case DATA_REQUEST_FUEL: {
                    FuelData_t* data = (FuelData_t*)&pObjData->dwData;
                    memcpy(liveFuelData, data, sizeof(FuelData_t));
                    break;
                }
                case DATA_REQUEST_GSX: {
                    GSXData_t* data = (GSXData_t*)&pObjData->dwData;
                    memcpy(GSXData, data, sizeof(GSXData_t));
                    break;
                }
                case DATA_REQUEST_USER_DATA: {
                    UserData_t* data = (UserData_t*)&pObjData->dwData;
                    data->isImperial = ((long)data->isImperial) & 1;
                    memcpy(UserData, data, sizeof(UserData_t));
                    break;
                }
                default: {
                    break;
                }
            }
            break;
        }
        case SIMCONNECT_RECV_ID_EXCEPTION:
        {
            SIMCONNECT_RECV_EXCEPTION* pEx = (SIMCONNECT_RECV_EXCEPTION*)pData;
            log(stderr, MODULE_NAME"SimConnect Exception: %i\n", &pEx->dwException);

            break;
        }
        default: {
            break;
        }
    }
}