/*
 * Copyright (c) 2021 intel, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <ztest.h>
#include <kernel.h>
#include <ztest_error_hook.h>

static struct k_poll_signal signal_err;
#define STACK_SIZE (1024 + CONFIG_TEST_EXTRA_STACKSIZE)
static struct k_thread test_thread1;
static struct k_thread test_thread2;
K_THREAD_STACK_DEFINE(test_stack1, STACK_SIZE);
K_THREAD_STACK_DEFINE(test_stack2, STACK_SIZE);

/**
 * @brief Test API k_poll with error events type in kernel mode
 *
 * @details Define a poll event and initialize by k_poll_event_init(), and using
 * API k_poll with error events type as parameter check if a error will be met.
 *
 * @see k_poll()
 *
 * @ingroup kernel_poll_tests
 */
void test_condition_met_type_err(void)
{
	struct k_poll_event event;
	struct k_fifo fifo;

	ztest_set_assert_valid(true);
	k_fifo_init(&fifo);
	k_poll_event_init(&event, K_POLL_TYPE_DATA_AVAILABLE, K_POLL_MODE_NOTIFY_ONLY, &fifo);

	event.type = 5;
	k_poll(&event, 1, K_NO_WAIT);
}

/* verify multiple pollers */
static K_SEM_DEFINE(multi_sem, 0, 1);
static K_SEM_DEFINE(multi_ready_sem, 1, 1);
static K_SEM_DEFINE(multi_reply, 0, 1);

static void thread_entry(void *p1, void *p2, void *p3)
{
	struct k_poll_event event;

	k_poll_event_init(&event, K_POLL_TYPE_SEM_AVAILABLE,
			  K_POLL_MODE_NOTIFY_ONLY, &multi_sem);

	(void)k_poll(&event, 1, K_FOREVER);
	k_sem_take(&multi_sem, K_FOREVER);
	k_sem_give(&multi_reply);
}

/**
 * @brief Test polling of multiple events by lower priority thread
 *
 * @details
 * - Test the multiple semaphore events as waitable events in poll.
 *
 * @ingroup kernel_poll_tests
 *
 * @see K_POLL_EVENT_INITIALIZER(), k_poll(), k_poll_event_init()
 */
void test_poll_lower_prio(void)
{
	int old_prio = k_thread_priority_get(k_current_get());
	struct k_thread *p = &test_thread1;
	const int main_low_prio = 10;
	const int low_prio_than_main = 11;
	int rc;

	struct k_poll_event events[] = {
		K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SEM_AVAILABLE,
					 K_POLL_MODE_NOTIFY_ONLY,
					 &multi_sem),
		K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SEM_AVAILABLE,
					 K_POLL_MODE_NOTIFY_ONLY,
					 &multi_ready_sem),
	};

	k_thread_priority_set(k_current_get(), main_low_prio);

	k_thread_create(&test_thread1, test_stack1,
			K_THREAD_STACK_SIZEOF(test_stack1),
			thread_entry, 0, 0, 0, low_prio_than_main,
			K_INHERIT_PERMS, K_NO_WAIT);

	k_thread_create(&test_thread2, test_stack2,
			K_THREAD_STACK_SIZEOF(test_stack2),
			thread_entry, 0, 0, 0, low_prio_than_main,
			K_INHERIT_PERMS, K_NO_WAIT);

	/* Set up the thread timeout value to check if what happened if dticks is invalid */
	p->base.timeout.dticks = _EXPIRED;

	/* Delay for some actions above */
	k_sleep(K_MSEC(250));
	(void)k_poll(events, ARRAY_SIZE(events), K_SECONDS(1));

	k_sem_give(&multi_sem);
	k_sem_give(&multi_sem);
	rc = k_sem_take(&multi_reply, K_FOREVER);

	zassert_equal(rc, 0, "");

	/* Reset the initialized state */
	k_thread_priority_set(k_current_get(), old_prio);
	k_sleep(K_MSEC(250));
}

#ifdef CONFIG_USERSPACE
/**
 * @brief Test API k_poll with error number events in user mode
 *
 * @details Using API k_poll with error number
 * as parameter to check if a error will be met.
 *
 * @see k_poll()
 *
 * @ingroup kernel_poll_tests
 */
void test_k_poll_user_num_err(void)
{
	struct k_poll_event events;

	k_poll(&events, -1, K_NO_WAIT);
}

/**
 * @brief Test API k_poll with error member of events in user mode
 *
 * @details Using API k_poll with error member
 * as parameter to check if a error will be met.
 *
 * @see k_poll()
 *
 * @ingroup kernel_poll_tests
 */
void test_k_poll_user_mem_err(void)
{
	ztest_set_fault_valid(true);
	k_poll(NULL, 3, K_NO_WAIT);
}

/**
 * @brief Test API k_poll with NULL sem event in user mode
 *
 * @details Define a poll event, and using API k_poll with NULL sem
 * as parameter to check if a error will be met.
 *
 * @see k_poll()
 *
 * @ingroup kernel_poll_tests
 */
