// shell.c


#include <912d60.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "kernel.h"
#include "semlib.h"




// FUNCTION PROTOTYPES
void shellcmd_help(char *argv1);
void shellcmd_tcb(signed char id);
void shellcmd_rcb(signed char id);
void shellcmd_rcbPrint(signed char rid);
void shellcmd_ticks(void);
void shellcmd_startTask(unsigned char id);
void shellcmd_stopTask(unsigned char id);
void shellcmd_freeMemCheck(void);
void shellcmd_kdb(int onoff);
void shellcmd_quitShell(void);
/*
void shellcmd_setTaskPriority(unsigned char id, unsigned char priority);
*/




// GLOBAL VARIABLES
extern unsigned long int system_tick;
extern unsigned int current;		   	 	// current task id number

extern char error_msg[8][25];
extern char error_src[5][18];

extern char kdb_trace;




void shell(void) {
	
	// LOCAL CONSTANTS
	#define cmd_size (32+1)

	
	
	// LOCAL ENUMERATIONS
	enum command_type {	help = 1,
		 			  	tcb, 
		 			  	rcb, 
						ticks,
						start,
						stop,
						priority,
						freemem,
						kdb,
						quit
	};
						
		
						
	// LOCAL VARIABLES
	char command[cmd_size], i, j, **argv, *cursor1, *cursor2;
	int cmd_length, argc;
	enum command_type cmd;
	
	
	
	
	// INITIALIZE SHELL
	sem_get(COM1);		  	   	  // get COM1 semaphore
	set_task_priority(current, 255);
	INTR_ON();			  		  // enable interrupts
	
	
	
	
	
	// SHELL COMMAND LINE INTERPRETER
	while (1) {
	
		  i = 0;
		  cursor1 = command;
		  cursor2 = command;
		  
		  
		  // put a PROMPT
		  putchar('>'); putchar('>'); putchar(' ');
		  
		  
		  // GET AND ECHO THE COMMAND on the console
		  while (((command[i]=getchar()) != 0xD) && (i<cmd_size)) {
		  		putchar(command[i]);
				
				// allow backspace to correct typing mistakes
				if (command[i] == 8) {
				    putchar(32);  		 // space
					putchar(8);			 // backspace
					command[i] = '\0';	 // null
					i--;
					} 
				else
				  	i++;
		  		}
		  // terminate the string
		  command[i] = NULL;
		  putchar('\n');
		  
		  
		  
		  // PUT COMMAND LINE INTO ARGV & ARGC to extract cmd/args		  
		  // make argc and argv arrays according to the command line input
		  i = 0;
		  argc = 1;
		  
		  // count command + args: argc
		  while (command[i] != NULL) {
		  		if (command[i] == ' ') 
				   argc++;
				i++;
		  		}
		  
		  
		  // allocate memory to argv
		  if ((argv = malloc(argc)) == NULL) {
		  	 puts(error_msg[5]);
			 exit(1);
		  	 }
	 
 
		  // extract the cmd/args
		  i = 0;
		  for (j=0; j<argc; j++) {
		  	  
			  // search command for letters/numbers
			  while (isgraph(command[i])) {
			  		i++;
					cursor2++;
			  		}
			  

			  // found a cmd/arg, so make a string array for it
		  	  if ((argv[j] = malloc(cursor2 - cursor1 + 1)) == NULL) {
			  	 puts(error_msg[5]);
				 exit(1);
			  	 }
			  
			  // move finding to argv[j] array, and add NULL char
			  memmove(argv[j], cursor1, cursor2 - cursor1 + 1);
			  argv[j][i] = NULL;
			  
			  // update cursors
		  	  cursor1 = command + i + 1;
			  cursor2 = cursor1;
			  i++;
			   
		  	  }  // end for j
		  
		  
		  
		  // CLASSIFY THE COMMAND
		  if (command[0] == 0xD);	 // CR, so start over
		  else if (strcmp(argv[0], "help") == 0)
		  	   cmd = help;
		  else if (strcmp(argv[0], "tcb") == 0)
		  	   cmd = tcb;
		  else if (strcmp(argv[0], "rcb") == 0)
		  	   cmd = rcb;
		  else if (strcmp(argv[0], "ticks") == 0)
		  	   cmd = ticks;
		  else if (strcmp(argv[0], "start") == 0)
		  	   cmd = start;
		  else if (strcmp(argv[0], "stop") == 0)
		  	   cmd = stop;
		  else if (strcmp(argv[0], "priority") == 0)
		  	   cmd = priority;
		  else if (strcmp(argv[0], "freemem") == 0)
		  	   cmd = freemem;
		  else if (strcmp(argv[0], "kdb") == 0)
			   cmd = kdb;
		  else if (strcmp(argv[0], "quit") == 0)
		  	   cmd = quit;
		  else if (strcmp(argv[0], "") == 0) 
		  	   cmd = 0;
		  else {
		  	   puts(error_msg[1]); 
			   putchar('\n');
			   cmd = 0;
		  	   }
		
		
		  // CLASSIFY/VALIDATE THE PARAMETERS and DISPATCH the command
		  if (cmd) {
		  switch (cmd) {
		   		 case help:
				 	  if (argc == 1) {
					  	 puts("---HELP---\n");
					  	 puts("<> -- required arguments");
					  	 puts("[] -- optional arguments\n");
					  	 puts("help [cmd] -- help on a specific command");
					  	 puts("tcb [task_id] -- prints task control block");
					  	 puts("rcb [[task_id] | [-b]] -- prints resource control block");
					 	 puts("ticks -- shows system tick");
					  	 puts("start <task_id> -- start a task");
					  	 puts("stop <task_id>  -- stop a task");
					 	 puts("priority <task_id>, <task_priority>  -- change prio");
						 puts("freemem -- get approximate free RAM space");
					 	 puts("kdb [1|0] -- turn kernel debug on/off");
						puts("quit -- quit the shell (carefull!)");
					 	 putchar('\n');
					  	 }
					  else if (argc == 2) 
					  	   shellcmd_help(argv[1]);
				  	  break;
				 case tcb:
				 	  if (argc == 1)
				  	  	 shellcmd_tcb(-1);
					  else if (argc == 2)
					  	 shellcmd_tcb(atoi(argv[1]));
					  else if (argc > 2)
					  	   puts(error_msg[1]);
				  	  break;
				 case rcb:
				 	  if (argc == 1)		  		 // print entire rcb
					  	 shellcmd_rcb(-1);
					  else if (argc == 2) {
					  	 if (!strcmp(argv[1], "-b")) {	 // print 'busy' only
						 	shellcmd_rcb(-2);
							}
						 else	
					  	 	shellcmd_rcb(atoi(argv[1]));	  // single
						 } 
					  else if (argc > 2)
				 	  	 puts(error_msg[1]);
				  	  break;
				 case ticks:
				 	  if (argc > 1)
					  	 puts(error_msg[1]);
					  else
				  	  	  shellcmd_ticks();
					  break;
				 case start:
				 	  if ((argc != 2) || 
					  	 (!isdigit(*argv[1])))
					  	 puts(error_msg[1]);
					  else
				  	  	shellcmd_startTask(atoi(argv[1]));
					  break;
				 case stop:
				 	  if ((argc != 2) || 
					  	 (!isdigit(*argv[1])))
					  	 puts(error_msg[1]);
					  else
				  	  	shellcmd_stopTask(atoi(argv[1]));
				 	  break;
				 case priority:
				 	  puts(error_msg[0]);
				 	  break;
				 case freemem:
				 	  shellcmd_freeMemCheck();
				 	  break;
				 case kdb:
					  if (argc < 2)	
						puts(error_msg[1]);
					  else 
					  	shellcmd_kdb(atoi(argv[1]));
					  break;
				 case quit:
				 	  shellcmd_quitShell();
					  return;
				 default:
				  	  break;
					  
		  		}}	  // end switch/if		
		  
		
		
		  // free the argc and argv array memory
		  for (i=0; i<argc; i++)
		  	  free(argv[i]);
		  free(argv);
		  
		  putchar('\n');
		  
	}  // end while(1)
	
	
	INTR_OFF();
	sem_give(COM1);
	
}	// end shell()





