/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/ztest.h>

#define TIMEOUT K_MSEC(100)
#if !defined(CONFIG_BOARD_QEMU_X86)
#define STACK_SIZE (512 + CONFIG_TEST_EXTRA_STACK_SIZE)
#else
#define STACK_SIZE (640 + CONFIG_TEST_EXTRA_STACK_SIZE)
#endif
#define MAIL_LEN 64

/**
 * @brief Tests for the mailbox kernel object
 * @defgroup kernel_mbox_api Mailbox
 * @ingroup all_tests
 * @{
 * @}
 */

/**TESTPOINT: init via K_MBOX_DEFINE*/
K_MBOX_DEFINE(kmbox);

static struct k_mbox mbox;

static k_tid_t sender_tid, receiver_tid, random_tid;

static K_THREAD_STACK_DEFINE(tstack, STACK_SIZE);
static K_THREAD_STACK_DEFINE(rtstack, STACK_SIZE);
static K_THREAD_STACK_DEFINE(tstack_1, STACK_SIZE);
static K_THREAD_STACK_ARRAY_DEFINE(waiting_get_stack, 5, STACK_SIZE);
static struct k_thread tdata, rtdata, async_tid, waiting_get_tid[5];

static struct k_sem end_sema, sync_sema;

static enum mmsg_type {
	PUT_GET_NULL = 0,
	PUT_GET_BUFFER,
	ASYNC_PUT_GET_BUFFER,
	ASYNC_PUT_GET_BLOCK,
	TARGET_SOURCE_THREAD_BUFFER,
	MAX_INFO_TYPE,
	INCORRECT_RECEIVER_TID,
	INCORRECT_TRANSMIT_TID,
	TIMED_OUT_MBOX_GET,
	MSG_TID_MISMATCH,
	DISPOSE_SIZE_0_MSG,
	ASYNC_PUT_TO_WAITING_GET,
	GET_WAITING_PUT_INCORRECT_TID,
	ASYNC_MULTIPLE_PUT,
	MULTIPLE_WAITING_GET
} info_type;

static char data[MAX_INFO_TYPE][MAIL_LEN] = {
	"send/recv an empty message",
	"send/recv msg using a buffer",
	"async send/recv msg using a memory block",
	"specify target/source thread, using a memory block"
};

static void async_put_sema_give(void *p1, void *p2, void *p3)
{
	k_sem_give(&sync_sema);
}


static void mbox_get_waiting_thread(void *p1, void *p2, void *p3)
{
	int thread_number = POINTER_TO_INT(p1);
	struct k_mbox *pmbox = p2;
	struct k_mbox_msg mmsg = {0};

	switch (thread_number) {
	case 0:
		mmsg.rx_source_thread = K_ANY;
		break;

	case 1:
		mmsg.rx_source_thread = random_tid;
		break;

	case 2:
		mmsg.rx_source_thread = receiver_tid;
		break;

	case 3:
		mmsg.rx_source_thread = &async_tid;
		break;

	case 4:
		mmsg.rx_source_thread = K_ANY;
		break;

	default:
		break;
	}

	mmsg.size = 0;
	zassert_true(k_mbox_get(pmbox, &mmsg, NULL, K_FOREVER) == 0,
		     "Failure at thread number %d", thread_number);

}