void test_k_poll_user_type_sem_err(void)
{
	struct k_poll_event event[] = {
		K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SEM_AVAILABLE,
					 K_POLL_MODE_NOTIFY_ONLY,
					 NULL),
	};

	ztest_set_fault_valid(true);
	k_poll(event, 1, K_NO_WAIT);
}

/**
 * @brief Test API k_poll with NULL signal event in user mode
 *
 * @details Define a poll, and using API k_poll with NULL signal
 * as parameter to check if a error will be met.
 *
 * @see k_poll()
 *
 * @ingroup kernel_poll_tests
 */
void test_k_poll_user_type_signal_err(void)
{
	struct k_poll_event event[] = {
		K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SIGNAL,
					 K_POLL_MODE_NOTIFY_ONLY,
					 NULL),
	};

	ztest_set_fault_valid(true);
	k_poll(event, 1, K_NO_WAIT);
}

/**
 * @brief Test API k_poll with NULL fifo event in user mode
 *
 * @details Define a poll, and using API k_poll with NULL fifo
 * as parameter to check if a error will be met.
 *
 * @see k_poll()
 *
 * @ingroup kernel_poll_tests
 */
void test_k_poll_user_type_fifo_err(void)
{
	struct k_poll_event event[] = {
		K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_FIFO_DATA_AVAILABLE,
					 K_POLL_MODE_NOTIFY_ONLY,
					 NULL),
	};

	ztest_set_fault_valid(true);
	k_poll(event, 1, K_NO_WAIT);
}

/**
 * @brief Test API k_poll with NULL message queue event in user mode
 *
 * @details Define a poll, and using API k_poll with NULL message queue
 * as parameter to check if a error will be met.
 *
 * @see k_poll()
 *
 * @ingroup kernel_poll_tests
 */
void test_k_poll_user_type_msgq_err(void)
{
	struct k_poll_event event[] = {
		K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_MSGQ_DATA_AVAILABLE,
					 K_POLL_MODE_NOTIFY_ONLY,
					 NULL),
	};

	ztest_set_fault_valid(true);
	k_poll(event, 1, K_NO_WAIT);
}


/**
 * @brief Test API k_poll_signal_init with NULL in user mode
 *
 * @details Using API k_poll_signal_init with NULL as
 * parameter to check if a error will be met.
 *
 * @see k_poll_signal_init()
 *
 * @ingroup kernel_poll_tests
 */
void test_poll_signal_init_null(void)
{
	ztest_set_fault_valid(true);
	k_poll_signal_init(NULL);
}

/**
 * @brief Test API k_poll_signal_check with NULL object in user mode
 *
 * @details Using API k_poll with NULL object
 * as parameter to check if a error will be met.
 *
 * @see k_poll_signal_check()
 *
 * @ingroup kernel_poll_tests
 */
void test_poll_signal_check_obj(void)
{
	unsigned int signaled;
	int result;

	ztest_set_fault_valid(true);
	k_poll_signal_check(NULL, &signaled, &result);
}

/**
 * @brief Test API k_poll_signal_check with unread address
 * in user mode
 *
 * @details Using k_poll_signal_check with
 * unread results as parameter to check if a error
 * will be met.
 *
 * @see k_poll_signal_check()
 *
 * @ingroup kernel_poll_tests
 */
void test_poll_signal_check_signal(void)
{
	unsigned int result;

	k_poll_signal_init(&signal_err);

	ztest_set_fault_valid(true);
	k_poll_signal_check(&signal_err, NULL, &result);
}


/**
 * @brief Test API k_poll_signal_check with unread address
 * in user mode
 *
 * @details Using k_poll_signal_check with
 * unread signaled as parameter to check if a error
 * will be met.
 *
 * @see k_poll_signal_check()
 *
 * @ingroup kernel_poll_tests
 */
void test_poll_signal_check_result(void)
{
	int signaled;

	k_poll_signal_init(&signal_err);

	ztest_set_fault_valid(true);
	k_poll_signal_check(&signal_err, &signaled, NULL);
}

/**
 * @brief Test API k_poll_signal_raise with unread address
 * in user mode
 *
 * @details Using k_poll_signal_raise with
 * NULL as parameter to check if a error
 * will be met.
 *
 * @see k_poll_signal_raise()
 *
 * @ingroup kernel_poll_tests
 */
void test_poll_signal_raise_null(void)
{
	int result = 0;

	ztest_set_fault_valid(true);
	k_poll_signal_raise(NULL, result);
}

/**
 * @brief Test API k_poll_signal_reset with unread address
 * in user mode
 *
 * @details Using k_poll_signal_reset with
 * NULL as parameter to check if a error
 * will be met.
 *
 * @see k_poll_signal_reset()
 *
 * @ingroup kernel_poll_tests
 */
void test_poll_signal_reset_null(void)
{
	ztest_set_fault_valid(true);
	k_poll_signal_reset(NULL);
}
#endif /* CONFIG_USERSPACE */

void test_poll_fail_grant_access(void)
{
	k_thread_access_grant(k_current_get(), &signal_err);
}