void shellcmd_help(char *argv1) {

	 puts(error_msg[0]);
}



void shellcmd_tcb(signed char tid) {
	
	 // Local Variables
	 unsigned char max, start;
	 
	 if (tid >= NUMTASKS) {
	 	puts(error_msg[2]);
		return;
		}
		
	 if (tid < 0) {
	 	start = 0;
		max = NUMTASKS;
		}	
	 else {
	 	start = tid;
	 	max = tid + 1;
		}
	 
	 puts("\nTask Control Block:");
	 for (tid=start; tid<max; tid++) {
	 
	 // don't print a big empty tcb
	 if (get_task_name(tid) == NULL)
	 	continue;
		
	 puts  ("---------------+--------+----------+-----------+------------+");
	 
	 INTR_OFF();
	 printf("Name: %8s | ID: %2d | State: %d | Prio: %3d | Msgs: 0x%2x |\n", 
			get_task_name(tid),
			tid,
	 		get_task_state(tid),
			get_task_priority(tid),
			get_task_messages(tid));
	 }		
	 INTR_ON();
	 
	 puts  ("---------------+--------+----------+-----------+------------+");
	 
	 puts("\nState: 0=idle, 1=pending, 2=running, 3=waiting, 4=stopped");
	 puts("Message: [ bit7 | bit6 | bit5 | bit4 | bit3 | bit2 | prio | state ]"); 
	 
}




