/**
 * @file tests/can_raw.cpp
 * @brief CAN Raw messaging
 * @date Sep 5, 2015
 * @author jjacobs
 * @copyright 2015 Dual Inventive Technology Centre B.V.
 */
#include "fixtures/CANTest.hpp"

/**
 * Verify send and recv of DI_CAN_RAW_DTYPE_DINET_TIME results in the di_time_get_stamp updated
 */
TEST_F(DI_CAN, can_raw_send_time_verify_stamp) {
	const uint64_t time = 123456789;

	SetNodeid(0xdeadbeef);
	di_can_msg_enable_timesync(&_ctx, true);
	ASSERT_EQ(0, di_time_get_stamp());

	struct di_can_msg *msg = di_can_msg_alloc(&_ctx);
	ASSERT_NE(nullptr, msg);

	di_can_msg_set_canid(msg,
			     DI_CAN_MSGTYPE_RAW,
			     DI_CAN_TRANSFERTYPE_PUBLISH,
			     DI_CAN_RAW_DTYPE_DINET_TIME);

	ASSERT_EQ(DNOK, di_can_msg_write_data_u64(msg, time));
	ASSERT_EQ(DNOK, di_can_send_broadcast(&msg));
	ASSERT_EQ(time, di_time_get_stamp());

	di_time_set_ms(0);
}

/**
 * Verify the correct device uid raw message is send when calling di_can_raw_send
 */
TEST_F(DI_CAN, can_raw_send_data_device_uid) {
	struct di_can_msg *msg;
	static const char uid[33] = "12340000123400001234000012340000";

	SetNodeid(0xdeadbeef);

	/* raw send manual */
	ASSERT_EQ(DNOK, di_can_raw_send(&_ctx, DI_CAN_NODEID_BROADCAST, DI_CAN_TRANSFERTYPE_PUBLISH, DI_CAN_RAW_DTYPE_DEVICE_UID, DI_CAN_PTYPE_STRING, &uid, sizeof(uid)));
	msg = di_can_recv(&_ctx, DI_CAN_MSGTYPE_ANY);

	ASSERT_NE(nullptr, msg);
	ASSERT_EQ(DI_CAN_TRANSFERTYPE_PUBLISH, DI_CAN_GET_TRANSFERTYPE(msg->canid));
	ASSERT_EQ(DI_CAN_RAW_DTYPE_DEVICE_UID, DI_CAN_GET_DATATYPE(msg->canid));
	ASSERT_EQ(0xdeadbeef,                  msg->src_id);
	ASSERT_EQ(DI_CAN_NODEID_BROADCAST,     msg->dst_id);
	ASSERT_EQ(DI_CAN_PTYPE_STRING,         msg->ptype);
	ASSERT_EQ(sizeof(uid),                 msg->size);
	ASSERT_STREQ(uid,                      (const char *)msg->msg);

	/* raw send device_uid */
	ASSERT_EQ(DNOK, di_can_raw_send_device_uid(&_ctx, DI_CAN_NODEID_BROADCAST, DI_CAN_TRANSFERTYPE_PUBLISH, uid));
	msg = di_can_recv(&_ctx, DI_CAN_MSGTYPE_ANY);

	ASSERT_NE(nullptr, msg);
	ASSERT_EQ(DI_CAN_TRANSFERTYPE_PUBLISH, DI_CAN_GET_TRANSFERTYPE(msg->canid));
	ASSERT_EQ(DI_CAN_RAW_DTYPE_DEVICE_UID, DI_CAN_GET_DATATYPE(msg->canid));
	ASSERT_EQ(0xdeadbeef,                  msg->src_id);
	ASSERT_EQ(DI_CAN_NODEID_BROADCAST,     msg->dst_id);
	ASSERT_EQ(DI_CAN_PTYPE_STRING,         msg->ptype);
	ASSERT_EQ(sizeof(uid),                 msg->size);
	ASSERT_STREQ(uid,                      (const char *)msg->msg);
}

TEST_F(DI_CAN, can_raw_send_device_fw_hw_version) {
	struct di_can_msg *msg;

	SetNodeid(0xdeadbeef);

	// fw version
	static const char fw_version[DI_DEVICE_FW_VERSION_LEN] = "1.0.0";
	static const size_t fw_version_len = strlen(fw_version)+1;

	ASSERT_EQ(DNOK, di_can_raw_send_device_fw_version(&_ctx, DI_CAN_NODEID_BROADCAST, DI_CAN_TRANSFERTYPE_REPLY, fw_version));
	msg = di_can_recv(&_ctx, DI_CAN_MSGTYPE_ANY);

	ASSERT_NE(nullptr, msg);
	ASSERT_EQ(DI_CAN_TRANSFERTYPE_REPLY,   DI_CAN_GET_TRANSFERTYPE(msg->canid));
	ASSERT_EQ(DI_CAN_RAW_DTYPE_FW_VERSION, DI_CAN_GET_DATATYPE(msg->canid));
	ASSERT_EQ(0xdeadbeef,                  msg->src_id);
	ASSERT_EQ(DI_CAN_NODEID_BROADCAST,     msg->dst_id);
	ASSERT_EQ(DI_CAN_PTYPE_STRING,         msg->ptype);
	ASSERT_EQ(fw_version_len,              msg->size);
	ASSERT_STREQ(fw_version,               (const char *)msg->msg);

	// hw version
	static const char hw_version[DI_DEVICE_HW_VERSION_LEN] = "1.2";
	static const size_t hw_version_len = strlen(hw_version)+1;

	ASSERT_EQ(DNOK, di_can_raw_send_device_hw_version(&_ctx, DI_CAN_NODEID_BROADCAST, DI_CAN_TRANSFERTYPE_REPLY, hw_version));
	msg = di_can_recv(&_ctx, DI_CAN_MSGTYPE_ANY);

	ASSERT_NE(nullptr, msg);
	ASSERT_EQ(DI_CAN_TRANSFERTYPE_REPLY,   DI_CAN_GET_TRANSFERTYPE(msg->canid));
	ASSERT_EQ(DI_CAN_RAW_DTYPE_HW_VERSION, DI_CAN_GET_DATATYPE(msg->canid));
	ASSERT_EQ(0xdeadbeef,                  msg->src_id);
	ASSERT_EQ(DI_CAN_NODEID_BROADCAST,     msg->dst_id);
	ASSERT_EQ(DI_CAN_PTYPE_STRING,         msg->ptype);
	ASSERT_EQ(hw_version_len,              msg->size);
	ASSERT_STREQ(hw_version,               (const char *)msg->msg);
}