////////////////////////////////////////////////////////////////
// Technomaint 2004 (c) SofTech di Germinara Francesco 2000,2004
//                      www.germinara.it info@germinara.it
// Story:
// 
////////////////////////////////////////////////////////////////
// Checked Version: 6/5/2004
////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "CFGSmsParser.h"

//Function Commands Supported See CFGSmsCmds.cpp
extern CString VI(CStringArray& cmdParams,CStringArray& cmdOptions); //Versione Prg
extern CString CM(CStringArray& cmdParams,CStringArray& cmdOptions); //Chiamata Intervento
//////////////////////////////////////////////

CFGSmsParser::CFGSmsParser(CString strToParser){
 CleanUp();

 //Set string to parser
 SetStrToParser(strToParser);

 //SETUP Recognized commands

 m_strArrayOfToken.Add("VI",eVI,VI); //VersionInformation
 m_strArrayOfToken.Add("CM",eCM,CM); //Invio Chiamata

 //SETUP Recognized commands option
 m_strArrayOfToken.Add("%",eOption,NULL); //Option delimiter
 
 m_strArrayOfToken.Add("-",eDelimiter,NULL);  //Delimiter Parameters
 m_strArrayOfToken.Add("//",eComment,NULL);  //Comments
 m_strArrayOfToken.Add("#",eStartCmd,NULL);   //Command Identifier
 m_strArrayOfToken.Add(":",eTimeSeparator,NULL);   //Time Separator
 m_strArrayOfToken.Add("\x0d",eEnd,NULL);//Command Line End
 m_strArrayOfToken.Add("\x0a",eEnd,NULL);//Command Line End
 m_strArrayOfToken.Add("\x09",eWhiteSpace,NULL);//TAB   WhiteSpace
 m_strArrayOfToken.Add("\x20",eWhiteSpace,NULL);//Space WhiteSpace

 m_nCommands=m_strArrayOfToken.GetSize(); //Get Size of Array elements

 m_pScheduleCmd=NULL;
}

CFGSmsParser::~CFGSmsParser(){
 m_strArrayOfToken.RemoveAll();
 if(m_pScheduleCmd!=NULL)
  delete m_pScheduleCmd;
}

void CFGSmsParser::SetStrToParser(CString strToParser){
 strToParser=strToParser.MakeUpper();
 cmdToExecute="";
 cmdParams.RemoveAll();
 cmdOptions.RemoveAll();
 m_strStringToParser=strToParser;
 strcpy(SMS,m_strStringToParser);
 ptrSMS=SMS;
}

void CFGSmsParser::CleanUp(){
 m_strStringToParser=_T("");
 m_strLastError=_T("");
 cmdToExecute=_T("");
 cmdParams.RemoveAll();
 cmdOptions.RemoveAll();
}

int CFGSmsParser::GetToken(){
 int tokenType=eEnd;

 while(*ptrSMS){
  if(IsEnd(tokenType)){return tokenType;};
  if(IsComment(tokenType)){return eEnd;}; //Skip the rest of the line
  if(IsWhiteSpace(tokenType)){
   ptrSMS++; 
   continue;
  }; //Skip white space

  if(IsDelimiter(tokenType) && !cmdToExecute.IsEmpty()){ //Command parametr 
   tokenType=GetParameter();
   continue;
  }; 

  if(IsOption(tokenType) && !cmdToExecute.IsEmpty()){ //Command option
   tokenType=GetOption();
   continue;
  }; 

  if(IsCommand(tokenType)){
   tokenType=GetCommand();
   if(tokenType==eError) return tokenType;
   return tokenType;
  }
  ptrSMS++;
 }

 return tokenType;
}
  
//Check Type Function
BOOL CFGSmsParser::IsWhiteSpace(int &tokenType){
 int sts=0;
 CString token;
 for(;;){
  sts=LookUp(eWhiteSpace,sts,token);
  if(sts==-1)
   break;
  if(token.GetLength()>0){
   if((*ptrSMS) == token.GetAt(0)){ 
    tokenType=eWhiteSpace;
    return TRUE;
   }
  }
 }
 return FALSE;
}

BOOL CFGSmsParser::IsEnd(int &tokenType){
 int sts=0;
 CString token;
 for(;;){
  sts=LookUp(eEnd,sts,token);
  if(sts==-1)
   break;
  if(token.GetLength()>0){
   if((*ptrSMS) == token.GetAt(0)){ 
    tokenType=eEnd;
    return TRUE;
   }
  }
 }
 return FALSE;
}

BOOL CFGSmsParser::IsDelimiter(int &tokenType){
 int sts=0;
 CString token;
 for(;;){
  sts=LookUp(eDelimiter,sts,token);
  if(sts==-1)
   break;
  if(token.GetLength()>0){
   if((*ptrSMS) == token.GetAt(0)){ 
    tokenType=eDelimiter;
    return TRUE;
   }
  }
 }
 return FALSE;
}


BOOL CFGSmsParser::IsComment(int &tokenType){
 int sts=0;
 CString token;
 for(;;){
  sts=LookUp(eComment,sts,token);
  if(sts==-1)
   break;
  if(token.GetLength()>0){
   if((*ptrSMS) == token.GetAt(0) && (*(ptrSMS+1)) == token.GetAt(1) && (*(ptrSMS-1)) == ' '){ 
    tokenType=eComment;
    return TRUE;
   }
  }
 }
 return FALSE;
}


BOOL CFGSmsParser::IsOption(int &tokenType){
 int sts=0;
 CString token;
 for(;;){
  sts=LookUp(eOption,sts,token);
  if(sts==-1)
   break;
  if(token.GetLength()>0){
   if((*ptrSMS) == token.GetAt(0)){ 
    tokenType=eOption;
    return TRUE;
   }
  }
 }
 return FALSE;
}

