// Function to write inputPCM as a wav file
void writeInputPCMAsWavFile(short* inputPCM, uint32_t sampleCount, uint16_t channelCount, uint32_t sampleRate) {
    // Open the file
    FILE* file = fopen("C:\\Users\\MenguezG\\Desktop\\input.wav", "wb");
    if (file == NULL) {
        mumbleAPI.log(ownID, "Failed to open file");
        return;
    }

    // Write wav header
    uint16_t bitsPerSample = 16;
    uint32_t byteRate = sampleRate * channelCount * bitsPerSample / 8;
    uint16_t blockAlign = channelCount * bitsPerSample / 8;
    uint32_t dataSize = sampleCount * channelCount * bitsPerSample / 8;
    uint32_t fileSize = 36 + dataSize;

    // Write RIFF header
    fwrite("RIFF", 1, 4, file);
    fwrite(&fileSize, 4, 1, file);
    fwrite("WAVE", 1, 4, file);

    // Write fmt subchunk
    fwrite("fmt ", 1, 4, file);
    uint32_t fmtSize = 16;
    fwrite(&fmtSize, 4, 1, file);
    uint16_t audioFormat = 1;
    fwrite(&audioFormat, 2, 1, file);
    fwrite(&channelCount, 2, 1, file);
    fwrite(&sampleRate, 4, 1, file);
    fwrite(&byteRate, 4, 1, file);
    fwrite(&blockAlign, 2, 1, file);
    fwrite(&bitsPerSample, 2, 1, file);

    // Write data subchunk
    fwrite("data", 1, 4, file);
    fwrite(&dataSize, 4, 1, file);

    // Write audio data
    for (uint32_t i = 0; i < sampleCount; i++) {
        for (uint16_t j = 0; j < channelCount; j++) {
            short sample = inputPCM[i * channelCount + j];
            fwrite(&sample, sizeof(short), 1, file);
        }
    }

    fclose(file);
}


// Global variables to accumulate samples
std::vector<short> accumulatedSamples;
uint32_t accumulatedSampleCount = 0;
static const uint32_t MAX_ACCUMULATED_SAMPLES = 48000;

// Function to accumulate samples and call writeInputPCMAsWavFile
void accumulateAndWriteInputPCM(short* inputPCM, uint32_t sampleCount, uint16_t channelCount, uint32_t sampleRate, bool isSpeech) {
    for (uint32_t i = 0; i < sampleCount; i++) {
        for (uint16_t j = 0; j < channelCount; j++) {
            accumulatedSamples.push_back(inputPCM[i * channelCount + j]);
        }
    }

    accumulatedSampleCount += sampleCount;

    // Check if 48000 samples have been accumulated
    if (accumulatedSamples.size() >= MAX_ACCUMULATED_SAMPLES * channelCount) {
        mumbleAPI.log(ownID, "Writing accumulated samples as a wav file");

        // Call the function to write accumulated samples as a wav file
        writeInputPCMAsWavFile(accumulatedSamples.data(), accumulatedSamples.size() / channelCount, channelCount, sampleRate);

        // Clear the accumulated samples
        accumulatedSamples.clear();
    }
}

// On audio input
bool mumble_onAudioInput(short* inputPCM, uint32_t sampleCount, uint16_t channelCount, uint32_t sampleRate, bool isSpeech) {
    if (isSpeech) {
        std::string message = "Speech detected (number of samples: " + std::to_string(sampleCount) + ", number of channels: " + std::to_string(channelCount) + ", rate: " + std::to_string(sampleRate) + ")";
        mumbleAPI.log(ownID, message.c_str());
    }
    else {
        std::string message = "Noise detected (number of samples: " + std::to_string(sampleCount) + ", number of channels: " + std::to_string(channelCount) + ", rate: " + std::to_string(sampleRate) + ")";
        mumbleAPI.log(ownID, message.c_str());
    }

    // Call the function to accumulate samples and write inputPCM as a wav file
    accumulateAndWriteInputPCM(inputPCM, sampleCount, channelCount, sampleRate, isSpeech);
    //writeInputPCMAsWavFile(inputPCM, sampleCount, channelCount, sampleRate);

    // release the memory
    mumbleAPI.freeMemory(ownID, inputPCM);

    return false;
}