// Initialize the SDK v6.x
if (krispAudioGlobalInit(workingPath) != 0) {
    std::cerr << "Failed to initialize SDK" << std::endl;
    return -1;
}

// Initialize the SDK v5.x
if (krispAudioGlobalInit(workingPath, 1) != 0) {
    std::cerr << "Failed to initialize SDK" << std::endl;
    return -1;
}

// Set the neural network model path
if (krispAudioSetModel(weightConfFilePath)) {
    std::cout << "Faied to set the weight file: " << weight_str << std::endl;
    return -1;
}


// Create audio session
KrispAudioSessionID noiseCancellerSession = krispAudioNcCreateSession(inputSampleRate, 
                                                                      outputSampleRate, 
                                                                      frameDuration, 
                                                                      modelName);
if (noiseCancellerSession == nullptr) {
    std::cerr << "Failed to create noise cancellation session for channel" << std::endl;
    return -1;
}

// For every audio frame, call this function to remove noise
krispAudioNcCleanAmbientNoiseInt16(noiseCancellerSession, 
                                   pFrameIn, 
                                   frameInSize, 
                                   pFrameOut, frameOutSize);


// Close the session and uninitalize the SDK
krispAudioNcCloseSession(noiseCancellerSession);
// Uninitalize the SDK
krispAudioGlobalDestroy();

/// read Krisp allow and block list and the local allow list
preload_krisp_allow_list();
preload_local_allow_list();
preload_krisp_block_list();

// preload the models into the memory
// BVC model
krispAudioSetModel(“hs.c6.f.s.de56df.kw”, "bvc-model-alias");
// NC full band model
krispAudioSetModel(“c6.f.s.ced125.kw”, "nc-fb-model-alias");
// NC wide band model
krispAudioSetModel(“c5.s.w.c9ac8f.kw”, "nc-wb-model-alias");
// NC narrow band model
krispAudioSetModel(“c5.n.s.20949d.kw”, "nc-nb-model-alias");

void on_device_change(DeviceID device) {
		if (current_session) {
				krispAudioNcCloseSession(current_session);
				current_session = 0;
		}
		current_session = create_session_for_device(device);
}

KrispSession create_session_for_device(DeviceID device) {
		if (sampling_rate_below_wide_band(device))
				return create_nc_session(device);
		if (is_headset(device)) {
				if (in_krisp_block_list(device))
						return create_nc_session(device);
				if (in_krisp_allow_list(device))
						return create_bvc_session(device);
				if (in_local_allow_list(device))
						return create_bvc_session(device);
				else {
						bool added;
						consider_add_local_allow_list(device, &added);
						if (added) {
								return create_bvc_session(device);
						}
				}
		}
		return create_nc_session(device);
}

KrispSession create_bvc_session(DeviceID device) {
		// TODO: handle sampling rates, frame duration parameters
		auto s = krispAudioNcCreateSession("bvc-model-alias");
		// TODO: handle error checking
		return s;
}

KrispSession create_nc_session(DeviceID device) {
		auto model_alias_c_str = choose_nc_model(device);
		// TODO: handle sampling rates, frame duration parameters
		auto s = krispAudioNcCreateSession(model_alias_c_str);
		// TODO: handle error checking
		return s;
}

const char * choose_nc_model(DeviceID device) {
		if (sampling_rate(device) > 16000)
				return "nc-fb-model-alias";
		else if (sampling_rate(device > 8000))
				return "nc-wb-model-alias";
		else
				return "nc-nb-model-alias";
}

void consider_add_local_allow_list(DeviceID device, bool &added) {
		// Ask the user to add the device to the local allow list
		// this could be interactive
		bool ask = ask_for_user_input();
		if (ask) {
				add_to_local_allow_list(device);
				added = true;
		} else {
				added = false;
		}
}