/*
	OSSemTest.c

*/


#include "DHL_OSAL.h"

//#include "string.h"
//#include "stdio.h"


#if COMMENT
____SemTest____(){}
#endif



static DHL_OS_SEMA_ID lcsem, lmsem, lbsem;
static int sem_task_state;

void sem_test(int type, int value)
{
	int r;
	DHL_OS_TASK_INFO tInfo;
	DHL_OS_TASK_ID tid;

	printf("====> before test: csem 0x%x, msem 0x%x, bsem 0x%x\n", lcsem, lmsem, lbsem);
	tid = DHL_OS_GetTaskID();

	DHL_OS_GetTaskInfo(tid, &tInfo);
	printf("Task id = 0x%x, priority = %d, name = %s\n", tInfo.tid, tInfo.priority, tInfo.name);

	switch (type)
	{
	case 0:
		printf("sem: delete test\n");
		if (lcsem) {
			DHL_OS_DeleteSemaphore(lcsem);
			lcsem = 0;
		}
		break;

	case 1:
		printf("sem: create test\n");
		lcsem = DHL_OS_CreateCountingSemaphore("csem", 0, 0);
		break;
	case 2:
		printf("sem: take test, lcsem %x, timeout %d, tick %d\n", lcsem, value, DHL_OS_GetMsCount());
		r = DHL_OS_TakeSemaphore(lcsem, value);
		printf("sem taken, return %d, at %d\n", r, DHL_OS_GetMsCount());
		break;
	case 3:
		printf("sem: give test, lcsem %x, tick %d\n", lcsem, DHL_OS_GetMsCount());
		r = DHL_OS_GiveSemaphore(lcsem);
		printf("sem given, return %d at %d\n", r, DHL_OS_GetMsCount());
		break;

	/*
		Shell> OS_SemTest 1           // check csem id
		Shell> OS_SemTest 2 1000       // check if timeout occur.
		Shell> OS_SemTest 2 20000 &   // this will be blocked.
		Shell> OS_SemTest 3           // sem give and released.
	*/
	case 10:
		printf("mtx: delete\n");
		if (lmsem) {
			DHL_OS_DeleteSemaphore(lmsem);
			lmsem = 0;
		}
		break;
	case 11:
		printf("mtx: create\n");
		lmsem = DHL_OS_CreateMutexSemaphore("mtx");
		break;
	case 12:
		printf("mtx: take test, lmsem %x, timeout %d, tick %d\n", lmsem, value, DHL_OS_GetMsCount());
		r = DHL_OS_TakeSemaphore(lmsem, value);
		printf("mtx taken, err %d, at %d\n", r, DHL_OS_GetMsCount());
		break;
	case 13:
		printf("mtx: give test, lmsem %x, tick %d\n", lmsem, DHL_OS_GetMsCount());
		DHL_OS_GiveSemaphore(lmsem);
		printf("mtx given tick %d\n", DHL_OS_GetMsCount());
		break;
	/*	
	test1.
		Shell> OS_SemTest 11         // mutex create
		Shell> OS_SemTest 12 200     // mutex lock
		Shell> OS_SemTest 13         // mutex unlock ok.
		Shell> OS_SemTest 12 200     // mutex lock
		Shell> OS_SemTest 12 200 &   // mutex lock in task 2. fail with timeout.
		..
		Shell> OS_SemTest 13         // mutex unlock here. ok.
	test2.
		Shell> OS_SemTest 12 200 &
		Shell> OS_SemTest 12 200     // lock again. this will fail with timeout.
		
		Shell> OS_SemTest 12 200
		Shell> OS_SemTest 12 0x7fffffff &   // wait forever
		Shell> OS_SemTest 13
	*/
	case 20:
		printf("bsem: delete\n");
		if (lbsem) {
			DHL_OS_DeleteSemaphore(lbsem);
			lbsem = 0;
		}
		break;
	case 21:
		printf("bsem: create\n");
		lbsem = DHL_OS_CreateBinarySemaphore("bsem", 0, 0); // initial empty state
		break;
	case 22:
		printf("bsem: take test, timeout %d, tick %d\n", value, DHL_OS_GetMsCount());
		r = DHL_OS_TakeSemaphore(lbsem, value);
		printf("bsem taken, err %d, at %d\n", r, DHL_OS_GetMsCount());
		break;
	case 23:
		printf("bsem: give test, tick %d\n", DHL_OS_GetMsCount());
		DHL_OS_GiveSemaphore(lbsem);
		printf("bsem given tick %d\n", DHL_OS_GetMsCount());
		break;
		
	/*
		Shell> OS_SemTest 21      // create

		Shell> OS_SemTest 22 200  // take.. fail with timeout.
		Shell> OS_SemTest 23      // give
		Shell> OS_SemTest 22 0    // take.. ok
		
		Shell> OS_SemTest 23      // give
		Shell> OS_SemTest 23      // give again. still the count should be one.
		Shell> OS_SemTest 22 0    // take.. ok
		Shell> OS_SemTest 22 0    // take.. fail.
	*/

	
	}
	printf("====> after test: csem 0x%x, msem 0x%x, bsem 0x%x\n\n", lcsem, lmsem, lbsem);


}

