---

#include <stdio.h>
#include <string.h>
#include <portaudio.h>
#include <audio_dev.h>
#include <pthread.h>
#include <zephyr_i2s_dev.h>
#include <zephyr_audio_dev.h>

#include <zephyr/kernel.h>
#include <zephyr/drivers/i2s.h>
#include <zephyr/audio/codec.h>


#if DT_NODE_EXISTS(DT_NODELABEL(i2s_rxtx))
#define I2S_RX_NODE  DT_NODELABEL(i2s_rxtx)
#define I2S_TX_NODE  I2S_RX_NODE
#else
#define I2S_RX_NODE  DT_NODELABEL(i2s0_rx)
#define I2S_TX_NODE  DT_NODELABEL(i2s0_tx)
#endif

#define AUDIO_MCLK_FREQ 12288000
#define TIMEOUT             1000

#ifndef MY_CODE
#define I2S_THREAD_PRIORITY 8
#else
#define I2S_THREAD_PRIORITY 12
#endif

#ifdef MY_CODE
K_MEM_SLAB_DEFINE_IN_SECT_STATIC(mem_slab_rx, __dtcm_noinit_section, ZEPHYR_AUDIO_BLOCK_SIZE, ZEPHYR_AUDIO_BLOCK_COUNT, 4);
K_MEM_SLAB_DEFINE_IN_SECT_STATIC(mem_slab_tx, __dtcm_noinit_section, ZEPHYR_AUDIO_BLOCK_SIZE, ZEPHYR_AUDIO_BLOCK_COUNT, 4);
#else
K_MEM_SLAB_DEFINE(mem_slab_rx, ZEPHYR_AUDIO_BLOCK_SIZE, ZEPHYR_AUDIO_BLOCK_COUNT, 4);
K_MEM_SLAB_DEFINE(mem_slab_tx, ZEPHYR_AUDIO_BLOCK_SIZE, ZEPHYR_AUDIO_BLOCK_COUNT, 4);
#endif

#ifndef MY_CODE
#define I2S_STACK_SIZE 1024
static uint8_t __aligned(4) i2s_in_stack[I2S_STACK_SIZE] __section(".dtcm_data");
static uint8_t __aligned(4) i2s_out_stack[I2S_STACK_SIZE] __section(".dtcm_data");
#endif

static const struct device *const i2s_dev_rx = DEVICE_DT_GET(I2S_RX_NODE);
static const struct device *const i2s_dev_tx = DEVICE_DT_GET(I2S_TX_NODE);
static uint8_t start_stream = 0;

enum zephyr_i2s_state {
    I2S_STREAM_RUNNING,
    I2S_STREAM_CLOSED
};

struct i2s_strm {
    uint8_t alloc;
    uint8_t devid;
    uint8_t *i2s_buf;
    pthread_t i2s_thread;
    pthread_attr_t  threadAttr;
    enum zephyr_i2s_state state;
};

#define MODOPS_I2S_STREAM_COUNT 2
static struct i2s_strm i2s_strm_pool[MODOPS_I2S_STREAM_COUNT] = {0};


/////////////////////////////I2S Stream///////////////////
static struct i2s_strm *i2s_str_alloc()
{
    struct i2s_strm *i2s_strm_ = NULL;
    for(uint8_t i=0; i < MODOPS_I2S_STREAM_COUNT; i++)
    {
        if(i2s_strm_pool[i].alloc == 0)
        {
            i2s_strm_ = &i2s_strm_pool[i];
            i2s_strm_pool[i].alloc = 1;
            break;
        }
    }
    return i2s_strm_;
}

static void i2s_str_free(struct i2s_strm *i2s_strm_)
{
    if(!i2s_strm_)
        return;
    for(uint8_t i=0; i < MODOPS_I2S_STREAM_COUNT; i++)
    {
        if(i2s_strm_pool[i].devid == i2s_strm_->devid)
        {
            i2s_strm_pool[i].alloc = 0;
            break;
        }
    }
}

static void i2s_thread_wakeup(struct i2s_strm *strm, enum i2s_state state)
{
    if(!strm)
        return;
    strm->state = state;
}

