/*******************************************************************************
   Function: HelpMenu
         In:
        Out:
     Return:
Description:
*******************************************************************************/
void HelpMenu(int iSockID)
{
  iSendToClient(iSockID,"*** HELP MENU ***\n");
  iSendToClient(iSockID,"[getdate <ddmmyy>] meaning: /n return type, valstr and valnum for line with max (hh:mm:ss) for date <ddmmyy>\n");
  iSendToClient(iSockID,"[count] meaning: /n return number of record for every different type in table test_marin\n");
}
/*******************************************************************************
   Function: iGetDate
         In:
        Out:
     Return:
Description:
*******************************************************************************/
int getDate(int iSockID, char *pstrDate)
{
  EXEC SQL BEGIN DECLARE SECTION;
  SQL20 qstrValdateOut,qstrValdateIn;
  EXEC SQL END DECLARE SECTION;

  memcpy(qstrValdateIn,pstrDate,(strlen(pstrDate)+1));

  EXEC SQL WHENEVER SQLERROR DO return (sqlError (ERR_SQL_ERROR, "sql error: [getDate] select\n"));
  EXEC SQL WHENEVER NOT FOUND DO return (sqlError (ERR_NOT_FOUND, "not found error: [getDate] select.\n"));

  EXEC SQL SELECT TO_CHAR (MAX(valdat)) AS qstrValdateOut
             FROM test_edu
            WHERE valdat = qstrValdateIn;

  memcpy(pstrDate,qstrValdateOut,(strlen(qstrValdateOut)+1));
  iSendToClient(iSockID, pstrDate);
}
/*******************************************************************************
   Function: iCount
         In:
        Out:
     Return:
Description:
*******************************************************************************/
int iCount(int iSockID)
{
  EXEC SQL BEGIN DECLARE SECTION;
  SQL20 qstrCount;
  EXEC SQL END DECLARE SECTION;

  char *pstrBuf;

  EXEC SQL WHENEVER SQLERROR DO return (sqlError (ERR_SQL_ERROR, "sql error: [iCount] declare countCursor\n"));
  EXEC SQL WHENEVER NOT FOUND DO return (sqlError (ERR_NOT_FOUND, "not found error: [iCount] declare countCursor.\n"));

  EXEC SQL DECLARE countCursor CURSOR FOR
                                   SELECT type,
                                          COUNT(*)
                                     FROM test_marin
                                 GROUP BY type
                                 ORDER BY type;

  EXEC SQL WHENEVER SQLERROR DO return (sqlError (ERR_SQL_ERROR, "sql error: [iCount] open countCursor\n"));
  EXEC SQL WHENEVER NOT FOUND DO return (sqlError (ERR_NOT_FOUND, "not found error: [iCount] open countCursor.\n"));

  EXEC SQL OPEN countCursor;

  for (;;)
  {
    EXEC SQL WHENEVER SQLERROR DO return (sqlError (ERR_SQL_ERROR, "sql error: [iCount] fetch cursor.\n"));
    EXEC SQL WHENEVER NOT FOUND DO break;

    EXEC SQL FETCH countCursor
              INTO qstrCount;

  memcpy(pstrBuf,qstrCount,strlen(qstrCount));

  iSendToClient(iSockID,pstrBuf);
  }

  EXEC SQL WHENEVER SQLERROR DO return (sqlError (ERR_SQL_ERROR, "sql error: [iCount] close countCursor\n"));
  EXEC SQL WHENEVER NOT FOUND DO return (sqlError (ERR_NOT_FOUND, "not found error: [iCount] close countCursor.\n"));

  EXEC SQL CLOSE countCursor;

  return 0;
}
/*******************************************************************************
   Function: iSendToClient
         In:
        Out:
     Return: 0 on succes
             1 on fail
Description: send data
*******************************************************************************/
int iSendToClient(int iSockID, char *pstrBuffer)
{
  if ((send (iSockID, pstrBuffer, strlen (pstrBuffer) ,0)) == -1)
  {
    logs("error: [iSendToClient] send fail.\n");
    return 1;
  }
  logs("succes: [iSendToClient] send done.\n");
  return 0;
}
/*******************************************************************************
   Function: iCheckInputSocket
         In:
        Out:
     Return:
Description: checks arguments
*******************************************************************************/
int iCheckInputSocket(char *pstrBuffer, char *pstrDate)
{
  int iFlag;
  char strFirstArg[MAX_SOCKET_BUF_SIZE], strSecondArg[MAX_SOCKET_BUF_SIZE], strThirdArg[MAX_SOCKET_BUF_SIZE];

  iFlag = sscanf(pstrBuffer,"%s %s %s",strFirstArg,strSecondArg,strThirdArg);
  logs("debug: [iCheckInput]iRes from sscanf: %d\n", iRes);

  if(iFlag == 3)
  {
    logs("[iCheckInputSocket] more than two arguments.\n");
    return ERR_SOCKET_ARGUMENTS_NUM;
  }

  if (iFlag == 2)
  {
    if (!(strcmp(strFirstArg,"getdate")))
    {
      if (iCheckDate(strSecondArg,"ddmmyyyy")==1)
      {
      	logs("[iCheckInput]Client choose: getdate <ddmmyyyy>.\n");
        memcpy(pstrDate,strSecondArg,strlen(strSecondArg));
        return SOCKET_INPUT_GETDATE;
      }
    }
  }

  if (iFlag==1)
  {
    if (!(strcmp(pstrBuffer,"quit")))
    {
      logs("[iCheckInput]Client choose: quit.\n");
      return SOCKET_INPUT_QUIT;
    }

    if (!(strcmp(pstrBuffer,"exit")))
    {
      logs("[iCheckInput]Client choose: exit.\n");
      return SOCKET_INPUT_EXIT;
    }

    if (!(strcmp(pstrBuffer,"count")))
    {
      logs("[iCheckInput]Client choose: count.\n");
      return SOCKET_INPUT_COUNT;
    }

    if (!(strcmp(pstrBuffer,"help")))
    {
      logs("[iCheckInput]Client choose: help.\n");
      return SOCKET_INPUT_HELP;
    }
  }

  logs("[iCheckInput]Client write wrong argument.\n");
  return ERR_SOCKET_ARGUMENTS;
}
/*******************************************************************************
   Function: iReceive
         In:
        Out:
     Return: 0 on succes
             1 on fail
Description: receive data
*******************************************************************************/
int iReceive(int iSockID, char *pstrBuffer)
{
  if ((recv (iSockID, pstrBuffer, strlen (pstrBuffer) ,0)) == -1 )
  {
    logs ("error: [iReceive] receive fail.\n");
    return 1;
  }
  logs("succes: [iReceive] receive done.\n");
  return 0;
}
/*******************************************************************************
   Function: iProcess
         In:
        Out:
     Return:
Description:
*******************************************************************************/
int iProcess(int iSockID)
{
  int iRes;
  char strBuffer[MAX_SOCKET_BUF_SIZE], strDate[MAX_SOCKET_BUF_SIZE];

  //INFINITE LOOP FOR CHAT

    logs("[iProcess] prints menu to client.\n");

    //PRINTS MENU TO CLIENT
    iSendToClient(iSockID,"--> MENU **************************************\n");
    iSendToClient(iSockID,"--> Enter command *****************************\n");
    iSendToClient(iSockID,"--> getdate <ddmmyy> **************************\n");
    iSendToClient(iSockID,"--> count *************************************\n");
    iSendToClient(iSockID,"--> Help: for more info about the commands ****\n");
    iSendToClient(iSockID,"--> Exit: exit chat ***************************\n");
    iSendToClient(iSockID,"--> Quit: exit sever **************************\n");

    bzero(strBuffer, MAX_SOCKET_BUF_SIZE);

    iReceive(iSockID,strBuffer);
    logs("debug: received data: %s\n", strBuffer);

    logs("[iProcess] send for check.\n");

    iRes = iCheckInputSocket(strBuffer, strDate);

    logs("[iProcess] check result: %d\n",iRes);

    if (iRes == ERR_SOCKET_ARGUMENTS_NUM)
    {
      logs("error: [iReceive] wrong number of arguments.\n");
      iSendToClient(iSockID,"--> More than two arguments input.\n");
    }

    if (iRes == ERR_SOCKET_ARGUMENTS)
    {
      logs("error: [iProcess] wrong arguments.\n");
      iSendToClient(iSockID,"--> Wrong arguments input.\n");
    }

    if (iRes == SOCKET_INPUT_QUIT)
    {
      logs("succes: [iReceive] server quit code.\n");
      iSendToClient(iSockID,"--> Closing server..\n");
      return SOCKET_INPUT_QUIT;
    }
    if (iRes == SOCKET_INPUT_EXIT)
    {
      logs("succes: [iReceive] chat exit code.\n");
      iSendToClient(iSockID,"--> End of chat.\n");
      //break;
    }
    if (iRes == SOCKET_INPUT_HELP)
    {
      logs("succes: [iReceive] help code.\n");
      iSendToClient(iSockID,"--> Help menu loading.\n");
      HelpMenu(iSockID);
    }
    if (iRes == SOCKET_INPUT_COUNT)
    {
      logs("succes: [iReceive] count type code.\n");
      iSendToClient(iSockID,"--> Sending to count function.\n");
      iCount(iSockID);
    }
    if (iRes == SOCKET_INPUT_GETDATE)
    {
      logs("succes: [iReceive] getdate code.\n");
      iSendToClient(iSockID,"--> Sending to getdate function.\n");
      getDate(iSockID,strBuffer);
    }
  return 0;
}
/*******************************************************************************
   Function: iServer
         In:
        Out:
     Return: 0 on succes
             1 on fail
Description:
********************************************************************************/
int iServer(char *pstrValue)
{
  int iSockId, iConnId, iLen, iPort, iPro;
  struct sockaddr_in servAddr, cliAdr;

  if(!(iPort = atoi(pstrValue)))
  {
    logs("error: [iServer] wrong input port.\n");
    return 1;
  }

  // socket create and verification
  iSockId = socket(AF_INET, SOCK_STREAM, 0);
  if (iSockId == -1)
  {
    logs("error: [iServer] socket not created.\n");
    return 1;
  }
  logs("succes: [iServer] socket created.\n");

  bzero(&servAddr, sizeof(servAddr));

  // assign IP, PORT
  servAddr.sin_family = AF_INET;
  servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servAddr.sin_port = htons(iPort);

  // Binding newly created socket to given IP and verification
  if ((bind(iSockId, (struct sockaddr*)&servAddr, sizeof(servAddr))) != 0)
  {
    logs("error: [iServer] socked bind fail.\n");
    return 1;
  }
  logs("succes: [iServer] socked bind.\n");

  // Now server is ready to listen and verification
  if ((listen(iSockId, 1)) != 0)
  {
    logs("error: [iServer] Listen failed.\n");
    return 1;
  }
  logs("succes: [iServer] Server listening.\n");

    iLen = sizeof(cliAdr);

    // Accept the data packet from client and verification
    iConnId = accept(iSockId, (struct sockaddr*)&cliAdr, &iLen);
    if (iConnId < 0)
    {
      logs("error: [iServer] server acccept failed.\n");
      return 1;
    }
    logs("succes: [iServer] server acccept the client socket: %d, port: %d.\n",iConnId,iPort);

    iPro = iProcess(iConnId);

    // Function for chatting between client and server
    if (iPro == SOCKET_INPUT_QUIT)
    {
      logs("Server quit.\n");
     // break;
    }

  // Close the socket
  if (!(close(iSockId)))
  {
    logs("error: [iServer] socket close fail.\n");
    return 1;
  }

  logs("succes: [iServer] socket closed.\n");
  return 0;
}