void shellcmd_rcb(signed char option) {
	 
	 // Local Variables
	 unsigned char rid;
	 

	 
	 // print all	
	 if (option == -1) {
		for (rid=0; rid<NUMRESOURCES; rid++) {
			shellcmd_rcbPrint(rid);
			}
		}	
	 
	 // only print busy resources
	 else if (option == -2) {
	 	for (rid=0; rid<NUMRESOURCES; rid++) {
			if (get_resource_state(rid) == BUSY)
			   shellcmd_rcbPrint(rid); 
			}
		}
		
	 // print only one
	 else {
	 	  if (option >= NUMRESOURCES) {
	 	  	 puts(error_msg[6]);
			 return;
			 }
		  else  
	 	  	shellcmd_rcbPrint(option);

		}	

	 
	 puts  ("-----------+----------+------------+------------+");
	 
	 puts("\nState: 0=notbusy, 1=busy");
	 puts("Owner: 0..15=task ID, 255=nobody");

}



void shellcmd_rcbPrint(signed char rid) {

	 puts  ("-----------+----------+------------+------------+");
	 
	 INTR_OFF();
	 printf("RsrcID: %2d | State: %x | Owner: %3d | Waiting: %d |\n", 
	 		rid,
	 		get_resource_state(rid),
			get_resource_owner(rid),
			get_resource_queuelen(rid));
	INTR_ON();

}



void shellcmd_ticks(void) {
	 
	 INTR_OFF();
	 printf("ticks: %ld\n", system_tick);
	 INTR_ON();
}




void shellcmd_startTask(unsigned char id) {

	 if (set_task_state(id, PENDING) == 0)
	  	 printf("task %d started\n", id);
}




void shellcmd_stopTask(unsigned char id) {

	 if ((set_task_state(id, STOPPED)) == 0)
	  	 printf("task %d stopped\n", id);

}



void shellcmd_freeMemCheck(void) {

	 // LOCAL VARIABLES
	 int free;
	 
	 
	 free = get_free_memory();
	 INTR_OFF();
	 printf("approximate free heap memory: %d bytes\n", free);
	 INTR_ON();
	 
}



void shellcmd_kdb(int onoff) {


	kdb = onoff;

}




void shellcmd_quitShell(void) {

	 puts("exiting shell");
	 puts("\n");
	 shellcmd_stopTask(get_task_id());

}