#include "asm/includes.h"
#include "media/includes.h"
#include "system/includes.h"
#include "classic/hci_lmp.h"
#include "asm/audio_src.h"
#include "audio_enc.h"
#include "app_main.h"
#include "btstack/avctp_user.h"
#include "audio_config.h"
#include "sbc_enc.h"
#include "api/mesh_config.h"

#if ENC_DEMO_EN
const unsigned char sin44K[88] ALIGNED(4) = {
    0x00, 0x00, 0x45, 0x0E, 0x41, 0x1C, 0xAA, 0x29, 0x3B, 0x36, 0xB2, 0x41, 0xD5, 0x4B, 0x6E, 0x54,
    0x51, 0x5B, 0x5A, 0x60, 0x70, 0x63, 0x82, 0x64, 0x8A, 0x63, 0x8E, 0x60, 0x9D, 0x5B, 0xD1, 0x54,
    0x4D, 0x4C, 0x3D, 0x42, 0xD5, 0x36, 0x50, 0x2A, 0xF1, 0x1C, 0xFB, 0x0E, 0xB7, 0x00, 0x70, 0xF2,
    0x6E, 0xE4, 0xFD, 0xD6, 0x60, 0xCA, 0xD9, 0xBE, 0xA5, 0xB4, 0xF7, 0xAB, 0xFC, 0xA4, 0xDA, 0x9F,
    0xAB, 0x9C, 0x7F, 0x9B, 0x5E, 0x9C, 0x3F, 0x9F, 0x19, 0xA4, 0xCE, 0xAA, 0x3D, 0xB3, 0x3A, 0xBD,
    0x92, 0xC8, 0x0A, 0xD5, 0x60, 0xE2, 0x50, 0xF0
};

extern struct audio_encoder_task *encode_task;
#define ENC_BUF_NUM        (2)
#define ENC_ADC_IRQ_POINTS     (320)
#define ENC_ADC_BUFS_SIZE      (ENC_BUF_NUM * ENC_ADC_IRQ_POINTS)

#define MIC_USE_MIC_CHANNEL    (1)
#define ENC_IN_SIZE		(ENC_ADC_IRQ_POINTS * 2)
#define ENC_OUT_SIZE       (ENC_ADC_IRQ_POINTS)
#define ENC_CLK  96 * 1000000L    //编码时候的时钟

struct demo_enc_hdl {
    struct audio_encoder encoder;
    OS_SEM pcm_frame_sem;
    u8 output_frame[ENC_OUT_SIZE];
    u8  pcm_frame[ENC_IN_SIZE];
    u8 frame_size;
    u8 in_cbuf_buf[ENC_IN_SIZE * 6];
    cbuffer_t pcm_in_cbuf;
    u32 clk_before;
#if mic_enc_PACK_ENABLE
    u16 cp_type;
    u16 packet_head_sn;
#endif
#if MIC_USE_MIC_CHANNEL
    struct audio_adc_output_hdl adc_output;
    struct adc_mic_ch mic_ch;
    s16 adc_buf[ENC_ADC_BUFS_SIZE];    //align 4Bytes
#endif
    int (*demo_output)(void *priv, void *buf, int len);

};

static struct demo_enc_hdl *demo_enc = NULL;


static u16 demo_frame_test_tmr = 0;

static void demo_enc_output_func_register(int (*output_func)(void *priv, void *buf, int len))
{
    if (demo_enc) {
        demo_enc->demo_output = output_func;
    }
}

void demo_enc_resume(void)
{
    if (demo_enc) {
        os_sem_post(&demo_enc->pcm_frame_sem);
    }
}

static int demo_enc_pcm_get(struct audio_encoder *encoder, s16 **frame, u16 frame_len)
{
    int pcm_len = 0;
    if (demo_enc == NULL) {
        r_printf("demo_enc NULL\n");
        return 0;
    }
    /* putchar('!'); */
    if ((&demo_enc->pcm_in_cbuf)->data_len < frame_len) {
        /* putchar('#'); */
        os_sem_set(&demo_enc->pcm_frame_sem, 0);
        os_sem_pend(&demo_enc->pcm_frame_sem, 5);
        if (demo_enc == NULL) {
            printf("demo_enc is NULL\n");
            return 0;
        }
    }

    pcm_len = cbuf_read(&demo_enc->pcm_in_cbuf, demo_enc->pcm_frame, frame_len);

    if (pcm_len != frame_len) {
        putchar('L');
    }
    /* putchar('D'); */

    *frame = demo_enc->pcm_frame;
    return pcm_len;
}

static void demo_enc_pcm_put(struct audio_encoder *encoder, s16 *frame)
{
}

static const struct audio_enc_input demo_enc_input = {
    .fget = demo_enc_pcm_get,
    .fput = demo_enc_pcm_put,
};

static int demo_enc_probe_handler(struct audio_encoder *encoder)
{
    return 0;
}

static int demo_enc_output_handler(struct audio_encoder *encoder, u8 *frame, int len)
{
    if (encoder == NULL) {
        r_printf("encoder NULL");
    }
    wdt_clear();
    printf("demo frame len:%d \n", len);
    if (demo_enc && demo_enc->demo_output) {
        demo_enc->demo_output(NULL, frame, len);
    }
    put_buf(frame, 16);
    return len;
}