typedef struct {
	int type;
	int value;
} tSemTaskArg;

static void sem_task(void* arg)
{
	while (sem_task_state != 0)
		DHL_OS_Delay(100);
	printf("sem_task: this task should be blocked for 5 sec\n");
	sem_test(2, 20000);	// this task should be blocked for 5 sec
	printf("sem_task: sem give\n");
	sem_test(3, 0);

	while (sem_task_state != 1)
		DHL_OS_Delay(100);

	printf("sem_task: mutex block test, this task should be blocked for 5 sec\n");
	sem_test(12, 20000);	// mutex block test, this task should be blocked for 5 sec
	printf("sem_task: mutex give\n");
	sem_test(13, 0);

	while (sem_task_state != 2)
		DHL_OS_Delay(100);
	printf("sem_task: recursive mutex test, this task should be resumed after 2nd unlock\n");
	sem_test(12, 50000);	// recursive mutex test, this task should be resumed after 2nd unlock
	printf("sem_task: mutex give\n");
	sem_test(13, 0);
	DHL_OS_SelfDeleteTask();
	return;
}

static void sem_task2(void* arg)
{

	/*
		¼¼¸¶Æ÷¾î Å×½ºÆ® ½ÃÀÛ
	*/
	printf("\n**** Semaphore test is started..\n\n");



	/* 
		1. timeout Å×½ºÆ® & block Å×½ºÆ®
	*/
	printf("SEM timeout test 1\n");
	printf("create semaphore\n");
	sem_test(1, 0);	// create semaphore
	printf("check if timeout occur\n");
	sem_test(2, 1000);	// check if timeout occur
	printf("sem_task_state = 0\n");
	sem_task_state = 0;	
	printf("delay 50000\n");
	DHL_OS_Delay(5000); 
	printf("delay sem give and released\n");
	sem_test(3, 0);	// sem give and released
	printf("delay 1000\n");
	DHL_OS_Delay(1000);
	printf("delete semaphore\n");
	sem_test(0, 0);


	/* 
		2. ¹ÂÅؽº Å×½ºÆ®
	*/
	printf("SEM mutex test 2\n");
	printf("mutex create\n");
	sem_test(11, 0);	// mutex create
	printf("mutex lock\n");
	sem_test(12, 0);	// mutex lock
	printf("mutex unlock. ok.\n");
	sem_test(13, 0);	// mutex unlock. ok.
	printf("mutex lock\n");
	sem_test(12, 0);	// mutex lock
	printf("sem_task_state = 1\n");
	sem_task_state = 1;
	printf("delay 20000\n");
	DHL_OS_Delay(2000);
	printf("mutex unlock here. ok.\n");
	sem_test(13, 0);	// mutex unlock here. ok.
	printf("delay 10000.\n");
	DHL_OS_Delay(1000);


	/*
		3. ¹ÂÅؽº Àç±Í Á¢±Ù Å×½ºÆ®		: //BKNOTE: mutex¿¡¼­ Àç±ÍÁ¢±ÙÀº Á¤ÀǵÇÁö ¸»¾Æ¾ßÇÏÁö ¾ÊÀ»±î...?
	*/
	printf("SEM timeout recursive 3\n");
	printf("mutex lock\n");
	sem_test(12, 0);	// mutex lock
	printf(" mutex 2nd lock\n");
	sem_test(12, 0);	// mutex 2nd lock
	printf(" sem_task_state = 2\n");
	sem_task_state = 2;
	printf(" delay 50000\n");
	DHL_OS_Delay(5000);
	printf(" mutex unlock\n");
	sem_test(13, 0);
	printf(" mutex 2nd unlock here.\n");
	sem_test(13, 0);	// mutex 2nd unlock here. ok.
	printf(" delay 30000\n");
	DHL_OS_Delay(3000);
	printf(" delete mutex\n");
	sem_test(10, 0);
	

	/*
		4. ¹ÙÀ̳ʸ® ¼¼¸¶Æ÷¾î Å×½ºÆ®	
	*/
	printf("SEM timeout binary test 4\n");
	printf("create binary semaphore\n");
	sem_test(21, 0);
	printf("take should be failed with timeout\n");
	sem_test(22, 200);	// take should be failed with timeout
	printf("give\n");
	sem_test(23, 0);	// give
	printf("take ok\n");
	sem_test(22, 0);	// take ok
	printf("give\n");
	sem_test(23, 0);	// give
	printf("give again. still the count should be one\n");
	sem_test(23, 0);	// give again. still the count should be one
	printf("take ok\n");
	sem_test(22, 0);	// take ok
	printf("take should be failed\n");
	sem_test(22, 0);	// take should be failed
	printf("delay 50000\n");	
	DHL_OS_Delay(5000);
	printf("delete binary semaphore\n");	
	sem_test(20, 0);
	
	/*
		¼¼¸¶Æ÷¾î Å×½ºÆ® Á¾·á
	*/
	printf("**** Semaphore test is completed\n\n");
	DHL_OS_SelfDeleteTask();
	return;
}

