#include "server/audio_server.h"
#include "server/server_core.h"
#include "generic/circular_buf.h"
#include "os/os_api.h"
#include "event.h"
#include "app_config.h"
#include "jlsp_far_keyword.h"
#include "event/key_event.h"
/* #include "jlsp_kws_aec.h" */

#if (defined CONFIG_ASR_ALGORITHM) && (CONFIG_ASR_ALGORITHM == JLKWS_ALGORITHM)

const int CONFIG_KWS_RAM_USE_ENABLE = 1;

extern void aisp_resume(void);

#define ONCE_SR_POINTS	160//256

#define AISP_BUF_SIZE	(ONCE_SR_POINTS * 2)	//跑不过来时适当加大倍数
#define MIC_SR_LEN		(ONCE_SR_POINTS * 2)

#ifdef CONFIG_AEC_ENC_ENABLE

/*aec module enable bit define*/
#define AEC_EN              BIT(0)
#define NLP_EN              BIT(1)
#define ANS_EN              BIT(2)

#define AEC_MODE_ADVANCE	(AEC_EN | NLP_EN | ANS_EN)
#define AEC_MODE_REDUCE		(NLP_EN | ANS_EN)
#define AEC_MODE_SIMPLEX	(ANS_EN)

#endif

static struct {
    int pid;
    u16 sample_rate;
    u8 volatile exit_flag;
    int volatile run_flag;
    OS_SEM sem;
    s16 mic_buf[AISP_BUF_SIZE * 2];
    void *mic_enc;
    cbuffer_t mic_cbuf;
} aisp_server;

#define __this (&aisp_server)

static const float confidence[8] = {
    0.5, 0.5, 0.5, 0.5, //小杰小杰，小杰同学，播放音乐，暂停播放
    0.5, 0.5, 0.5, 0.5, //增大音量，减小音量，上一首, 下一首
};

enum {
    PLAY_MUSIC_EVENT = 4,
    STOP_MUSIC_EVENT,
    VOLUME_INC_EVENT = 7,
    VOLUME_DEC_EVENT,
    SONG_PREVIOUS_EVENT,
    SONG_NEXT_EVENT,
};

static void aisp_task(void *priv)
{
    u32 mic_len, linein_len;
    u32 time = 0, time_cnt = 0, cnt = 0;
    int ret;
    int model = 0;
    int model_size, private_heap_size, share_heap_size;
    void *kws = NULL;
    u8 *private_heap = NULL, *share_heap = NULL;
    int online = 0;

    jl_far_kws_model_get_heap_size(model, &model_size, &private_heap_size, &share_heap_size);

    private_heap = zalloc(private_heap_size);
    if (!private_heap) {
        goto __exit;
    }

    share_heap	 = zalloc(share_heap_size);
    if (!share_heap) {
        goto __exit;
    }

    kws = jl_far_kws_model_init(model, private_heap, private_heap_size, share_heap, share_heap_size, model_size, confidence, online);
    if (!kws) {
        goto __exit;
    }

    aisp_resume();

    while (1) {
        if (__this->exit_flag) {
            break;
        }

        if (!__this->run_flag) {
            os_sem_pend(&__this->sem, 0);
            continue;
        }

        if (__this->exit_flag) {
            break;
        }

        if ((cbuf_get_data_size(&__this->mic_cbuf) < ONCE_SR_POINTS * 2)) {
            os_sem_pend(&__this->sem, 0);
            continue;
        }
        short near_data_buf[ONCE_SR_POINTS];
        mic_len = cbuf_read(&__this->mic_cbuf, near_data_buf, ONCE_SR_POINTS * 2);
        if (!mic_len) {
            continue;
        }

        time = timer_get_ms();
        ret = jl_far_kws_model_process(kws, model, (u8 *)near_data_buf, sizeof(near_data_buf));
        if (ret > 1) {
            printf("++++++++++++++++++ %d ++++++++++++++++++\n", ret);
            //add your button event according to ret
            struct key_event key = {0};

            if (ret == PLAY_MUSIC_EVENT) {
                key.action = KEY_EVENT_UP;
                key.value = KEY_LOCAL;
            } else if (ret == STOP_MUSIC_EVENT) {
                key.action = KEY_EVENT_HOLD;
                key.value = KEY_LOCAL;
            } else if (ret == VOLUME_INC_EVENT) {
                key.action = KEY_EVENT_CLICK;
                key.value = KEY_DOWN;
            } else if (ret == VOLUME_DEC_EVENT) {
                key.action = KEY_EVENT_CLICK;
                key.value = KEY_UP;
            } else if (ret == SONG_PREVIOUS_EVENT) {
                key.action = KEY_EVENT_LONG;
                key.value = KEY_UP;
            } else if (ret == SONG_NEXT_EVENT) {
                key.action = KEY_EVENT_LONG;
                key.value = KEY_DOWN;
            }

            key.type = KEY_EVENT_USER;
            key_event_notify(KEY_EVENT_FROM_USER, &key);

            jl_far_kws_model_reset(kws);
        }

        time_cnt += timer_get_ms() - time;
        if (++cnt == 100) {
            printf("aec time :%d \n", time_cnt);
            time_cnt = cnt = 0;
        }
    }

__exit:

    if (kws) {
        jl_far_kws_model_free(kws);
    }
    if (private_heap) {
        free(private_heap);
    }
    if (share_heap) {
        free(share_heap);
    }

    __this->run_flag = 0;

}

