/*
 * Copyright 2020 Rockchip Electronics Co. LTD
 *
 * 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 <stdbool.h>
#include <stdint.h>
#include <sys/time.h>
#include <stdbool.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <errno.h>
#include <pthread.h>
#include <pwd.h>
#include <stdarg.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/prctl.h>
#include <unistd.h>
#include <sys/ioctl.h>

#include "uac_log.h"
#include "uac_control.h"
#include <rt_header.h>
#include <rt_metadata.h>
#include <RTUACGraph.h>
#include <RTMediaBuffer.h>
#include <rt_metadata.h>
#include <RTMediaMetaKeys.h>

#ifdef LOG_TAG
#undef LOG_TAG
#define LOG_TAG "uac"
#endif // LOG_TAG

/*
 * pc datas -> rv1109
 * usb record->xxxx process->speaker playback
 */
#define UAC_USB_RECORD_SPK_PLAY_CONFIG_FILE "/oem/usr/share/uac_app/usb_recode_speaker_playback.json"

/*
 * rv1109 datas -> pc
 * mic record->>xxxx process->usb playback
 */
#define UAC_MIC_RECORD_USB_PLAY_CONFIG_FILE "/oem/usr/share/uac_app/mic_recode_usb_playback.json"

typedef struct _UACStream {
    pthread_mutex_t mutex;
    UACAudioConfig  config;
    RTUACGraph     *uac;
} UACStream;

typedef struct _UACControl {
    UACStream     stream[UAC_STREAM_MAX];
} UACControl;

typedef enum UACConfigCmd {
    UAC_SET_SAMPLE_RATE = 1,
    UAC_SET_VOLUME,
    UAC_SET_PPM,
} UACConfigCmd;

UACControl *gUAControl = NULL;

extern void uac_set_sample_rate(int type, int samplerate);
extern void uac_set_volume(int type, int volume);
extern void uac_set_mute(int type, int  mute);
extern int  uac_set_parameter(RTUACGraph* uac, int type, UACAudioConfig& config, UACConfigCmd cmd);

int uac_control_create() {
    gUAControl = (UACControl*)calloc(1, sizeof(UACControl));
    if (!gUAControl) {
        ALOGE("fail to malloc memory!\n");
        return -1;
    }

    for (int i = 0; i < UAC_STREAM_MAX; i++) {
        pthread_mutex_init(&gUAControl->stream[i].mutex, NULL);
        gUAControl->stream[i].uac = NULL;

        if (UAC_STREAM_PLAYBACK == i) {
            gUAControl->stream[i].config.samplerate = 48000;
        } else {
            gUAControl->stream[i].config.samplerate = 48000;
        }

        gUAControl->stream[i].config.volume = 1.0;
        gUAControl->stream[i].config.mute = 0;
        gUAControl->stream[i].config.ppm = 0;
    }

    return 0;
}

void uac_control_destory() {
    if (gUAControl == NULL)
        return;

    for (int i = 0; i < UAC_STREAM_MAX; i++) {
        if (gUAControl->stream[i].uac != NULL) {
            delete(gUAControl->stream[i].uac);
            gUAControl->stream[i].uac = NULL;
        }
        pthread_mutex_destroy(&gUAControl->stream[i].mutex);
    }

    gUAControl = NULL;
}

void uac_set_sample_rate(int type, int samplerate) {
    if (gUAControl == NULL)
        return;

    if ((type < 0) || (type >= UAC_STREAM_MAX))
        return;

    ALOGD("type = %d, samplerate = %d\n", type, samplerate);
    pthread_mutex_lock(&gUAControl->stream[type].mutex);
    gUAControl->stream[type].config.samplerate = samplerate;
    /*
     * if uac is already start, set samplerate
     */
    RTUACGraph* uac = gUAControl->stream[type].uac;
    if (uac != NULL) {
        uac_set_parameter(uac, type, gUAControl->stream[type].config, UAC_SET_SAMPLE_RATE);
    }
    pthread_mutex_unlock(&gUAControl->stream[type].mutex);
}

void uac_set_volume(int type, int volume) {
    if (gUAControl == NULL)
        return;

    if ((type < 0) || (type >= UAC_STREAM_MAX))
        return;

    pthread_mutex_lock(&gUAControl->stream[type].mutex);
    gUAControl->stream[type].config.volume = ((float)volume/100.0);
    ALOGD("type = %d, volume = %f\n", type, gUAControl->stream[type].config.volume);
    /*
     * if uac is already start, set volume to RTUACGraph
     */
    RTUACGraph* uac = gUAControl->stream[type].uac;
    if (uac != NULL) {
        uac_set_parameter(uac, type, gUAControl->stream[type].config, UAC_SET_VOLUME);
    }
    pthread_mutex_unlock(&gUAControl->stream[type].mutex);
}