/*
	
*/
void OS_SemTest()
{
	sem_task_state = -1;
	DHL_OS_CreateTask(sem_task,"sem_task", 50, 8192, 0);	

//yhkim, NEO HAL ÀÇ °æ¿ì mutex take ½Ã task ÆǺ°À» ID °¡ ¾Æ´Ñ priority ·Î Çϴµ¥ 
//ÁöÁ¤µÈ task °¡ ¾Æ´Ñ main task ¿¡¼­ take ¸¦ ÇÒ °æ¿ì take ÀÇ default owner priority ¿Í 
//main task ÀÇ priority °¡ °°À» °æ¿ì°¡ ¹ß»ýÇÏ¿© take ¸¦ ÇÏÁö ¸øÇÏ´Â °æ¿ì ¹ß»ý.
//Test ½Ã main task ¿¡¼­ ÇÏÁö ¸»°í º°µµÀÇ task ¸¦ »ý¼ºÇÏ¿© Test.
#if 1
	DHL_OS_CreateTask(sem_task2,"sem_task2", 51, 8192, 0);
#else
	/*
		¼¼¸¶Æ÷¾î Å×½ºÆ® ½ÃÀÛ
	*/
	printf("\n**** Semaphore test is started..\n\n");



	/* 
		1. timeout Å×½ºÆ® & block Å×½ºÆ®
	*/
	sem_test(1, 0);	// create semaphore
	sem_test(2, 1000);	// check if timeout occur
	sem_task_state = 0;	
	DHL_OS_Delay(5000); 
	sem_test(3, 0);	// sem give and released

	DHL_OS_Delay(1000);
	sem_test(0, 0);


	/* 
		2. ¹ÂÅؽº Å×½ºÆ®
	*/
	sem_test(11, 0);	// mutex create
	sem_test(12, 0);	// mutex lock
	sem_test(13, 0);	// mutex unlock. ok.

	sem_test(12, 0);	// mutex lock
	sem_task_state = 1;
	DHL_OS_Delay(5000);
	sem_test(13, 0);	// mutex unlock here. ok.

	DHL_OS_Delay(1000);
	

	/*
		3. ¹ÂÅؽº Àç±Í Á¢±Ù Å×½ºÆ®		
	*/
	sem_test(12, 0);	// mutex lock
	sem_test(12, 0);	// mutex 2nd lock
	sem_task_state = 2;
	DHL_OS_Delay(5000);
	sem_test(13, 0);
	sem_test(13, 0);	// mutex 2nd unlock here. ok.

	DHL_OS_Delay(1000);
	sem_test(10, 0);
	

	/*
		4. ¹ÙÀ̳ʸ® ¼¼¸¶Æ÷¾î Å×½ºÆ®	
	*/
	sem_test(21, 0);
	sem_test(22, 200);	// take should be failed with timeout
	sem_test(23, 0);	// give
	sem_test(22, 0);	// take ok

	sem_test(23, 0);	// give
	sem_test(23, 0);	// give again. still the count should be one
	sem_test(22, 0);	// take ok
	sem_test(22, 0);	// take should be failed
	
	DHL_OS_Delay(1000);
	sem_test(20, 0);
	
	/*
		¼¼¸¶Æ÷¾î Å×½ºÆ® Á¾·á
	*/
	printf("**** Semaphore test is completed\n\n");
#endif	
}


