/*
 * Copyright (c) 2021 Nordic Semiconductor ASA.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <pm/policy.h>
#include <sys/time_units.h>
#include <sys_clock.h>
#include <ztest.h>

#ifdef CONFIG_PM_POLICY_DEFAULT
/**
 * @brief Test the behavior of pm_policy_next_state() when
 * CONFIG_PM_POLICY_DEFAULT=y.
 */
static void test_pm_policy_next_state_default(void)
{
	const struct pm_state_info *next;

	/* cpu 0 */
	next = pm_policy_next_state(0U, 0);
	zassert_equal(next, NULL, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(10999));
	zassert_equal(next, NULL, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);
	zassert_equal(next->min_residency_us, 100000, NULL);
	zassert_equal(next->exit_latency_us, 10000, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(1099999));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(1100000));
	zassert_equal(next->state, PM_STATE_SUSPEND_TO_RAM, NULL);
	zassert_equal(next->min_residency_us, 1000000, NULL);
	zassert_equal(next->exit_latency_us, 100000, NULL);

	next = pm_policy_next_state(0U, K_TICKS_FOREVER);
	zassert_equal(next->state, PM_STATE_SUSPEND_TO_RAM, NULL);

	/* cpu 1 */
	next = pm_policy_next_state(1U, 0);
	zassert_equal(next, NULL, NULL);

	next = pm_policy_next_state(1U, k_us_to_ticks_floor32(549999));
	zassert_equal(next, NULL, NULL);

	next = pm_policy_next_state(1U, k_us_to_ticks_floor32(550000));
	zassert_equal(next->state, PM_STATE_SUSPEND_TO_RAM, NULL);
	zassert_equal(next->min_residency_us, 500000, NULL);
	zassert_equal(next->exit_latency_us, 50000, NULL);

	next = pm_policy_next_state(1U, K_TICKS_FOREVER);
	zassert_equal(next->state, PM_STATE_SUSPEND_TO_RAM, NULL);
}

/**
 * @brief Test the behavior of pm_policy_next_state() when
 * states are allowed/disallowed and CONFIG_PM_POLICY_DEFAULT=y.
 */
static void test_pm_policy_next_state_default_allowed(void)
{
	bool active;
	const struct pm_state_info *next;

	/* initial state: PM_STATE_RUNTIME_IDLE allowed
	 * next state: PM_STATE_RUNTIME_IDLE
	 */
	active = pm_policy_state_lock_is_active(PM_STATE_RUNTIME_IDLE);
	zassert_false(active, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);

	/* disallow PM_STATE_RUNTIME_IDLE
	 * next state: NULL (active)
	 */
	pm_policy_state_lock_get(PM_STATE_RUNTIME_IDLE);

	active = pm_policy_state_lock_is_active(PM_STATE_RUNTIME_IDLE);
	zassert_true(active, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next, NULL, NULL);

	/* allow PM_STATE_RUNTIME_IDLE again
	 * next state: PM_STATE_RUNTIME_IDLE
	 */
	pm_policy_state_lock_put(PM_STATE_RUNTIME_IDLE);

	active = pm_policy_state_lock_is_active(PM_STATE_RUNTIME_IDLE);
	zassert_false(active, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);
}

/** Flag to indicate if latency callback has been called */
static bool latency_cb_called;
/** Flag to indicate expected latency */
static int32_t expected_latency;

/**
 * Callback to notify when state allowed status changes.
 */
static void on_pm_policy_latency_changed(int32_t latency)
{
	TC_PRINT("Latency changed to %d\n", latency);

	zassert_equal(latency, expected_latency, NULL);

	latency_cb_called = true;
}

/**
 * @brief Test the behavior of pm_policy_next_state() when
 * latency requirements are imposed and CONFIG_PM_POLICY_DEFAULT=y.
 */
