/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <getopt.h>
#include <stddef.h>
#include <stdint.h>
#include <sys/stat.h>
#include <vector>

#include <audio_effects/effect_aec.h>
#include <audio_effects/effect_agc.h>
#include <audio_effects/effect_agc2.h>
#include <audio_effects/effect_ns.h>
#include <audio_utils/channels.h>
#include <log/log.h>

// This is the only symbol that needs to be imported
extern audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM;

//------------------------------------------------------------------------------
// local definitions
//------------------------------------------------------------------------------

// types of pre processing modules
enum PreProcId {
    PREPROC_AGC,  // Automatic Gain Control
    PREPROC_AGC2,  // Automatic Gain Control 2
    PREPROC_AEC,  // Acoustic Echo Canceler
    PREPROC_NS,   // Noise Suppressor
    PREPROC_NUM_EFFECTS
};

enum PreProcParams {
    ARG_HELP = 1,
    ARG_INPUT,
    ARG_OUTPUT,
    ARG_FAR,
    ARG_FS,
    ARG_CH_MASK,
    ARG_AGC_TGT_LVL,
    ARG_AGC_COMP_LVL,
    ARG_AEC_DELAY,
    ARG_NS_LVL,
    ARG_AGC2_GAIN,
    ARG_AGC2_LVL,
    ARG_AGC2_SAT_MGN,
    ARG_FILE_CHANNELS,
    ARG_MONO_MODE
};

struct preProcConfigParams_t {
    int samplingFreq = 16000;
    audio_channel_mask_t chMask = AUDIO_CHANNEL_IN_MONO;
    int nsLevel = 0;         // a value between 0-3
    int agcTargetLevel = 3;  // in dB
    int agcCompLevel = 9;    // in dB
    float agc2Gain = 0.f;              // in dB
    float agc2SaturationMargin = 2.f;  // in dB
    int agc2Level = 0;                 // either kRms(0) or kPeak(1)
    int aecDelay = 0;  // in ms
    int fileChannels = 1;
    int monoMode = 0;
};

const effect_uuid_t kPreProcUuids[PREPROC_NUM_EFFECTS] = {
        {0xaa8130e0, 0x66fc, 0x11e0, 0xbad0, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},  // agc uuid
        {0x89f38e65, 0xd4d2, 0x4d64, 0xad0e, {0x2b, 0x3e, 0x79, 0x9e, 0xa8, 0x86}},  // agc2 uuid
        {0xbb392ec0, 0x8d4d, 0x11e0, 0xa896, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},  // aec uuid
        {0xc06c8400, 0x8e06, 0x11e0, 0x9cb6, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},  // ns  uuid
};

constexpr audio_channel_mask_t kPreProcConfigChMask[] = {
        AUDIO_CHANNEL_IN_MONO,
        AUDIO_CHANNEL_IN_STEREO,
        AUDIO_CHANNEL_IN_FRONT_BACK,
        AUDIO_CHANNEL_IN_6,
        AUDIO_CHANNEL_IN_2POINT0POINT2,
        AUDIO_CHANNEL_IN_2POINT1POINT2,
        AUDIO_CHANNEL_IN_3POINT0POINT2,
        AUDIO_CHANNEL_IN_3POINT1POINT2,
        AUDIO_CHANNEL_IN_5POINT1,
        AUDIO_CHANNEL_IN_VOICE_UPLINK_MONO,
        AUDIO_CHANNEL_IN_VOICE_DNLINK_MONO,
        AUDIO_CHANNEL_IN_VOICE_CALL_MONO,
};

constexpr int kPreProcConfigChMaskCount = std::size(kPreProcConfigChMask);