const static struct audio_enc_handler demo_enc_handler = {
    .enc_probe = demo_enc_probe_handler,
    .enc_output = demo_enc_output_handler,
};

static void demo_enc_event_handler(struct audio_decoder *decoder, int argc, int *argv)
{
    printf("demo_enc_event_handler:0x%x,%d\n", argv[0], argv[0]);
    switch (argv[0]) {
    case AUDIO_ENC_EVENT_END:
        puts("AUDIO_ENC_EVENT_END\n");
        break;
    }
}

int read_44k_sine_data(void *buf, int bytes, int offset, u8 channel)
{
    s16 *sine = (s16 *)sin44K;
    s16 *data = (s16 *)buf;
    int frame_len = (bytes >> 1) / channel;
    int sin44k_frame_len = sizeof(sin44K) / 2;
    int i, j;

    offset = offset % sin44k_frame_len;

    for (i = 0; i < frame_len; i++) {
        for (j = 0; j < channel; j++) {
            *data++ = sine[offset];
        }
        if (++offset >= sin44k_frame_len) {
            offset = 0;
        }
    }

    return i * 2 * channel;
}

static  u16 frames_offset = 0;
static  s16 frame_bytes = 0;
static  s16 pcm_frames[640];

static void adc_mic_output_handler(void *priv, s16 *data, int len)
{
    if (demo_enc) {
        u16 wlen = cbuf_write(&demo_enc->pcm_in_cbuf, data, len);
        if (wlen != len) {
            putchar('@');
        }
        audio_encoder_resume(&demo_enc->encoder);
        demo_enc_resume();
    }
}

static void demo_frame_test_time_func(void *param)
{
    u32 len = 320; //每次写的字节数

    frame_bytes = read_44k_sine_data(pcm_frames, len, frames_offset, 1);
    frames_offset += (frame_bytes >> 1) / 1;   //固定传320
    if (demo_enc) {
        /* put_buf(pcm_frames,len); */   //是不是这里写数据写漏了
        u16 wlen = cbuf_write(&demo_enc->pcm_in_cbuf, pcm_frames, len);
        if (wlen != len) {
            putchar('@');
        }

        audio_encoder_resume(&demo_enc->encoder);
        demo_enc_resume();
    }
}

#define HIGHT_COMPLEX		0
#define LOW_COMPLEX			(BIT(4))