static void tmbox_put(struct k_mbox *pmbox)
{
	struct k_mbox_msg mmsg = {0};

	switch (info_type) {
	case PUT_GET_NULL:
		/**TESTPOINT: mbox sync put empty message*/
		mmsg.info = PUT_GET_NULL;
		mmsg.size = 0;
		mmsg.tx_data = NULL;
		mmsg.tx_target_thread = K_ANY;
		k_mbox_put(pmbox, &mmsg, K_FOREVER);
		break;
	case PUT_GET_BUFFER:
		__fallthrough;
	case TARGET_SOURCE_THREAD_BUFFER:
		/**TESTPOINT: mbox sync put buffer*/
		mmsg.info = PUT_GET_BUFFER;
		mmsg.size = sizeof(data[info_type]);
		mmsg.tx_data = data[info_type];
		if (info_type == TARGET_SOURCE_THREAD_BUFFER) {
			mmsg.tx_target_thread = receiver_tid;
		} else {
			mmsg.tx_target_thread = K_ANY;
		}
		k_mbox_put(pmbox, &mmsg, K_FOREVER);
		break;
	case ASYNC_PUT_GET_BUFFER:
		/**TESTPOINT: mbox async put buffer*/
		mmsg.info = ASYNC_PUT_GET_BUFFER;
		mmsg.size = sizeof(data[info_type]);
		mmsg.tx_data = data[info_type];
		mmsg.tx_target_thread = K_ANY;
		k_mbox_async_put(pmbox, &mmsg, &sync_sema);
		/*wait for msg being taken*/
		k_sem_take(&sync_sema, K_FOREVER);
		break;
	case ASYNC_PUT_GET_BLOCK:
		__fallthrough;
	case INCORRECT_TRANSMIT_TID:
		mmsg.tx_target_thread = random_tid;
		zassert_true(k_mbox_put(pmbox,
					&mmsg,
					K_NO_WAIT) == -ENOMSG, NULL);
		break;
	case MSG_TID_MISMATCH:
		/* keep one msg in the queue and try to get with a wrong tid */
		mmsg.info = PUT_GET_NULL;
		mmsg.size = 0;
		mmsg.tx_data = NULL;
		mmsg.tx_target_thread = sender_tid;
		/* timeout because this msg wont be received with a _get*/
		k_mbox_put(pmbox, &mmsg, TIMEOUT);
		break;

	case DISPOSE_SIZE_0_MSG:
		/* Get a msg and dispose it by making the size = 0 */
		mmsg.size = 0;
		mmsg.tx_data = data[1];
		mmsg.tx_block.data = NULL;
		mmsg.tx_target_thread = K_ANY;
		zassert_true(k_mbox_put(pmbox, &mmsg, K_FOREVER) == 0);
		break;

	case ASYNC_PUT_TO_WAITING_GET:
		k_sem_take(&sync_sema, K_FOREVER);
		mmsg.size = sizeof(data[0]);
		mmsg.tx_data = data[0];
		mmsg.tx_target_thread = K_ANY;
		k_mbox_async_put(pmbox, &mmsg, NULL);
		break;
	case GET_WAITING_PUT_INCORRECT_TID:
		k_sem_take(&sync_sema, K_FOREVER);
		mmsg.size = sizeof(data[0]);
		mmsg.tx_data = data[0];
		mmsg.tx_target_thread = random_tid;
		k_mbox_async_put(pmbox, &mmsg, &sync_sema);
		break;
	case ASYNC_MULTIPLE_PUT:
		mmsg.size = sizeof(data[0]);
		mmsg.tx_data = data[0];
		mmsg.tx_target_thread = K_ANY;
		k_mbox_async_put(pmbox, &mmsg, NULL);

		mmsg.tx_data = data[1];
		mmsg.tx_target_thread = &async_tid;
		k_mbox_async_put(pmbox, &mmsg, NULL);

		mmsg.tx_data = data[1];
		mmsg.tx_target_thread = receiver_tid;
		k_mbox_async_put(pmbox, &mmsg, NULL);

		mmsg.tx_data = data[1];
		mmsg.tx_target_thread = &async_tid;
		k_mbox_async_put(pmbox, &mmsg, NULL);

		mmsg.tx_data = data[2];
		mmsg.tx_target_thread = receiver_tid;
		k_mbox_async_put(pmbox, &mmsg, &sync_sema);

		k_sem_take(&sync_sema, K_FOREVER);
		break;

	case MULTIPLE_WAITING_GET:
		k_sem_take(&sync_sema, K_FOREVER);

		mmsg.size = sizeof(data[0]);
		mmsg.tx_data = data[0];
		mmsg.tx_target_thread = K_ANY;
		k_mbox_put(pmbox, &mmsg, K_NO_WAIT);

		mmsg.tx_data = data[1];
		mmsg.tx_target_thread = &async_tid;
		k_mbox_put(pmbox, &mmsg, K_NO_WAIT);

		mmsg.tx_data = data[1];
		mmsg.tx_target_thread = receiver_tid;
		k_mbox_put(pmbox, &mmsg, K_NO_WAIT);

		mmsg.tx_data = data[1];
		mmsg.tx_target_thread = &async_tid;
		k_mbox_put(pmbox, &mmsg, K_NO_WAIT);

		mmsg.tx_data = data[2];
		mmsg.tx_target_thread = receiver_tid;
		k_mbox_put(pmbox, &mmsg, K_NO_WAIT);

		break;
	default:
		break;
	}
}