void printUsage() {
    printf("\nUsage: ");
    printf("\n     <executable> [options]\n");
    printf("\nwhere options are, ");
    printf("\n     --input <inputfile>");
    printf("\n           path to the input file");
    printf("\n     --output <outputfile>");
    printf("\n           path to the output file");
    printf("\n     --help");
    printf("\n           Prints this usage information");
    printf("\n     --fs <sampling_freq>");
    printf("\n           Sampling frequency in Hz, default 16000.");
    printf("\n     --ch_mask <channel_mask>\n");
    printf("\n         0  - AUDIO_CHANNEL_IN_MONO");
    printf("\n         1  - AUDIO_CHANNEL_IN_STEREO");
    printf("\n         2  - AUDIO_CHANNEL_IN_FRONT_BACK");
    printf("\n         3  - AUDIO_CHANNEL_IN_6");
    printf("\n         4  - AUDIO_CHANNEL_IN_2POINT0POINT2");
    printf("\n         5  - AUDIO_CHANNEL_IN_2POINT1POINT2");
    printf("\n         6  - AUDIO_CHANNEL_IN_3POINT0POINT2");
    printf("\n         7  - AUDIO_CHANNEL_IN_3POINT1POINT2");
    printf("\n         8  - AUDIO_CHANNEL_IN_5POINT1");
    printf("\n         9  - AUDIO_CHANNEL_IN_VOICE_UPLINK_MONO");
    printf("\n         10 - AUDIO_CHANNEL_IN_VOICE_DNLINK_MONO ");
    printf("\n         11 - AUDIO_CHANNEL_IN_VOICE_CALL_MONO ");
    printf("\n         default 0");
    printf("\n     --far <farend_file>");
    printf("\n           Path to far-end file needed for echo cancellation");
    printf("\n     --aec");
    printf("\n           Enable Echo Cancellation, default disabled");
    printf("\n     --ns");
    printf("\n           Enable Noise Suppression, default disabled");
    printf("\n     --agc");
    printf("\n           Enable Gain Control, default disabled");
    printf("\n     --agc2");
    printf("\n           Enable Gain Controller 2, default disabled");
    printf("\n     --ns_lvl <ns_level>");
    printf("\n           Noise Suppression level in dB, default value 0dB");
    printf("\n     --agc_tgt_lvl <target_level>");
    printf("\n           AGC Target Level in dB, default value 3dB");
    printf("\n     --agc_comp_lvl <comp_level>");
    printf("\n           AGC Comp Level in dB, default value 9dB");
    printf("\n     --agc2_gain <fixed_digital_gain>");
    printf("\n           AGC Fixed Digital Gain in dB, default value 0dB");
    printf("\n     --agc2_lvl <level_estimator>");
    printf("\n           AGC Adaptive Digital Level Estimator, default value kRms");
    printf("\n     --agc2_sat_mgn <saturation_margin>");
    printf("\n           AGC Adaptive Digital Saturation Margin in dB, default value 2dB");
    printf("\n     --aec_delay <delay>");
    printf("\n           AEC delay value in ms, default value 0ms");
    printf("\n     --fch <fileChannels>");
    printf("\n           number of channels in the input file");
    printf("\n     --mono <Mono Mode>");
    printf("\n           Mode to make data of all channels the same as first channel");
    printf("\n");
}

constexpr float kTenMilliSecVal = 0.01;

int preProcCreateEffect(effect_handle_t* pEffectHandle, uint32_t effectType,
                        effect_config_t* pConfig, int sessionId, int ioId) {
    if (int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.create_effect(&kPreProcUuids[effectType],
                                                                 sessionId, ioId, pEffectHandle);
        status != 0) {
        ALOGE("Audio Preprocessing create returned an error = %d\n", status);
        return EXIT_FAILURE;
    }
    int reply = 0;
    uint32_t replySize = sizeof(reply);
    if (effectType == PREPROC_AEC) {
        (**pEffectHandle)
                ->command(*pEffectHandle, EFFECT_CMD_SET_CONFIG_REVERSE, sizeof(effect_config_t),
                          pConfig, &replySize, &reply);
    }
    (**pEffectHandle)
            ->command(*pEffectHandle, EFFECT_CMD_SET_CONFIG, sizeof(effect_config_t), pConfig,
                      &replySize, &reply);
    return reply;
}

int preProcSetConfigParam(uint32_t paramType, uint32_t paramValue, effect_handle_t effectHandle) {
    int reply = 0;
    uint32_t replySize = sizeof(reply);
    uint32_t paramData[2] = {paramType, paramValue};
    effect_param_t* effectParam = (effect_param_t*)malloc(sizeof(*effectParam) + sizeof(paramData));
    memcpy(&effectParam->data[0], &paramData[0], sizeof(paramData));
    effectParam->psize = sizeof(paramData[0]);
    (*effectHandle)
            ->command(effectHandle, EFFECT_CMD_SET_PARAM, sizeof(effect_param_t), effectParam,
                      &replySize, &reply);
    free(effectParam);
    return reply;
}