#if COMMENT
____MsgQTest____(){}
#endif


static DHL_OS_MSGQ_ID s_testmsgq;
static int msgq_task_state;

void msgq_test(int type, int value, int value2)
{
	int err, i;
	UINT8 msg[20]; // length of message

	printf("====> before test: msgq 0x%x\n", s_testmsgq);
	if (type == 0) {
		printf("MsgQ delete test\n");
		if (s_testmsgq) {
			DHL_OS_DeleteMessageQueue(s_testmsgq);
			s_testmsgq = 0;
		}
	}
	if (type == 1) {
		printf("MsgQ create test. %d x msg size %d bytes\n", 10, sizeof(msg));
		if (s_testmsgq)
			printf("already created. recreate..\n");
		s_testmsgq = DHL_OS_CreateMessageQueue("Test", 0, 10, sizeof(msg));
		printf("MsgQ created: 0x%x\n", s_testmsgq);
	}
	else if (type == 2) {
		printf("MsgQ send test. send 1 msg (full size), at %d\n", DHL_OS_GetMsCount());
		for (i=0; i<sizeof(msg); i++)
			msg[i] = i;
		err = DHL_OS_SendMessage(s_testmsgq, msg, sizeof(msg));
		printf("MsgQ send result 0x%x\n", err);
	}
	else if (type == 3) {
		printf("MsgQ send test. send 1 msg (small size %d)\n", 5);
		msg[0] = msg[1] = msg[2] = msg[3] = msg[4] = 0x33;
		err = DHL_OS_SendMessage(s_testmsgq, msg, sizeof(msg));
		printf("MsgQ send result 0x%x, at %d\n", err, DHL_OS_GetMsCount());
	}
	else if (type == 4) {
		value2 = !value2 ? sizeof(msg) : value2;  // receive buffer size. if 0, enough buffer is used.
		printf("MsgQ recv with timeout %u tick, rx buf size %d\n", value, value2);
		memset(msg, 0, sizeof(msg));

		err = DHL_OS_ReceiveMessage(s_testmsgq, msg, value);
		if (err != DHL_OK)
			printf("!! msg rx err %d, at %d\n", err, DHL_OS_GetMsCount());
		else
		{
			printf("msg received at %d. : %d %d %d %d %d %d %d %d %d %d\n", 
				DHL_OS_GetMsCount(), msg[0], msg[1], msg[2], msg[3], msg[4], 
				msg[5], msg[6], msg[7], msg[8], msg[9]);
			printf("                %d %d %d %d %d %d %d %d %d %d\n", 
				msg[10], msg[11], msg[12], msg[13], msg[14], 
				msg[15], msg[16], msg[17], msg[18], msg[19]); 
		}
	}
	/*
		OS_MsgTest 0   // delete
		OS_MsgTest 1   // create
		OS_MsgTest 4 0 // rx no wait. this fails with timeout.

		OS_MsgTest 2   // send full msg
		OS_MsgTest 4 0 // rx no wait

		OS_MsgTest 3   // send partial msg
		OS_MsgTest 4 0 // ok.
		OS_MsgTest 4 0 // error

		OS_MsgTest 2 & // send from other task.
		OS_MsgTest 4 0 // ok.
		OS_MsgTest 4 0 // error

		OS_MsgTest 4 200     // error after some time.
		OS_MsgTest 4 2000 &  // pending..
		OS_MsgTest 2         // ok. wake up		
		
	*/
	printf("====> after test: msgq 0x%x\n\n", s_testmsgq);
}

