/*
  parse.c

  Handles input commands from clients, by splitting strings into tokens
  and passing arguments to the appropriate handler.

  It works much like a command line.  Only the first token is used to
  determine what function to call.
  
 */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "../shared/LL.h"
#include "../shared/sockets.h"
#include "../shared/debug.h"
#include "clients.h"
#include "client_functions.h"
#include "parse.h"



int parse_all_client_messages()
{
   int i, j;
   int newtoken, inquote;
   client *c;
   char *str;
//   char *tok;
   int argc;
   char *argv[256];
   char delimiters[] = " \0";
   char leftquote[]  = "\0\"'`([{\0";
   char rightquote[] = "\0\"'`)]}\0";
   char errmsg[256];
   int invalid=0;
   
   //debug("parse: Rewinding list...\n");
   LL_Rewind(clients);
   do {
      // Get the next client...
      //debug("parse: Getting client...\n");
      c = LL_Get(clients);
      if(c)
      {
	 // And parse all its messages...
	 //debug("parse: Getting messages...\n");
	 for(str = client_get_message(c); str; str = client_get_message(c))
	 {
	    debug("parse: ...%s\n", str);
	    // Now, split up the string...
	    //len = strlen(str);
	    argc=0;
	    newtoken=1;
	    inquote=0;
	    for(i=0; str[i]; i++)
	    {
	       if(inquote)  // Scan for the end of the quote
	       {
		  if(str[i] == rightquote[inquote])
		  {  // Found the end of the quote
		     inquote=0;
		     str[i] = 0;
		     newtoken=1;
		  }
	       }
	       else // Normal operation; split at delimiters
	       {
		  for(j=1; leftquote[j]; j++)
		  {
		     // Found the beginning of a new quote...
		     if(str[i] == leftquote[j])
		     {
			inquote = j;
			str[i] = 0;
			continue;
		     }
		  }
		  for(j=0; delimiters[j]; j++)
		  {
		     // Break into a new string...
		     if(str[i] == delimiters[j])
		     {
			str[i] = 0;
			newtoken = 1;
			continue;
		     }
		  }
	       }
	       if(newtoken && str[i])
	       {
		  newtoken=0;
		  argv[argc] = str + i;
		  argc++;
	       }
	       else
	       {
	       }
	    }
	    if(inquote)
	    {
	       sprintf(errmsg, "huh? Unterminated string: missing %c\n",
		       rightquote[inquote]);
	       sock_send_string(c->sock, errmsg);
	       continue;
	    }
/*
	    for(tok = strtok(str, delimiters);
		tok;
		tok=strtok(NULL, delimiters))
	    {
	       argv[argc] = tok;
	       argc++;
	    }
*/
	    argv[argc] = NULL;
	    if(argc < 1) continue;
	 
	    // Now find and call the appropriate function...
//	    debug("parse: Finding function...\n");
	    invalid = 1;
	    for(i=0; commands[i].keyword; i++)
	    {
//	       debug("(checking %s)\n", commands[i].keyword);
	       if(0 == strcmp(argv[0], commands[i].keyword))
	       {
//	          debug("(FOUND %s)\n", commands[i].keyword);
		  invalid = commands[i].function(c, argc, argv);
//	          debug("parse: Returned %i...\n", err);
	       }
	    }
	    if(invalid)
	    {
	       // FIXME:  Check for buffer overflows here...
	       sprintf(errmsg, "huh? Invalid command \"%s\"\n", argv[0]);
	       sock_send_string(c->sock, errmsg);
	    }

	    free(str);  // fixed memory leak?
	 } // end for(str...)
      } // end if (c)
   } while (LL_Next(clients) == 0);

   return 0;
}