#include "alsa_dev.h"
#include <thread>
#include <mutex>
#include <atomic>
#include <vector>
#include <cmath>

#define LOG(fmt,...) printf(fmt,##__VA_ARGS__)
#define LOGF(file, fmt,...) fprintf(file,fmt,##__VA_ARGS__)

namespace alsa {


//----------------------------------------------
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
// 最大/小音量（db）
#define MIN_DB (-10)
#define MAX_DB (10)
// 最大/小音量： 0: 静音； 100:最大音量
#define MUTE_VOLUME (0)
#define MAX_VOLUME (100)

static int vol_scaler_init(int *scaler, int mindb, int maxdb);
typedef struct VolumeCtlUnit
{
    int scaler[MAX_VOLUME + 1];     // 音量表
    int zeroDb;                     // 0db在scaler中的索引
    VolumeCtlUnit() {
        // 音量控制器初始化
        zeroDb = vol_scaler_init(scaler, MIN_DB, MAX_DB);
    }
} volume_ctl_unit_t;
static volume_ctl_unit_t kVolCtrlUnit;

static int vol_scaler_init(int *scaler, int mindb, int maxdb)
{
    double tabdb[MAX_VOLUME + 1];
    double tabf [MAX_VOLUME + 1];
    int    z, i;

    for (i = 0; i < (MAX_VOLUME + 1); i++) {
        // (mindb, maxdb)平均分成(MAX_VOLUME + 1)份
        tabdb[i]  = mindb + (maxdb - mindb) * i / (MAX_VOLUME + 1);
        // dB = 20 * log(A1 / A2)，当A1，A2相等时，db为0
        // 这里以(1 << 14)作为原始声音振幅，得到调节后的振幅(A1),将A1存入音量表中
        tabf [i]  = pow(10.0, tabdb[i] / 20.0);
        scaler[i] = (int)((1 << 14) * tabf[i]); // Q14 fix point
    }

    z = -mindb * (MAX_VOLUME + 1) / (maxdb - mindb);
    z = MAX(z, 0  );
    z = MIN(z, MAX_VOLUME);
    scaler[0] = 0;        // 音量表中，0标识静音
    scaler[z] = (1 << 14);// (mindb, maxdb)的中间值作为0db，即不做增益处理

    return z;
}

void vol_scaler_run(int16_t *buf, int n, int volume)
{
    /* 简易版
    while (n--) {
        *buf = (*buf) * multiplier / 100.0;
        *buf = std::max((int)*buf, -0x7fff);
        *buf = std::min((int)*buf, 0x7fff);
        buf++;
    }
    */
    int multiplier = kVolCtrlUnit.scaler[volume];
    if (multiplier > (1 << 14)) {
        int32_t v;
        while (n--) {
            v = ((int32_t)*buf * multiplier) >> 14;
            v = MAX(v,-0x7fff);
            v = MIN(v, 0x7fff);
            *buf++ = (int16_t)v;
        }
    } else if (multiplier < (1 << 14)) {
        while (n--) {
            *buf = ((int32_t)*buf * multiplier) >> 14;
            buf++;
        }
    }
}
//----------------------------------------------


struct ConfigPrivate {
    Config config;
    int sample_size;
    snd_pcm_uframes_t buffer;
    snd_pcm_uframes_t period;
};

static int set_swparams(snd_pcm_t *handle, ConfigPrivate &config);
static int set_hwparams(snd_pcm_t *handle, ConfigPrivate &config);
static int xrun_recovery(snd_pcm_t *handle, int err);

static void msleep(size_t ms) {
    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
}

static void usleep(size_t us) {
    std::this_thread::sleep_for(std::chrono::microseconds(us));
}


class AlsaDev::Private
{
public:
    Private() {
        memset(&_config, 0, sizeof(_config));
    }
    ~Private() {
        destory();
    }
    int init(snd_pcm_stream_t type) {
        int err = 0;

        if ((err = snd_pcm_open(&_handle, _config.config.device, type, 0)) < 0) {
            LOG("Playback open error: %s\n", snd_strerror(err));
            return err;
        }

        if ((err = set_hwparams(_handle, _config)) < 0) {
            LOG("Setting of hwparams failed: %s\n", snd_strerror(err));
            return err;
        }
        if ((err = set_swparams(_handle, _config)) < 0) {
            LOG("Setting of swparams failed: %s\n", snd_strerror(err));
            return err;
        }
        LOG("alsa param, period: %d, buffer: %d\n", _config.period, _config.buffer);
        return err;
    }
    void destory() {
        if (_handle) {
            snd_pcm_drain(_handle);
            snd_pcm_close(_handle);
            snd_pcm_hw_free(_handle);
        }
        _handle = nullptr;
    }
public:
    ConfigPrivate _config;
    snd_pcm_t *_handle = nullptr;
};

AlsaDev::AlsaDev() : d_ptr{new Private()} {

}

AlsaDev::~AlsaDev() {
    if (d_ptr) delete d_ptr;
}

int AlsaDev::applyConfig(Config &config)
{
    memcpy(&d_ptr->_config.config, &config, sizeof(config));
    d_ptr->_config.sample_size = snd_pcm_format_size(d_ptr->_config.config.format, 1);
    d_ptr->_config.period = d_ptr->_config.config.period_time * d_ptr->_config.config.rate / 1000000;
    d_ptr->_config.buffer = d_ptr->_config.period * d_ptr->_config.config.buffer_time / d_ptr->_config.config.period_time;
    return 0;
}

int AlsaDev::init(snd_pcm_stream_t type) {
    return d_ptr->init(type);
}

void AlsaDev::destory() {
    return d_ptr->destory();
}

const char * AlsaDev::configToString() {
    static char str[1024];
    memset(str, 0, 1024);
    sprintf(str, "{\n"
    "\t device: %s\n"
    "\t format: %d\n"
    "\t channels: %d\n"
    "\t rate: %d\n"
    "\t bytes_per_sample: %d\n"
    "\t period: %d\n"
    "\t buffer: %d\n"
    "}", d_ptr->_config.config.device, d_ptr->_config.config.format, 
    d_ptr->_config.config.channels, d_ptr->_config.config.rate, d_ptr->_config.sample_size,
    d_ptr->_config.period, d_ptr->_config.buffer);
    return str;
}

int AlsaDev::getSampleSize() {
    return d_ptr->_config.sample_size;
}
int AlsaDev::getFrameSize() {
    return d_ptr->_config.sample_size * d_ptr->_config.config.channels;
}
int AlsaDev::getFrames() {
    return d_ptr->_config.period;
}
int AlsaDev::getHwBufferSize() {
    return d_ptr->_config.buffer;
}

int AlsaDev::write(uint8_t *data, size_t bytes)
{
    int bytes_per_frame = snd_pcm_frames_to_bytes(d_ptr->_handle, 1);
    snd_pcm_sframes_t frames = bytes / bytes_per_frame;
    snd_pcm_sframes_t gotten = 0;
    int ret;
    // LOG("frames = %d\n", frames);
    while (frames > 0) {
        ret = snd_pcm_writei(d_ptr->_handle, data, frames);
        // LOG("snd_pcm_writei %d, ret=%d\n", frames, ret);
        if (ret < 0) {
            if (ret == -EAGAIN) {
                usleep(100);
                errno = -EAGAIN;
                break;
            }
            if (xrun_recovery(d_ptr->_handle, ret) < 0) {
                LOG("write error: %s \n", strerror(ret));
                break;
            }
        }
        frames -= ret;
        gotten += ret;
    }
    return gotten;
}
int AlsaDev::read(uint8_t *data, size_t bytes) {
    int bytes_per_frame = snd_pcm_frames_to_bytes(d_ptr->_handle, 1);
    snd_pcm_sframes_t frames = bytes / bytes_per_frame;
    snd_pcm_sframes_t gotten = 0;
    int ret;
    while (frames > 0) {
        ret = snd_pcm_readi(d_ptr->_handle, data, frames);
        if (ret < 0) {
            if (ret == -EAGAIN) {
                usleep(100);
                errno = -EAGAIN;
                break;
            }
            if (xrun_recovery(d_ptr->_handle, ret) < 0) {
                LOG("Read error: %s \n", strerror(ret));
                break;
            }
        }
        frames -= ret;
        gotten += ret;
    }
    return gotten;
}

static int set_hwparams(snd_pcm_t *handle, ConfigPrivate &config)
{
    snd_pcm_hw_params_t *params;
    unsigned int rrate;
    snd_pcm_uframes_t size;
    int err, dir;
    snd_pcm_hw_params_alloca(&params);
    /* choose all parameters */
    err = snd_pcm_hw_params_any(handle, params);
    if (err < 0) {
        LOG("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
        return err;
    }
      /* set the interleaved read/write format */
    err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
    if (err < 0) {
        LOG("Access type not available for playback: %s\n", snd_strerror(err));
        return err;
    }
    /* set the sample format */
    err = snd_pcm_hw_params_set_format(handle, params, config.config.format);
    if (err < 0) {
        LOG("Sample format not available for playback: %s\n", snd_strerror(err));
        return err;
    }
    /* set the count of channels */
    err = snd_pcm_hw_params_set_channels(handle, params, config.config.channels);
    if (err < 0) {
        LOG("Channels count (%u) not available for playbacks: %s\n", config.config.channels, snd_strerror(err));
        return err;
    }
    /* set the stream rate */
    rrate = config.config.rate;
    err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
    if (err < 0) {
        LOG("Rate %uHz not available for playback: %s\n", config.config.rate, snd_strerror(err));
        return err;
    }
    if (rrate != config.config.rate) {
        LOG("Rate doesn't match (requested %uHz, get %iHz)\n", config.config.rate, err);
        return -EINVAL;
    }
    /* set the buffer time */
    err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &config.config.buffer_time, &dir);
    if (err < 0) {
        LOG("Unable to set buffer time %u for playback: %s\n", config.config.buffer_time, snd_strerror(err));
        return err;
    }
    err = snd_pcm_hw_params_get_buffer_size(params, &size);
    if (err < 0) {
        LOG("Unable to get buffer size for playback: %s\n", snd_strerror(err));
        return err;
    }
    config.buffer = size;
    /* set the period time */
    err = snd_pcm_hw_params_set_period_time_near(handle, params, &config.config.period_time, &dir);
    if (err < 0) {
        LOG("Unable to set period time %u for playback: %s\n", config.config.period_time, snd_strerror(err));
        return err;
    }
    err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
    if (err < 0) {
        LOG("Unable to get period size for playback: %s\n", snd_strerror(err));
        return err;
    }
    config.period = size;
    /* write the parameters to device */
    err = snd_pcm_hw_params(handle, params);
    if (err < 0) {
        printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
        return err;
    }
    return 0;
}

static int set_swparams(snd_pcm_t *handle, ConfigPrivate &config)
{
    int err;    snd_pcm_sw_params_t *swparams;
    snd_pcm_sw_params_alloca(&swparams);
    /* get the current swparams */
    err = snd_pcm_sw_params_current(handle, swparams);
    if (err < 0) {
        LOG("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
        return err;
    }
    /* start the transfer when the buffer is almost full: */
    /* (buffer_size / avail_min) * avail_min */
    err = snd_pcm_sw_params_set_start_threshold(handle, swparams, (config.buffer / config.period) * config.period);
    if (err < 0) {
        printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
        return err;
    }
    // LOGF(stderr, "---%d--\r\n", (config.buffer / config.period) * config.period);
    err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, (config.buffer / config.period) * config.period);
    /* write the parameters to the playback device */
    err = snd_pcm_sw_params(handle, swparams);
    if (err < 0) {
        LOG("Unable to set sw params for playback: %s\n", snd_strerror(err));
        return err;
    }
    return 0;
}

static int xrun_recovery(snd_pcm_t *handle, int err)
{
#if 0
    if (err == -EPIPE) {    /* under-run */
        err = snd_pcm_prepare(handle);
        if (err < 0)
            LOG("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(err));
        return 0;
    } else if (err == -ESTRPIPE) {
        while ((err = snd_pcm_resume(handle)) == -EAGAIN)
            sleep(1);   /* wait until the suspend flag is released */
        if (err < 0) {
            LOG("stream recovery----%d\n", __LINE__);
            err = snd_pcm_prepare(handle);
            if (err < 0)
                LOG("Can't recovery from suspend, prepare failed: %s\n", snd_strerror(err));
        }
        return 0;
    }
#endif
    if (err == -EPIPE) {
        err = snd_pcm_prepare(handle);
        if (err < 0) {
            LOG("Unable to prepare PCM device: %s\n", (char *)snd_strerror(err));
        }
    } else {
        LOG("Error recovery to PCM device: %s\n", (char *)snd_strerror(err));
    }
    return err;
}

}