extern struct audio_adc_hdl adc_hdl;
int audio_demo_enc_open(int (*demo_output)(void *priv, void *buf, int len), u32 code_type, u8 ai_type)  //第一个参数为编码输出回调，在回调中可以对编码后的数据进行处理
{
    int err;
    struct audio_fmt fmt = {0};
    switch (code_type) {
#if TCFG_ENC_OPUS_ENABLE
    case AUDIO_CODING_OPUS:
        //1. quality:bitrate     0:16kbps    1:32kbps    2:64kbps
        //   quality: MSB_2:(bit7_bit6)     format_mode    //0:百度_无头.                   1:酷狗_eng+range.
        //   quality:LMSB_2:(bit5_bit4)     low_complexity //0:高复杂度,高质量.兼容之前库.  1:低复杂度,低质量.
        //2. sample_rate         sample_rate=16k         ignore
        fmt.quality = 0 | ai_type/*| LOW_COMPLEX*/;  //32位的
        fmt.sample_rate = 16000;
        fmt.coding_type = AUDIO_CODING_OPUS;
        break;
#endif

#if TCFG_ENC_SPEEX_ENABLE
    case AUDIO_CODING_SPEEX:
        fmt.quality = 5;
        fmt.complexity = 2;
        fmt.sample_rate = 16000;
        fmt.coding_type = AUDIO_CODING_SPEEX;
        break;
#endif

#if TCFG_ENC_ADPCM_ENABLE
    case AUDIO_CODING_WAV:   //adpcm 编码,在lib_media_config.c 里面配置 const_sel_adpcm_type 来选择 ima格式的或者ms格式的
        fmt.sample_rate = 16000;
        fmt.bit_rate = 1024;  //blockSize,可配成256/512/1024/2048
        fmt.channel = 2;
        fmt.coding_type = AUDIO_CODING_WAV;
        break;
#endif

#if TCFG_ENC_LC3_ENABLE
    case AUDIO_CODING_LC3:
        fmt.bit_rate = 64000;
        fmt.sample_rate = LC3_CODING_SAMPLERATE;
        fmt.frame_len = LC3_CODING_FRAME_LEN;
        fmt.channel = LC3_CODING_CHANNEL;
        fmt.coding_type = AUDIO_CODING_LC3;
        break;
#endif

#if TCFG_ENC_SBC_ENABLE
    case AUDIO_CODING_SBC:
        sbc_t sbc_enc_parm = {
            .frequency = SBC_FREQ_44100,
            .blocks = SBC_BLK_16,
            .subbands = SBC_SB_8,
            .mode = SBC_MODE_STEREO,
            .allocation = 0,
            .endian = SBC_LE,
            .bitpool = 53
        };
        fmt.priv = (void *)(&sbc_enc_parm);
        fmt.frame_len = 640; //sbc 编码每次读取的源数据的字节数,值要大于编成一个帧需要的长度
        fmt.coding_type = AUDIO_CODING_SBC;
        break;
#endif

#if TCFG_ENC_MSBC_ENABLE
    case AUDIO_CODING_MSBC:  //msbc没有外部配置的参数
        fmt.coding_type = AUDIO_CODING_MSBC;
        break;
#endif

    default:
        printf("do not support this type !!!\n");
        return -1;
        break;
    }

    if (!encode_task) {
        encode_task = zalloc(sizeof(*encode_task));
        if (!encode_task) {
            printf("encode_task NULL !!!\n");
        }
        audio_encoder_task_create(encode_task, "audio_enc");
    }
    if (!demo_enc) {
        demo_enc = zalloc(sizeof(*demo_enc));
        if (!demo_enc) {
            printf("demo_enc NULL !!!\n");
        }
        memset(demo_enc, 0x00, sizeof(*demo_enc));
    }

    demo_enc_output_func_register(demo_output);

    cbuf_init(&demo_enc->pcm_in_cbuf, demo_enc->in_cbuf_buf, ENC_IN_SIZE * 6);
    os_sem_create(&demo_enc->pcm_frame_sem, 0);
    audio_encoder_open(&demo_enc->encoder, &demo_enc_input, encode_task);
    audio_encoder_set_handler(&demo_enc->encoder, &demo_enc_handler);
    audio_encoder_set_fmt(&demo_enc->encoder, &fmt);
    audio_encoder_set_event_handler(&demo_enc->encoder, demo_enc_event_handler, 0);
    audio_encoder_set_output_buffs(&demo_enc->encoder, demo_enc->output_frame,
                                   sizeof(demo_enc->output_frame), 1);
    if (!demo_enc->encoder.enc_priv) {
        log_e("encoder err, maybe coding(0x%x) disable \n", fmt.coding_type);
        err = -EINVAL;
        goto __err;
    }

    int start_err = audio_encoder_start(&demo_enc->encoder);
    // 用timer模拟填数,填入需要编码的源数据
    /* demo_frame_test_tmr = sys_hi_timer_add(NULL, demo_frame_test_time_func, 40); */
    /* printf("id:%d \n", demo_frame_test_tmr); */
//把mic采到的数据编码
#if MIC_USE_MIC_CHANNEL
    demo_enc->clk_before = clk_get("sys");
    if (demo_enc->clk_before < ENC_CLK) {
        clk_set("sys", ENC_CLK);
    }
    u32 clk_debug = clk_get("sys");
    fmt.sample_rate = 16000;
#if !defined(CONFIG_MEDIA_DEVELOP_ENABLE)
    audio_mic_pwr_ctl(MIC_PWR_ON);
#endif
    audio_adc_mic_open(&demo_enc->mic_ch, AUDIO_ADC_MIC_CH, &adc_hdl);
    audio_adc_mic_set_sample_rate(&demo_enc->mic_ch, fmt.sample_rate);
#if (TCFG_AUDIO_ENABLE && MESH_AUDIO_TEST)
    app_var.aec_mic_gain = 14;
#endif
    printf(">>>>>>>>>mic gain:%d \n", app_var.aec_mic_gain);
    audio_adc_mic_set_gain(&demo_enc->mic_ch, app_var.aec_mic_gain);
    audio_adc_mic_set_buffs(&demo_enc->mic_ch, demo_enc->adc_buf,
                            ENC_ADC_IRQ_POINTS * 2, ENC_BUF_NUM);
    demo_enc->adc_output.handler = adc_mic_output_handler;
    audio_adc_add_output_handler(&adc_hdl, &demo_enc->adc_output);
    //app_audio_output_samplerate_set(44100);
    //app_audio_output_start();
    audio_adc_mic_start(&demo_enc->mic_ch);
#endif
    printf("demo_enc_open ok %d\n", start_err);
    return 0;
__err:
    audio_encoder_close(&demo_enc->encoder);
    local_irq_disable();
    free(demo_enc);
    demo_enc = NULL;
    local_irq_enable();
    return err;
}

int audio_demo_enc_close()
{
    if (!demo_enc) {
        return -1;
    }
    printf("audio_demo_enc_close\n");
#if MIC_USE_MIC_CHANNEL
    clk_set("sys", demo_enc->clk_before);
    audio_adc_mic_close(&demo_enc->mic_ch);
    audio_adc_del_output_handler(&adc_hdl, &demo_enc->adc_output);
#endif

    demo_enc_resume();
    audio_encoder_close(&demo_enc->encoder);

    /* if (encode_task) { */
    /* audio_encoder_task_del(encode_task); */
    /* free(encode_task); */
    /* encode_task = NULL; */
    /* } */

    free(demo_enc);
    demo_enc = NULL;

    printf("audio_demo_enc_close end\n");
    return 0;
}

#endif