static void msgq_task(void* arg)
{
	while (msgq_task_state != 0)
		DHL_OS_Delay(100);
	
	msgq_test(2, 0, 0);	// send full msg

	while (msgq_task_state != 1)
		DHL_OS_Delay(100);

	msgq_test(4, 2000, 0); 
	DHL_OS_SelfDeleteTask();

}

void OS_MsgQTest(void)
{
	msgq_task_state = -1;	

	DHL_OS_CreateTask(msgq_task, "msgq_task", 49, 8192, 0);

	/*
		¸Þ½ÃÁö Å¥ Å×½ºÆ® ½ÃÀÛ
	*/
	printf("\n**** MsgQ test is started..\n\n");
	
	/* 
		1. delete, create, timeout Å×½ºÆ®
	*/
	msgq_test(0, 0, 0);	// delete
	msgq_test(1, 0, 0);	// create
	msgq_test(4, 0, 0);	// rx no wait. this fails with timeout.
	DHL_OS_Delay(1000);

	/* 
		2. send, receive Å×½ºÆ®
	*/
	msgq_test(2, 0, 0);	// send full msg
	msgq_test(4, 0, 0);	// rx no wait
	DHL_OS_Delay(1000);

	/* 
		3. send, receive Å×½ºÆ® 2 
	*/
	msgq_test(3, 0, 0);	// send partial msg
	msgq_test(4, 0, 0);	// ok.
	msgq_test(4, 0, 0);	// error
	DHL_OS_Delay(1000);

	/* 
		4. ¼­·Î ´Ù¸¥ task¿¡¼­ send, receive Å×½ºÆ® 
	*/
	msgq_task_state = 0;	// send from other task.	
	DHL_OS_Delay(100);	
	msgq_test(4, 0, 0);	// ok.
	msgq_test(4, 0, 0);	// error
	DHL_OS_Delay(1000);
	
	/* 
		5. ¼­·Î ´Ù¸¥ task¿¡¼­ send, receive Å×½ºÆ® 2
	*/
	msgq_test(4, 1000, 0);	// error after some time.
	msgq_task_state = 1;	// pending..
	DHL_OS_Delay(1000);
	msgq_test(2, 0, 0);	// ok. wake up	

	DHL_OS_Delay(1000);
	msgq_test(0, 0, 0); // delete

	/*
		¸Þ½ÃÁö Å¥ Å×½ºÆ® Á¾·á
	*/
	printf("**** MsgQ test is completed\n\n");
}
 
 
#if COMMENT
____MessangerTest____(){}
#endif

#if 1
DHL_OS_MSGQ_ID s_msgq;

void OS_MsgListenerTask(void)
{
	char buf[200];
	int r;
	
	if (!s_msgq) {
		s_msgq = DHL_OS_CreateMessageQueue("", 0, 2, 200);
		printf("==> create msgq 0x%x..\n", s_msgq);
	}
	
	printf("==> start to listen..\n");
	while (1)
	{
		r = DHL_OS_ReceiveMessage(s_msgq, buf, DHL_TIMEOUT_FOREVER);
		if (r) {
			printf("!! msg rx err %d\n", r);
			break;
		}

		printf("==> msg len(%d), '%s'\n", strlen(buf), buf);
		if (strcmp("stop", buf) == 0)
			break;
	}
	printf("==> msg listener end.\n");

}

void OS_MsgSenderTest(const char *msg)
{
	int r;
	if (!s_msgq) {
		printf("!! msg listener not ready..\n");
		return;
	}
	if (!msg || !msg[0]) msg = "<null>";
	r = DHL_OS_SendMessage(s_msgq, (void *)msg, sizeof(msg));
	if (r)
		printf("==> msg send err %d\n", r);
}

/*
	Shell> OS_MsgSenderTest   // err if not created.
	Shell> OS_MsgListenerTask &
	
	Shell> OS_MsgSenderTest "hello world"
	Shell> OS_MsgSenderTest "this is test msg"

*/
#endif