void uac_set_mute(int type, int mute) {
    if (gUAControl == NULL)
        return;

    if ((type < 0) || (type >= UAC_STREAM_MAX))
        return;

    ALOGD("type = %d, mute = %d\n", type, mute);
    pthread_mutex_lock(&gUAControl->stream[type].mutex);
    gUAControl->stream[type].config.mute = mute;
    /*
     * if uac is already start, set mute to RTUACGraph
     */
    RTUACGraph* uac = gUAControl->stream[type].uac;
    if (uac != NULL) {
        uac_set_parameter(uac, type, gUAControl->stream[type].config, UAC_SET_VOLUME);
    }
    pthread_mutex_unlock(&gUAControl->stream[type].mutex);
}

void uac_set_ppm(int type, int ppm) {
    if (gUAControl == NULL)
        return;

    if ((type < 0) || (type >= UAC_STREAM_MAX))
        return;

    ALOGD("type = %d, ppm = %d\n", type, ppm);
    pthread_mutex_lock(&gUAControl->stream[type].mutex);
    gUAControl->stream[type].config.ppm = ppm;
    /*
     * if uac is already start, set mute to RTUACGraph
     */
    RTUACGraph* uac = gUAControl->stream[type].uac;
    if (uac != NULL) {
        uac_set_parameter(uac, type, gUAControl->stream[type].config, UAC_SET_PPM);
    }
    pthread_mutex_unlock(&gUAControl->stream[type].mutex);
}


/*
 * see json file
 */
int uac_set_parameter(RTUACGraph* uac, int type, UACAudioConfig& config, UACConfigCmd cmd) {
    if (uac == NULL)
        return -1;

    switch (cmd) {
        case UAC_SET_SAMPLE_RATE: {
            graph_set_samplerate(uac, type, config);
        } break;
        case UAC_SET_VOLUME: {
			graph_set_volume(uac, type, config);
        } break;
        case UAC_SET_PPM: {
            graph_set_ppm(uac, type, config);
        } break;
        default: {
            ALOGE("cannot find UACConfigCmd = %d.\n", cmd);
        } break;
    }

    return 0;
}

int uac_start(int type) {
    if (gUAControl == NULL)
        return -1;

    if (type >= UAC_STREAM_MAX) {
        ALOGE("error, type = %d\n", type);
        return -1;
    }

    uac_stop(type);
    char* config = (char*)UAC_MIC_RECORD_USB_PLAY_CONFIG_FILE;
    char* name = (char*)"uac_playback";
    if (type == UAC_STREAM_RECORD) {
        name = (char*)"uac_record";
        config = (char*)UAC_USB_RECORD_SPK_PLAY_CONFIG_FILE;
    }
    ALOGD("config = %s\n", config);
    RTUACGraph* uac = new RTUACGraph(name);
    if (uac == NULL) {
        ALOGE("error, malloc fail\n");
        return -1;
    }
    // default configs will be readed in json file
    uac->autoBuild(config);
    uac->prepare();

    uac_set_parameter(uac, type, gUAControl->stream[type].config, UAC_SET_VOLUME);
    uac_set_parameter(uac, type, gUAControl->stream[type].config, UAC_SET_SAMPLE_RATE);
    uac_set_parameter(uac, type, gUAControl->stream[type].config, UAC_SET_PPM);

    uac->start();

    pthread_mutex_lock(&gUAControl->stream[type].mutex);
    gUAControl->stream[type].uac = uac;
    pthread_mutex_unlock(&gUAControl->stream[type].mutex);

    return 0;
}

void uac_stop(int type) {
    if (gUAControl == NULL)
        return;

    RTUACGraph* uac = NULL;
    if (type >= UAC_STREAM_MAX) {
        ALOGE("error type = %d\n",  type);
        return;
    }
    ALOGD("type = %d\n", type);
    pthread_mutex_lock(&gUAControl->stream[type].mutex);
    uac = gUAControl->stream[type].uac;
    gUAControl->stream[type].uac = NULL;
    pthread_mutex_unlock(&gUAControl->stream[type].mutex);

    if (uac != NULL) {
        uac->stop();
        uac->waitUntilDone();
        delete uac;
    }
    ALOGD("type = %d out\n", type);
}