static void enc_server_event_handler(void *priv, int argc, int *argv)
{
    switch (argv[0]) {
    case AUDIO_SERVER_EVENT_ERR:
    case AUDIO_SERVER_EVENT_END:
        break;
    default:
        break;
    }
}

static int aisp_vfs_fwrite(void *file, void *data, u32 len)
{
    cbuffer_t *cbuf = (cbuffer_t *)file;

    u32 wlen = cbuf_write(cbuf, data, len);
    if (wlen != len) {
        cbuf_clear(&__this->mic_cbuf);
        puts("busy!\n");
    }
    os_sem_set(&__this->sem, 0);
    os_sem_post(&__this->sem);

    return len;
}

static int aisp_vfs_fclose(void *file)
{
    return 0;
}

static const struct audio_vfs_ops aisp_vfs_ops = {
    .fwrite = aisp_vfs_fwrite,
    .fclose = aisp_vfs_fclose,
};

int aisp_open(u16 sample_rate)
{
    __this->exit_flag = 0;
    __this->mic_enc = server_open("audio_server", "enc");
    server_register_event_handler(__this->mic_enc, NULL, enc_server_event_handler);
    cbuf_init(&__this->mic_cbuf, __this->mic_buf, sizeof(__this->mic_buf));
    os_sem_create(&__this->sem, 0);
    __this->sample_rate = sample_rate;

    return thread_fork("aisp", 3, 2048, 0, &__this->pid, aisp_task, __this);
}

void aisp_suspend(void)
{
    union audio_req req = {0};

    if (!__this->run_flag) {
        return;
    }

    __this->run_flag = 0;

    req.enc.cmd = AUDIO_ENC_STOP;
    server_request(__this->mic_enc, AUDIO_REQ_ENC, &req);
    cbuf_clear(&__this->mic_cbuf);
}

void aisp_resume(void)
{
    union audio_req req = {0};

    if (__this->run_flag) {
        return;
    }
    __this->run_flag = 1;
    os_sem_set(&__this->sem, 0);
    os_sem_post(&__this->sem);

    req.enc.cmd = AUDIO_ENC_OPEN;
    req.enc.channel = 1;
    req.enc.channel_bit_map = BIT(CONFIG_AISP_MIC0_ADC_CHANNEL);
    req.enc.frame_size = ONCE_SR_POINTS * 2 * req.enc.channel;
    req.enc.volume = CONFIG_AISP_MIC_ADC_GAIN;
    req.enc.sample_rate = __this->sample_rate;
    req.enc.format = "pcm";
#if CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_PLNK0
    req.enc.sample_source = "plnk0";
#elif CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_PLNK1
    req.enc.sample_source = "plnk1";
#elif CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_IIS0
    req.enc.sample_source = "iis0";
#elif CONFIG_AUDIO_ENC_SAMPLE_SOURCE == AUDIO_ENC_SAMPLE_SOURCE_IIS1
    req.enc.sample_source = "iis1";
#else
    req.enc.sample_source = "mic";
#endif
    req.enc.vfs_ops = &aisp_vfs_ops;
    req.enc.output_buf_len = req.enc.frame_size * 3;
    req.enc.file = (FILE *)&__this->mic_cbuf;
#ifdef CONFIG_AEC_ENC_ENABLE
    struct aec_s_attr aec_param = {0};
    aec_param.EnableBit = AEC_MODE_ADVANCE;
    aec_param.output_way = 0;	 //1:使用硬件回采 0:使用软件回采
    req.enc.aec_attr = &aec_param;
    req.enc.aec_enable = 0;	//默认不开
#endif

    server_request(__this->mic_enc, AUDIO_REQ_ENC, &req);
}

void aisp_close(void)
{
    if (__this->exit_flag) {
        return;
    }

    aisp_suspend();

    __this->exit_flag = 1;

    os_sem_post(&__this->sem);

    if (__this->mic_enc) {
        server_close(__this->mic_enc);
        __this->mic_enc = NULL;
    }
    thread_kill(&__this->pid, KILL_WAIT);
}

#endif