static void test_pm_policy_next_state_default_latency(void)
{
	struct pm_policy_latency_request req1, req2;
	const struct pm_state_info *next;

	/* add a latency requirement with a maximum value below the
	 * latency given by any state, so we should stay active all the time
	 */
	pm_policy_latency_request_add(&req1, 9000);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next, NULL, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(1100000));
	zassert_equal(next, NULL, NULL);

	/* update latency requirement to a value between latencies for
	 * PM_STATE_RUNTIME_IDLE and PM_STATE_SUSPEND_TO_RAM, so we should
	 * never enter PM_STATE_SUSPEND_TO_RAM.
	 */
	pm_policy_latency_request_update(&req1, 50000);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(1100000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);

	/* add a new latency requirement with a maximum value below the
	 * latency given by any state, so we should stay active all the time
	 * since it overrides the previous one.
	 */
	pm_policy_latency_request_add(&req2, 8000);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next, NULL, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(1100000));
	zassert_equal(next, NULL, NULL);

	/* remove previous request, so we should recover behavior given by
	 * first request.
	 */
	pm_policy_latency_request_remove(&req2);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(1100000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);

	/* remove first request, so we should observe regular behavior again */
	pm_policy_latency_request_remove(&req1);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(110000));
	zassert_equal(next->state, PM_STATE_RUNTIME_IDLE, NULL);

	next = pm_policy_next_state(0U, k_us_to_ticks_floor32(1100000));
	zassert_equal(next->state, PM_STATE_SUSPEND_TO_RAM, NULL);

	/* get notified when latency requirement changes */
	pm_policy_latency_changed(on_pm_policy_latency_changed);

	/* add new request (expected notification) */
	latency_cb_called = false;
	expected_latency = 10000;
	pm_policy_latency_request_add(&req1, 10000);
	zassert_true(latency_cb_called, NULL);

	/* update request (expected notification) */
	latency_cb_called = false;
	expected_latency = 50000;
	pm_policy_latency_request_update(&req1, 50000);
	zassert_true(latency_cb_called, NULL);

	/* add a new request, with higher value (no notification, previous
	 * prevails)
	 */
	latency_cb_called = false;
	pm_policy_latency_request_add(&req2, 60000);
	zassert_false(latency_cb_called, NULL);

	pm_policy_latency_request_remove(&req2);
	zassert_false(latency_cb_called, NULL);

	/* remove first request, we no longer have latency requirements */
	expected_latency = SYS_FOREVER_US;
	pm_policy_latency_request_remove(&req1);
	zassert_true(latency_cb_called, NULL);
}
#else
static void test_pm_policy_next_state_default(void)
{
	ztest_test_skip();
}

static void test_pm_policy_next_state_default_allowed(void)
{
	ztest_test_skip();
}
static void test_pm_policy_next_state_default_latency(void)
{
	ztest_test_skip();
}
#endif /* CONFIG_PM_POLICY_DEFAULT */

#ifdef CONFIG_PM_POLICY_CUSTOM
const struct pm_state_info *pm_policy_next_state(uint8_t cpu, int32_t ticks)
{
	static const struct pm_state_info state = {.state = PM_STATE_SOFT_OFF};

	ARG_UNUSED(cpu);
	ARG_UNUSED(ticks);

	return &state;
}

/**
 * @brief Test that a custom policy can be implemented when
 * CONFIG_PM_POLICY_CUSTOM=y.
 */
static void test_pm_policy_next_state_custom(void)
{
	const struct pm_state_info *next;

	next = pm_policy_next_state(0U, 0);
	zassert_equal(next->state, PM_STATE_SOFT_OFF, NULL);
}
#else
static void test_pm_policy_next_state_custom(void)
{
	ztest_test_skip();
}
#endif /* CONFIG_PM_POLICY_CUSTOM */

void test_main(void)
{
	ztest_test_suite(policy_api,
			 ztest_unit_test(test_pm_policy_next_state_default),
			 ztest_unit_test(test_pm_policy_next_state_default_allowed),
			 ztest_unit_test(test_pm_policy_next_state_default_latency),
			 ztest_unit_test(test_pm_policy_next_state_custom));
	ztest_run_test_suite(policy_api);
}