int main(int argc, const char* argv[]) {
    if (argc == 1) {
        printUsage();
        return EXIT_FAILURE;
    }

    // Print the arguments passed
    for (int i = 1; i < argc; i++) {
        printf("%s ", argv[i]);
    }

    const char* inputFile = nullptr;
    const char* outputFile = nullptr;
    const char* farFile = nullptr;
    int effectEn[PREPROC_NUM_EFFECTS] = {0};
    struct preProcConfigParams_t preProcCfgParams {};

    const option long_opts[] = {
            {"help", no_argument, nullptr, ARG_HELP},
            {"input", required_argument, nullptr, ARG_INPUT},
            {"output", required_argument, nullptr, ARG_OUTPUT},
            {"far", required_argument, nullptr, ARG_FAR},
            {"fs", required_argument, nullptr, ARG_FS},
            {"ch_mask", required_argument, nullptr, ARG_CH_MASK},
            {"agc_tgt_lvl", required_argument, nullptr, ARG_AGC_TGT_LVL},
            {"agc_comp_lvl", required_argument, nullptr, ARG_AGC_COMP_LVL},
            {"agc2_gain", required_argument, nullptr, ARG_AGC2_GAIN},
            {"agc2_lvl", required_argument, nullptr, ARG_AGC2_LVL},
            {"agc2_sat_mgn", required_argument, nullptr, ARG_AGC2_SAT_MGN},
            {"aec_delay", required_argument, nullptr, ARG_AEC_DELAY},
            {"ns_lvl", required_argument, nullptr, ARG_NS_LVL},
            {"aec", no_argument, &effectEn[PREPROC_AEC], 1},
            {"agc", no_argument, &effectEn[PREPROC_AGC], 1},
            {"agc2", no_argument, &effectEn[PREPROC_AGC2], 1},
            {"ns", no_argument, &effectEn[PREPROC_NS], 1},
            {"fch", required_argument, nullptr, ARG_FILE_CHANNELS},
            {"mono", no_argument, &preProcCfgParams.monoMode, 1},
            {nullptr, 0, nullptr, 0},
    };

    while (true) {
        const int opt = getopt_long(argc, (char* const*)argv, "i:o:", long_opts, nullptr);
        if (opt == -1) {
            break;
        }
        switch (opt) {
            case ARG_HELP:
                printUsage();
                return 0;
            case ARG_INPUT: {
                inputFile = (char*)optarg;
                break;
            }
            case ARG_OUTPUT: {
                outputFile = (char*)optarg;
                break;
            }
            case ARG_FAR: {
                farFile = (char*)optarg;
                break;
            }
            case ARG_FS: {
                preProcCfgParams.samplingFreq = atoi(optarg);
                break;
            }
            case ARG_CH_MASK: {
                int chMaskIdx = atoi(optarg);
                if (chMaskIdx < 0 or chMaskIdx > kPreProcConfigChMaskCount) {
                    ALOGE("Channel Mask index not in correct range\n");
                    printUsage();
                    return EXIT_FAILURE;
                }
                preProcCfgParams.chMask = kPreProcConfigChMask[chMaskIdx];
                break;
            }
            case ARG_AGC_TGT_LVL: {
                preProcCfgParams.agcTargetLevel = atoi(optarg);
                break;
            }
            case ARG_AGC_COMP_LVL: {
                preProcCfgParams.agcCompLevel = atoi(optarg);
                break;
            }
            case ARG_AGC2_GAIN: {
                preProcCfgParams.agc2Gain = atof(optarg);
                break;
            }
            case ARG_AGC2_LVL: {
                preProcCfgParams.agc2Level = atoi(optarg);
                break;
            }
            case ARG_AGC2_SAT_MGN: {
                preProcCfgParams.agc2SaturationMargin = atof(optarg);
                break;
            }
            case ARG_AEC_DELAY: {
                preProcCfgParams.aecDelay = atoi(optarg);
                break;
            }
            case ARG_NS_LVL: {
                preProcCfgParams.nsLevel = atoi(optarg);
                break;
            }
            case ARG_FILE_CHANNELS: {
                preProcCfgParams.fileChannels = atoi(optarg);
                break;
            }
            case ARG_MONO_MODE: {
                preProcCfgParams.monoMode = 1;
                break;
            }
            default:
                break;
        }
    }

    if (inputFile == nullptr) {
        ALOGE("Error: missing input file\n");
        printUsage();
        return EXIT_FAILURE;
    }

    std::unique_ptr<FILE, decltype(&fclose)> inputFp(fopen(inputFile, "rb"), &fclose);
    if (inputFp == nullptr) {
        ALOGE("Cannot open input file %s\n", inputFile);
        return EXIT_FAILURE;
    }

    std::unique_ptr<FILE, decltype(&fclose)> farFp(fopen(farFile, "rb"), &fclose);
    std::unique_ptr<FILE, decltype(&fclose)> outputFp(fopen(outputFile, "wb"), &fclose);
    if (effectEn[PREPROC_AEC]) {
        if (farFile == nullptr) {
            ALOGE("Far end signal file required for echo cancellation \n");
            return EXIT_FAILURE;
        }
        if (farFp == nullptr) {
            ALOGE("Cannot open far end stream file %s\n", farFile);
            return EXIT_FAILURE;
        }
        struct stat statInput, statFar;
        (void)fstat(fileno(inputFp.get()), &statInput);
        (void)fstat(fileno(farFp.get()), &statFar);
        if (statInput.st_size != statFar.st_size) {
            ALOGE("Near and far end signals are of different sizes");
            return EXIT_FAILURE;
        }
    }
    if (outputFile != nullptr && outputFp == nullptr) {
        ALOGE("Cannot open output file %s\n", outputFile);
        return EXIT_FAILURE;
    }

    int32_t sessionId = 1;
    int32_t ioId = 1;
    effect_handle_t effectHandle[PREPROC_NUM_EFFECTS] = {nullptr};
    effect_config_t config;
    config.inputCfg.samplingRate = config.outputCfg.samplingRate = preProcCfgParams.samplingFreq;
    config.inputCfg.channels = config.outputCfg.channels = preProcCfgParams.chMask;
    config.inputCfg.format = config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;

    // Create all the effect handles
    for (int i = 0; i < PREPROC_NUM_EFFECTS; i++) {
        if (int status = preProcCreateEffect(&effectHandle[i], i, &config, sessionId, ioId);
            status != 0) {
            ALOGE("Create effect call returned error %i", status);
            return EXIT_FAILURE;
        }
    }

    for (int i = 0; i < PREPROC_NUM_EFFECTS; i++) {
        if (effectEn[i] == 1) {
            int reply = 0;
            uint32_t replySize = sizeof(reply);
            (*effectHandle[i])
                    ->command(effectHandle[i], EFFECT_CMD_ENABLE, 0, nullptr, &replySize, &reply);
            if (reply != 0) {
                ALOGE("Command enable call returned error %d\n", reply);
                return EXIT_FAILURE;
            }
        }
    }

    // Set Config Params of the effects
    if (effectEn[PREPROC_AGC]) {
        if (int status = preProcSetConfigParam(AGC_PARAM_TARGET_LEVEL,
                                               (uint32_t)preProcCfgParams.agcTargetLevel,
                                               effectHandle[PREPROC_AGC]);
            status != 0) {
            ALOGE("Invalid AGC Target Level. Error %d\n", status);
            return EXIT_FAILURE;
        }
        if (int status = preProcSetConfigParam(AGC_PARAM_COMP_GAIN,
                                               (uint32_t)preProcCfgParams.agcCompLevel,
                                               effectHandle[PREPROC_AGC]);
            status != 0) {
            ALOGE("Invalid AGC Comp Gain. Error %d\n", status);
            return EXIT_FAILURE;
        }
    }
    if (effectEn[PREPROC_AGC2]) {
        if (int status = preProcSetConfigParam(AGC2_PARAM_FIXED_DIGITAL_GAIN,
                                               (float)preProcCfgParams.agc2Gain,
                                               effectHandle[PREPROC_AGC2]);
            status != 0) {
            ALOGE("Invalid AGC2 Fixed Digital Gain. Error %d\n", status);
            return EXIT_FAILURE;
        }
        if (int status = preProcSetConfigParam(AGC2_PARAM_ADAPT_DIGI_LEVEL_ESTIMATOR,
                                               (uint32_t)preProcCfgParams.agc2Level,
                                               effectHandle[PREPROC_AGC2]);
            status != 0) {
            ALOGE("Invalid AGC2 Level Estimator. Error %d\n", status);
            return EXIT_FAILURE;
        }
        if (int status = preProcSetConfigParam(AGC2_PARAM_ADAPT_DIGI_EXTRA_SATURATION_MARGIN,
                                               (float)preProcCfgParams.agc2SaturationMargin,
                                               effectHandle[PREPROC_AGC2]);
            status != 0) {
            ALOGE("Invalid AGC2 Saturation Margin. Error %d\n", status);
            return EXIT_FAILURE;
        }
    }
    if (effectEn[PREPROC_NS]) {
        if (int status = preProcSetConfigParam(NS_PARAM_LEVEL, (uint32_t)preProcCfgParams.nsLevel,
                                               effectHandle[PREPROC_NS]);
            status != 0) {
            ALOGE("Invalid Noise Suppression level Error %d\n", status);
            return EXIT_FAILURE;
        }
    }

    // Process Call
    const int frameLength = (int)(preProcCfgParams.samplingFreq * kTenMilliSecVal);
    const int ioChannelCount = audio_channel_count_from_in_mask(preProcCfgParams.chMask);
    const int fileChannelCount = preProcCfgParams.fileChannels;
    const int ioFrameSize = ioChannelCount * sizeof(short);
    const int inFrameSize = fileChannelCount * sizeof(short);
    int frameCounter = 0;
    while (true) {
        std::vector<short> in(frameLength * ioChannelCount);
        std::vector<short> out(frameLength * ioChannelCount);
        std::vector<short> farIn(frameLength * ioChannelCount);
        size_t samplesRead = fread(in.data(), inFrameSize, frameLength, inputFp.get());
        if (samplesRead == 0) {
            break;
        }
        if (fileChannelCount != ioChannelCount) {
            adjust_channels(in.data(), fileChannelCount, in.data(), ioChannelCount, sizeof(short),
                            frameLength * inFrameSize);
            if (preProcCfgParams.monoMode == 1) {
                for (int i = 0; i < frameLength; ++i) {
                    auto* fp = &in[i * ioChannelCount];
                    std::fill(fp + 1, fp + ioChannelCount, *fp);  // replicate ch 0
                }
            }
        }
        audio_buffer_t inputBuffer, outputBuffer;
        audio_buffer_t farInBuffer{};
        inputBuffer.frameCount = frameLength;
        outputBuffer.frameCount = frameLength;
        inputBuffer.s16 = in.data();
        outputBuffer.s16 = out.data();

        if (farFp != nullptr) {
            samplesRead = fread(farIn.data(), inFrameSize, frameLength, farFp.get());
            if (samplesRead == 0) {
                break;
            }
            if (fileChannelCount != ioChannelCount) {
                adjust_channels(farIn.data(), fileChannelCount, farIn.data(), ioChannelCount,
                                sizeof(short), frameLength * inFrameSize);
                if (preProcCfgParams.monoMode == 1) {
                    for (int i = 0; i < frameLength; ++i) {
                        auto* fp = &farIn[i * ioChannelCount];
                        std::fill(fp + 1, fp + ioChannelCount, *fp);  // replicate ch 0
                    }
                }
            }

            farInBuffer.frameCount = frameLength;
            farInBuffer.s16 = farIn.data();
        }

        for (int i = 0; i < PREPROC_NUM_EFFECTS; i++) {
            if (effectEn[i] == 1) {
                if (i == PREPROC_AEC) {
                    if (int status = preProcSetConfigParam(AEC_PARAM_ECHO_DELAY,
                                                           (uint32_t)preProcCfgParams.aecDelay,
                                                           effectHandle[PREPROC_AEC]);
                        status != 0) {
                        ALOGE("preProcSetConfigParam returned Error %d\n", status);
                        return EXIT_FAILURE;
                    }
                }
                if (int status = (*effectHandle[i])
                                         ->process(effectHandle[i], &inputBuffer, &outputBuffer);
                    status != 0) {
                    ALOGE("\nError: Process i = %d returned with error %d\n", i, status);
                    return EXIT_FAILURE;
                }
                if (i == PREPROC_AEC) {
                    if (int status = (*effectHandle[i])
                                             ->process_reverse(effectHandle[i], &farInBuffer,
                                                               &outputBuffer);
                        status != 0) {
                        ALOGE("\nError: Process reverse i = %d returned with error %d\n", i,
                              status);
                        return EXIT_FAILURE;
                    }
                }
            }
        }
        if (outputFp != nullptr) {
            if (fileChannelCount != ioChannelCount) {
                adjust_channels(out.data(), ioChannelCount, out.data(), fileChannelCount,
                                sizeof(short), frameLength * ioFrameSize);
            }
            size_t samplesWritten =
                    fwrite(out.data(), inFrameSize, outputBuffer.frameCount, outputFp.get());
            if (samplesWritten != outputBuffer.frameCount) {
                ALOGE("\nError: Output file writing failed");
                break;
            }
        }
        frameCounter += frameLength;
    }
    printf("frameCounter: [%d]\n", frameCounter);
    // Release all the effect handles created
    for (int i = 0; i < PREPROC_NUM_EFFECTS; i++) {
        if (int status = AUDIO_EFFECT_LIBRARY_INFO_SYM.release_effect(effectHandle[i]);
            status != 0) {
            ALOGE("Audio Preprocessing release returned an error = %d\n", status);
            return EXIT_FAILURE;
        }
    }
    return EXIT_SUCCESS;
}