static void tmbox_get(struct k_mbox *pmbox)
{
	struct k_mbox_msg mmsg = {0};
	char rxdata[MAIL_LEN];

	switch (info_type) {
	case PUT_GET_NULL:
		/**TESTPOINT: mbox sync get buffer*/
		mmsg.size = sizeof(rxdata);
		mmsg.rx_source_thread = K_ANY;
		/*verify return value*/
		zassert_true(k_mbox_get(pmbox, &mmsg, rxdata, K_FOREVER) == 0,
			     NULL);
		/*verify .info*/
		zassert_equal(mmsg.info, PUT_GET_NULL);
		/*verify .size*/
		zassert_equal(mmsg.size, 0);
		break;
	case PUT_GET_BUFFER:
		__fallthrough;
	case TARGET_SOURCE_THREAD_BUFFER:
		/**TESTPOINT: mbox sync get buffer*/
		mmsg.size = sizeof(rxdata);
		if (info_type == TARGET_SOURCE_THREAD_BUFFER) {
			mmsg.rx_source_thread = sender_tid;
		} else {
			mmsg.rx_source_thread = K_ANY;
		}
		zassert_true(k_mbox_get(pmbox, &mmsg, rxdata, K_FOREVER) == 0,
			     NULL);
		zassert_equal(mmsg.info, PUT_GET_BUFFER);
		zassert_equal(mmsg.size, sizeof(data[info_type]));
		/*verify rxdata*/
		zassert_true(memcmp(rxdata, data[info_type], MAIL_LEN) == 0,
			     NULL);
		break;
	case ASYNC_PUT_GET_BUFFER:
		/**TESTPOINT: mbox async get buffer*/
		mmsg.size = sizeof(rxdata);
		mmsg.rx_source_thread = K_ANY;
		zassert_true(k_mbox_get(pmbox, &mmsg, NULL, K_FOREVER) == 0,
			     NULL);
		zassert_equal(mmsg.info, ASYNC_PUT_GET_BUFFER);
		zassert_equal(mmsg.size, sizeof(data[info_type]));
		k_mbox_data_get(&mmsg, rxdata);
		zassert_true(memcmp(rxdata, data[info_type], MAIL_LEN) == 0,
			     NULL);
		break;
	case ASYNC_PUT_GET_BLOCK:
		__fallthrough;
	case INCORRECT_RECEIVER_TID:
		mmsg.rx_source_thread = random_tid;
		zassert_true(k_mbox_get
			     (pmbox, &mmsg, NULL, K_NO_WAIT) == -ENOMSG,
			     NULL);
		break;
	case TIMED_OUT_MBOX_GET:
		mmsg.rx_source_thread = random_tid;
		zassert_true(k_mbox_get(pmbox, &mmsg, NULL, TIMEOUT) == -EAGAIN,
			     NULL);
		break;
	case MSG_TID_MISMATCH:
		mmsg.rx_source_thread = random_tid;
		zassert_true(k_mbox_get
			     (pmbox, &mmsg, NULL, K_NO_WAIT) == -ENOMSG, NULL);
		break;

	case DISPOSE_SIZE_0_MSG:
		mmsg.rx_source_thread = K_ANY;
		mmsg.size = 0;
		zassert_true(k_mbox_get(pmbox, &mmsg, &rxdata, K_FOREVER) == 0,
			     NULL);
		break;

	case ASYNC_PUT_TO_WAITING_GET:

		/* Create a new thread to trigger the semaphore needed for the
		 * async put.
		 */
		k_thread_create(&async_tid, tstack_1, STACK_SIZE,
				       async_put_sema_give, NULL, NULL, NULL,
				       K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
		mmsg.rx_source_thread = K_ANY;
		mmsg.size = 0;
		/* Here get is blocked until the thread we created releases
		 *  the semaphore and the async put completes it operation.
		 */
		zassert_true(k_mbox_get(pmbox, &mmsg, NULL, K_FOREVER) == 0,
			     NULL);
		break;
	case GET_WAITING_PUT_INCORRECT_TID:
		/* Create a new thread to trigger the semaphore needed for the
		 * async put.
		 */
		k_thread_create(&async_tid, tstack_1, STACK_SIZE,
				       async_put_sema_give, NULL, NULL, NULL,
				       K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
		mmsg.rx_source_thread = &async_tid;
		mmsg.size = 0;
		/* Here the get is waiting for a async put to complete
		 * but the TIDs of the msgs doesn't match and hence
		 * causing a timeout.
		 */
		zassert_true(k_mbox_get(pmbox, &mmsg, NULL, TIMEOUT) == -EAGAIN,
			     NULL);
		/* clean up  */
		mmsg.rx_source_thread = K_ANY;
		zassert_true(k_mbox_get(pmbox, &mmsg, NULL, TIMEOUT) == 0,
			     NULL);
		break;

	case ASYNC_MULTIPLE_PUT:
		/* Async put has now populated the msgs. Now retrieve all
		 * the msgs from the mailbox.
		 */
		mmsg.rx_source_thread = K_ANY;
		mmsg.size = 0;
		/* get K_any msg */
		zassert_true(k_mbox_get(pmbox, &mmsg, NULL, TIMEOUT) == 0,
			     NULL);
		/* get the msg specific to receiver_tid */
		mmsg.rx_source_thread = sender_tid;
		zassert_true(k_mbox_get
			     (pmbox, &mmsg, NULL, TIMEOUT) == 0, NULL);

		/* get msg from async or random tid */
		mmsg.rx_source_thread = K_ANY;
		zassert_true(k_mbox_get
			     (pmbox, &mmsg, NULL, TIMEOUT) == 0, NULL);
		break;
	case MULTIPLE_WAITING_GET:
		/* Create 5 threads who will wait on a mbox_get. */
		for (uint32_t i = 0; i < 5; i++) {
			k_thread_create(&waiting_get_tid[i],
					waiting_get_stack[i],
					STACK_SIZE,
					mbox_get_waiting_thread,
					INT_TO_POINTER(i), pmbox, NULL,
					K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
		}
		/* Create a new thread to trigger the semaphore needed for the
		 * async put. This will trigger the start of the msg transfer.
		 */
		k_thread_create(&async_tid, tstack_1, STACK_SIZE,
				       async_put_sema_give, NULL, NULL, NULL,
				       K_PRIO_PREEMPT(1), 0, K_NO_WAIT);
		break;

	default:
		break;
	}
}



/*entry of contexts*/
static void tmbox_entry(void *p1, void *p2, void *p3)
{
	tmbox_get((struct k_mbox *)p1);
	k_sem_give(&end_sema);
}

static void tmbox(struct k_mbox *pmbox)
{
	/*test case setup*/
	k_sem_reset(&end_sema);
	k_sem_reset(&sync_sema);

	/**TESTPOINT: thread-thread data passing via mbox*/
	sender_tid = k_current_get();
	receiver_tid = k_thread_create(&tdata, tstack, STACK_SIZE,
				       tmbox_entry, pmbox, NULL, NULL,
				       K_PRIO_PREEMPT(0), 0, K_NO_WAIT);

	tmbox_put(pmbox);
	k_sem_take(&end_sema, K_FOREVER);

	/*test case teardown*/
	k_thread_abort(receiver_tid);
}

/*test cases*/
ZTEST(mbox_api, test_mbox_kinit)
{
	/**TESTPOINT: init via k_mbox_init*/
	k_mbox_init(&mbox);
}

ZTEST(mbox_api, test_mbox_kdefine)
{
	info_type = PUT_GET_NULL;
	tmbox(&kmbox);
}

static void thread_mbox_data_get_null(void *p1, void *p2, void *p3)
{
	struct k_mbox_msg get_msg = {0};
	char str_data[] = "it string for get msg test";

	get_msg.size = 16;
	get_msg.rx_source_thread = K_ANY;
	get_msg.tx_block.data = str_data;
	get_msg._syncing_thread = NULL;

	k_mbox_data_get(&get_msg, NULL);
	k_sem_give(&end_sema);
}

/**
 *
 * @brief Test k_mbox_data_get() API
 *
 * @details
 * - Init a mbox and just invoke k_mbox_data_get() with different
 *   input to check robust of API.
 *
 * @see k_mbox_data_get()
 *
 * @ingroup kernel_mbox_api
 */
ZTEST(mbox_api, test_mbox_data_get_null)
{
	k_sem_reset(&end_sema);

	receiver_tid = k_thread_create(&tdata, tstack, STACK_SIZE,
					thread_mbox_data_get_null,
					NULL, NULL, NULL,
					K_PRIO_PREEMPT(0), 0,
					K_NO_WAIT);
	k_sem_take(&end_sema, K_FOREVER);
	/*test case teardown*/
	k_thread_abort(receiver_tid);
}

static void thread_mbox_get_block_data(void *p1, void *p2, void *p3)
{
	k_sem_take(&sync_sema, K_FOREVER);
	struct k_mbox_msg bdmsg = {0};

	bdmsg.size = MAIL_LEN;
	bdmsg.rx_source_thread = sender_tid;
	bdmsg.tx_target_thread = receiver_tid;
	bdmsg.tx_data = NULL;
	bdmsg.tx_block.data = data;
	bdmsg.tx_data = data;

	zassert_equal(k_mbox_get((struct k_mbox *)p1, &bdmsg, p2, K_FOREVER),
			0, NULL);

	k_sem_give(&end_sema);
}

/* give a block data to API k_mbox_async_put */
static void thread_mbox_put_block_data(void *p1, void *p2, void *p3)
{
	struct k_mbox_msg put_msg = {0};

	put_msg.size = MAIL_LEN;
	put_msg.tx_data = NULL;
	put_msg.tx_block.data = p2;
	put_msg.tx_target_thread = receiver_tid;
	put_msg.rx_source_thread = sender_tid;

	k_mbox_async_put((struct k_mbox *)p1, &put_msg, NULL);
}

/**
 *
 * @brief Test put and get mailbox with block data
 *
 * @details
 * - Create two threads to put and get block data with
 *   specify thread ID and K_FOREVER for each other.
 * - Check the result after finished exchange.
 *
 * @see k_mbox_init() k_mbox_async_put() k_mbox_get()
 *
 * @ingroup kernel_mbox_api
 */
ZTEST(mbox_api, test_mbox_get_put_block_data)
{
	struct k_mbox bdmbox;
	/*test case setup*/
	k_sem_reset(&end_sema);
	k_sem_reset(&sync_sema);
	k_mbox_init(&bdmbox);
	char buff[MAIL_LEN];
	char data_put[] = "mbox put data";

	/**TESTPOINT: thread-thread data passing via mbox*/
	sender_tid = k_current_get();
	receiver_tid = k_thread_create(&rtdata, rtstack, STACK_SIZE,
				       thread_mbox_get_block_data,
				       &bdmbox, buff, NULL,
				       K_PRIO_PREEMPT(0), 0, K_NO_WAIT);

	sender_tid = k_thread_create(&tdata, tstack, STACK_SIZE,
				      thread_mbox_put_block_data,
				      &bdmbox, data_put, NULL,
				       K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
	k_sem_give(&sync_sema);
	k_sem_take(&end_sema, K_FOREVER);
	/*abort receiver thread*/
	k_thread_abort(receiver_tid);
	k_thread_abort(sender_tid);

	zassert_equal(memcmp(buff, data_put, sizeof(data_put)), 0,
			     NULL);
}

static ZTEST_BMEM char __aligned(4) buffer[8];

/**
 *
 * @brief Test mailbox enhance capabilities
 *
 * @details
 * - Define and initialized a message queue and a mailbox
 * - Verify the capability of message queue and mailbox
 * - with same data.
 *
 * @ingroup kernel_mbox_api
 *
 * @see k_msgq_init() k_msgq_put() k_mbox_async_put() k_mbox_get()
 */
ZTEST(mbox_api, test_enhance_capability)
{
	info_type = ASYNC_PUT_GET_BUFFER;
	struct k_msgq msgq;

	k_msgq_init(&msgq, buffer, 4, 2);
	/* send buffer with message queue */
	int ret = k_msgq_put(&msgq, &data[info_type], K_NO_WAIT);

	zassert_equal(ret, 0, "message queue put successful");

	/* send same buffer with mailbox */
	tmbox(&mbox);
}

/*
 *
 * @brife Test any number of mailbox can be defined
 *
 * @details
 * - Define multi mailbox and verify the mailbox whether as
 *   expected
 * - Verify the mailbox can be used
 *
 */
ZTEST(mbox_api, test_define_multi_mbox)
{
	/**TESTPOINT: init via k_mbox_init*/
	struct k_mbox mbox1, mbox2, mbox3;

	k_mbox_init(&mbox1);
	k_mbox_init(&mbox2);
	k_mbox_init(&mbox3);

	/* verify via send message */
	info_type = PUT_GET_NULL;
	tmbox(&mbox1);
	tmbox(&mbox2);
	tmbox(&mbox3);
}

ZTEST(mbox_api, test_mbox_put_get_null)
{
	info_type = PUT_GET_NULL;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_put_get_buffer)
{
	info_type = PUT_GET_BUFFER;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_async_put_get_buffer)
{
	info_type = ASYNC_PUT_GET_BUFFER;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_async_put_get_block)
{
	info_type = ASYNC_PUT_GET_BLOCK;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_target_source_thread_buffer)
{
	info_type = TARGET_SOURCE_THREAD_BUFFER;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_incorrect_receiver_tid)
{
	info_type = INCORRECT_RECEIVER_TID;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_incorrect_transmit_tid)
{
	info_type = INCORRECT_TRANSMIT_TID;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_timed_out_mbox_get)
{
	info_type = TIMED_OUT_MBOX_GET;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_msg_tid_mismatch)
{
	info_type = MSG_TID_MISMATCH;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_dispose_size_0_msg)
{
	info_type = DISPOSE_SIZE_0_MSG;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_async_put_to_waiting_get)
{
	info_type = ASYNC_PUT_TO_WAITING_GET;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_get_waiting_put_incorrect_tid)
{
	info_type = GET_WAITING_PUT_INCORRECT_TID;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_async_multiple_put)
{
	info_type = ASYNC_MULTIPLE_PUT;
	tmbox(&mbox);
}

ZTEST(mbox_api, test_mbox_multiple_waiting_get)
{
	info_type = MULTIPLE_WAITING_GET;
	tmbox(&mbox);

	/* cleanup the sender threads */
	for (int i = 0; i < 5 ; i++) {
		k_thread_abort(&waiting_get_tid[i]);
	}
}

void *setup_mbox_api(void)
{
	k_sem_init(&end_sema, 0, 1);
	k_sem_init(&sync_sema, 0, 1);
	k_mbox_init(&mbox);

	return NULL;
}

ZTEST_SUITE(mbox_api, NULL, setup_mbox_api, NULL, NULL, NULL);