BOOL CFGSmsParser::IsCommand(int &tokenType){
 int sts=0;
 CString token;
 for(;;){
  sts=LookUp(eStartCmd,sts,token);
  if(sts==-1)
   break;
  if(token.GetLength()>0){
   if((*ptrSMS) == token.GetAt(0)){ 
    tokenType=eStartCmd;
    return TRUE;
   }
  }
 }
 return FALSE;
}


//Search for type of token, if not found return -1 else return nIndex and TOKEN value
int CFGSmsParser::LookUp(int type,int startFrom,CString& token){
 int nIndex=0;
 token=_T("");
 for(nIndex=startFrom; nIndex < m_nCommands; nIndex++){
  if(m_strArrayOfToken.GetSmsToken(nIndex)->m_eType ==type){
   token=m_strArrayOfToken.GetSmsToken(nIndex)->m_strToken;
   nIndex++;
   return nIndex;
  }
 }
 return -1; //Not found
}

int CFGSmsParser::LookUp(CString strIDcmd){
 int nIndex=0;
 for(nIndex=0; nIndex < m_nCommands; nIndex++){
  if(m_strArrayOfToken.GetSmsToken(nIndex)->m_strToken ==strIDcmd){
   return m_strArrayOfToken.GetSmsToken(nIndex)->m_eType;
  }
 }
 return eError; //Not found
}

int CFGSmsParser::GetCommand(){
 int type=eError;
 char fit[160];
 cmdToExecute="  "; 
 ptrSMS++; //Skip #
 if(*ptrSMS)cmdToExecute.SetAt(0,*ptrSMS); ptrSMS++;
 if(*ptrSMS)cmdToExecute.SetAt(1,*ptrSMS); ptrSMS++;

  //LookUp
 type=LookUp(cmdToExecute);

 if(cmdToExecute.GetLength()!=2 || type==eError){ //Error
  m_strLastError = "Command ["+cmdToExecute+"] not allowed!";
  cmdToExecute=_T("");
  return eError;
 }
 strcpy(fit,ptrSMS);
 strcpy(SMS,fit);
 ptrSMS=SMS;

 return type;
}


int CFGSmsParser::GetParameter(){
 CString parm;
 
 char fit[160];
 int tokenType;
 int pos=0;

 ptrSMS++; //Skip Delimiter

 pos=0;
 while(*ptrSMS){
  if(IsDelimiter(tokenType) || IsEnd(tokenType) || IsOption(tokenType) || IsComment(tokenType)) //IsWhiteSpace(tokenType) ||
   break;
  if(IsCommand(tokenType)){ //Schedule Command
   break;
  }
  fit[pos]=*ptrSMS;
  pos++;
  ptrSMS++;
 }
 fit[pos]='\0';

 parm = (const char *) fit;
 cmdParams.Add(parm);
 strcpy(fit,ptrSMS);
 strcpy(SMS,fit);
 ptrSMS=SMS;

 //Process another command
 if(tokenType==eStartCmd && m_pScheduleCmd==NULL){
  m_pScheduleCmd = new CFGSmsParser();
  m_pScheduleCmd->SetStrToParser(fit);
  m_pScheduleCmd->Parser(); //TRUE for debug
  strcpy(SMS,"");
  ptrSMS=SMS;
  delete m_pScheduleCmd;
  m_pScheduleCmd=NULL;
 }
 return eString;
}


int CFGSmsParser::GetOption(){
 CString option;
 
 char fit[160];
 int tokenType;
 int pos=0;

 ptrSMS++; //Skip Delimiter

 pos=0;
 while(*ptrSMS){
  if(IsWhiteSpace(tokenType) ||  IsDelimiter(tokenType) || IsEnd(tokenType) || IsOption(tokenType) || IsComment(tokenType))
   break;
  fit[pos]=*ptrSMS;
  pos++;
  ptrSMS++;
 }
 fit[pos]='\0';

 option = (const char *) fit;
 cmdOptions.Add(option);
 strcpy(fit,ptrSMS);
 strcpy(SMS,fit);
 ptrSMS=SMS;
 
 return(IsNumeric(option));
}

int CFGSmsParser::IsNumeric(CString str){
 int j=0;
 for(j=0; j< str.GetLength(); j++){
  if(str.GetAt(j)<'0' && str.GetAt(j)>'9'){
   return eString;
  }
 }
 return eNumeric;
}

CString CFGSmsParser::Parser(BOOL debugInfo){
 int rc=0,i=0;
 CString strResult(""),fit(""),stsResult("");
 for(;;){
  rc=GetToken();
  if(rc == eEnd){
   if(debugInfo){
    strResult=cmdToExecute;
    strResult+="\n";
    for(i=0; i< cmdParams.GetSize(); i++){
	 fit.Format("Parm n° [%d]",i+1);
     strResult+=fit+cmdParams.GetAt(i);
	 strResult+="\n";
    }
    for(i=0; i< cmdOptions.GetSize(); i++){
	 fit.Format("Options n° [%d] ",i+1);
     strResult+=fit+cmdOptions.GetAt(i);
	 strResult+="\n";
    }
    AfxMessageBox(strResult);
   }
   //Execute cmd with options and parameters request...
   if(!cmdToExecute.IsEmpty()){
    stsResult=(*(m_strArrayOfToken.GetSmsToken(cmdToExecute))->m_pFunct)(cmdParams,cmdOptions);
	if(!stsResult.IsEmpty())
	 AfxMessageBox(stsResult); //DEBUG ONLY ...
   }
   break;
  }
  if(rc == eError){
   stsResult  = GetLastError();;
   break;
  }
 }
 return stsResult;
}