#include <iostream>
#include <media/AudioTrackShared.h>
#include <memory>
#include <utils/Log.h>
#include <thread>
#include <unistd.h>
#include <cassert>

using namespace android;
#define TAG "AudioTrackProxy"
constexpr size_t mFrameCount = 960; // 缓冲区帧数
constexpr size_t kFrameCount = mFrameCount * 10; // 缓冲区帧数
constexpr size_t mFrameSize = sizeof(int16_t); // 每帧大小
int kMaxNum = 4;

class AudioTrackServerProxyDerived : public AudioTrackServerProxy {
public:
    AudioTrackServerProxyDerived(audio_track_cblk_t* cblk, void *buffers, size_t frameCount,
            size_t frameSize, bool clientInServer, uint32_t sampleRate) : AudioTrackServerProxy( cblk, buffers, frameCount,
             frameSize,  clientInServer,  sampleRate) {}
    // 提供公共析构函数
    ~AudioTrackServerProxyDerived() override {
        // 可选：自定义清理代码
    }
};

void* producer(std::shared_ptr<AudioTrackClientProxy> proxy, int16_t *sineWave, size_t sineSize)
{
        // Client 写入数据
        (void)sineSize;
        ALOGI("Client writing data...");
        char *sinePtr = (char*)sineWave;
        size_t userSize = mFrameCount * mFrameSize;
        size_t toWrite = 0;
        size_t written = 0;
        size_t num = 0;
        Proxy::Buffer buffer;
        status_t status = NO_ERROR;
        
        while(num++ < kMaxNum) {
            userSize = mFrameCount * mFrameSize;
            written = 0;
            while(userSize >= mFrameSize) {
                buffer.mFrameCount = userSize / mFrameSize;
                status = proxy->obtainBuffer(&buffer, &ClientProxy::kNonBlocking, NULL);
                if (status < 0) {
                    ALOGE("obtainBuffer failed, ret:%d", status);
                    continue;
                }
                ALOGD("Client obtain buffer %zu frames", buffer.mFrameCount);
                toWrite = buffer.mFrameCount * mFrameSize;
                // buffer.mRaw = sinePtr + written;
                memcpy(buffer.mRaw, sinePtr + written, toWrite);
                userSize -= toWrite;
                written += toWrite;
                proxy->releaseBuffer(&buffer);
                ALOGI("Client wrote %zu bytes. userSize:%zu, written:%zu, num:%zu", toWrite, userSize, written, num);
            }
            // usleep(5000);
        }
        return NULL;
}
void *consumer(std::shared_ptr<AudioTrackServerProxyDerived> proxy, int16_t *sineWave, size_t sineSize)
{
    // Server 读取数据
    (void)sineSize;
    int16_t readBuffer[mFrameCount*5] = { 0 };
    char * bufPtr = (char*)readBuffer;
    size_t toRead = 0;
    size_t reads = mFrameCount *mFrameSize;
    size_t num = 0;
    ALOGI("Server reading data...");
    while(num < kMaxNum) {
        // usleep(5000);
        
        size_t read = proxy->framesReadySafe();
        if (read < mFrameCount) {
            ALOGE("Server ready %zu frames.", read);
            continue;
        } else {
            ALOGI("Server ready %zu frames.", read);
        }

        ServerProxy::Buffer buf;
        memset(readBuffer, 0, mFrameCount*mFrameSize);
        toRead = 0;
        reads = mFrameCount *mFrameSize;
        while(reads >= mFrameSize) {
            buf.mFrameCount = reads / mFrameSize;
            status_t status = proxy->obtainBuffer(&buf);
            if (status == NO_ERROR) {
                toRead = buf.mFrameCount*mFrameSize;
                memcpy(bufPtr + (mFrameCount *mFrameSize) - reads, buf.mRaw, toRead);
                reads -= toRead;
                ALOGD("read buffer suc. count:%zu, size:%zu, toRead:%zu, reads:%zu, num:%zu", buf.mFrameCount, mFrameSize, toRead, reads, num);
                proxy->releaseBuffer(&buf);
            } else {
                ALOGE("obtain buffer failed,  ret:%d", status);
            }
            
        }
        num++;
        // 验证数据一致性
        bool dataMatches = true;
        for (size_t i = 0; i < mFrameCount; ++i) {
            if (readBuffer[i] != sineWave[i]) {
                dataMatches = false;
                break;
            }
        }

        if (dataMatches) {
            std::cout << "Data matches between Server and Client!" << std::endl;
        } else {
            std::cerr << "Data mismatch!" << std::endl;
            abort();
        }
    }
    return NULL;
}

int main(int argc, char *argv[])
{
    if (argc > 1) {
        kMaxNum = atoi(argv[1]);
    }
    std::cout << "kMaxNum: " << kMaxNum << std::endl;
    // 分配共享内存，用于 Server 和 Client 之间的数据交互
    size_t sharedBufferSize = kFrameCount * mFrameSize + sizeof(audio_track_cblk_t);
    void* sharedMemory = malloc(sharedBufferSize);

    if (!sharedMemory) {
        std::cerr << "Failed to allocate shared memory" << std::endl;
        return -1;
    }

    // 初始化 audio_track_cblk_t（控制块）
    audio_track_cblk_t* cblk = new (sharedMemory) audio_track_cblk_t();

    // 缓冲区
    void* buffers = cblk + 1;
    // 创建 Server 和 Client Proxy
    std::shared_ptr<AudioTrackServerProxyDerived> serverProxy(new AudioTrackServerProxyDerived(cblk, buffers, kFrameCount, mFrameSize, false, 48000));
    std::shared_ptr<AudioTrackClientProxy> clientProxy(new AudioTrackClientProxy(cblk, buffers, kFrameCount, mFrameSize));

    // 示例数据：生成一个简单的正弦波数据
    int16_t sineWave[mFrameCount];
    for (size_t i = 0; i < mFrameCount; ++i) {
        sineWave[i] = static_cast<int16_t>(32767 * sin(2 * M_PI * i / mFrameCount));
    }

    // start
    {
        serverProxy->start();
        ServerProxy::Buffer buffer;
        buffer.mFrameCount = 1;
        (void)serverProxy->obtainBuffer(&buffer, true);
    }

    std::thread client(producer, clientProxy, sineWave, mFrameCount);
    std::thread server(consumer, serverProxy, sineWave, mFrameCount);

    client.join();
    server.join();

    // 清理
    free(sharedMemory);
    fgetc(stdin);
    return 0;
}