static void *i2s_thread_in(void *arg)
{
    struct i2s_strm *i2s_stream = (struct i2s_strm *) arg;
    uint32_t block_size;
    uint8_t *buf = NULL;
    uint8_t half_transfer = 1;
    int ret;

    buf = i2s_stream->i2s_buf;
    while (1)
    {
        if(!start_stream) {
            k_sleep(K_MSEC(10));
        }
        else
        {
            ret = i2s_buf_read(i2s_dev_rx, buf, &block_size);
            //printf("I2S_READ: %p size %u ret=%d\n",buf,block_size,ret);
            if (ret < 0)
            {
                printf("I2S_IN: Failed to read data: %d\n", ret);
                //break;
            }
            else
            {
                //printf("I2S_IN: Read data size=%u\n",block_size);
                if(half_transfer)
                {
                    BSP_AUDIO_IN_HalfTransfer_CallBack();
                    buf += ZEPHYR_AUDIO_BLOCK_SIZE;
                    half_transfer = 0;
                }
                else
                {
                    BSP_AUDIO_IN_TransferComplete_CallBack();
                    buf = i2s_stream->i2s_buf;
                    half_transfer = 1;
                }
            }
        }
        if (i2s_stream->state != I2S_STREAM_RUNNING)
        {
            printf("Exit i2s_in_thread\n");
            break;
        }
    }
    return NULL;
}

static void *i2s_thread_out(void *arg)
{
    struct i2s_strm *i2s_stream = (struct i2s_strm *) arg;
    uint8_t *buf = NULL;
    uint8_t half_transfer = 1;
    int ret;

    buf = i2s_stream->i2s_buf;
    while (1)
    {
        if(!start_stream) {
            k_sleep(K_MSEC(10));
        }
        else
        {
            ret = i2s_buf_write(i2s_dev_tx, buf, ZEPHYR_AUDIO_BLOCK_SIZE);
            //printf("I2S_WRITE: %p size %u ret=%d\n",buf,ZEPHYR_AUDIO_BLOCK_SIZE,ret);
            if (ret < 0)
            {
                printf("I2S_OUT: Failed to write data: %d\n", ret);
                //break;
            }
            else
            {
                //printf("I2S_OUT: Write data size=%u\n",ZEPHYR_AUDIO_BLOCK_SIZE);
                if(half_transfer)
                {
                    BSP_AUDIO_OUT_HalfTransfer_CallBack();
                    buf += ZEPHYR_AUDIO_BLOCK_SIZE;
                    half_transfer = 0;
                }
                else
                {
                    BSP_AUDIO_OUT_TransferComplete_CallBack();
                    buf = i2s_stream->i2s_buf;
                    half_transfer = 1;
                }
            }
        }
        if (i2s_stream->state != I2S_STREAM_RUNNING)
        {
            printf("Exit i2s_out_thread\n");
            break;
        }
    }
    return NULL;
}
///////////////////////////////////////////////////////////
static bool configure_streams(const struct device *i2s_dev_rx,
                              const struct device *i2s_dev_tx,
                              const struct i2s_config *base_config)
{
    int ret;
    struct i2s_config config = *base_config; // Копируем базу (частота, формат)

    /* RX Settings*/
    config.mem_slab = &mem_slab_rx;
    ret = i2s_configure(i2s_dev_rx, I2S_DIR_RX, &config);
    if (ret < 0) {
        printf("Failed to configure RX: %d\n", ret);
        return false;
    }

    /* TX Settings*/
    config.mem_slab = &mem_slab_tx;
    ret = i2s_configure(i2s_dev_tx, I2S_DIR_TX, &config);
    if (ret < 0) {
        printf("Failed to configure TX: %d\n", ret);
        return false;
    }

    return true;
}

static bool prepare_transfer(const struct device *i2s_dev_tx)
{
    int ret;

    for (int i = 0; i < ZEPHYR_AUDIO_INITIAL_BLOCKS; ++i)
    {
        void *mem_block;

        ret = k_mem_slab_alloc(&mem_slab_tx, &mem_block, K_NO_WAIT);
        if (ret < 0)
        {
            printf("Failed to allocate TX block %d: %d\n", i, ret);
            return false;
        }

        memset(mem_block, 0, ZEPHYR_AUDIO_BLOCK_SIZE);

        ret = i2s_write(i2s_dev_tx, mem_block, ZEPHYR_AUDIO_BLOCK_SIZE);
        if (ret < 0)
        {
            printf("Failed to write block %d: %d\n", i, ret);
            return false;
        }
    }

    return true;
}