/**
 * Copyright(c) 2011 Trusted Logic.   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Trusted Logic nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

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

#if defined(_WIN32_WCE)
#include "os_wm.h"
#else
#include <errno.h>
#endif

#include "smc_properties_parser.h"
#include "lib_manifest2.h"
#include "s_error.h"

/* ---------------------------------------------------------------------------------
   Defines
   ---------------------------------------------------------------------------------*/

#define STRUE                             "true"
#define SFALSE                            "false"

#if defined(_WIN32_WCE)
#define GET_LAST_ERR GetLastError()
#else
#define GET_LAST_ERR  errno
#endif

#if defined (LINUX) || defined (__SYMBIAN32__) || defined (__ANDROID32__)
#define STRICMP strcasecmp
#elif defined(_WIN32_WCE)
#define STRICMP _stricmp
#else
#define STRICMP stricmp
#endif


/* ---------------------------------------------------------------------------------
   Logs and Traces.
   ---------------------------------------------------------------------------------*/
#ifdef __SYMBIAN32__
#include "os_symbian.h"
#elif NDEBUG
/* Compile-out the traces */
#define TRACE_ERROR(...)
#define TRACE_WARNING(...)
#define TRACE_INFO(...)
#else
#include <stdarg.h>
static void TRACE_ERROR(const char* format, ...)
{
   va_list ap;
   va_start(ap, format);
   fprintf(stderr, "TRACE: ERROR: ");
   vfprintf(stderr, format, ap);
   fprintf(stderr, "\n");
   va_end(ap);
}

static void TRACE_WARNING(const char* format, ...)
{
   va_list ap;
   va_start(ap, format);
   fprintf(stderr, "TRACE: WARNING: ");
   vfprintf(stderr, format, ap);
   fprintf(stderr, "\n");
   va_end(ap);
}

static void TRACE_INFO(const char* format, ...)
{
   va_list ap;
   va_start(ap, format);
   fprintf(stderr, "TRACE: ");
   vfprintf(stderr, format, ap);
   fprintf(stderr, "\n");
   va_end(ap);
}
#endif /* NDEBUG */

/* ---------------------------------------------------------------------------------
   private functions.
   ---------------------------------------------------------------------------------*/

static NODE* static_listFindNodeElement(NODE* pList,char* pName,bool bIsCaseSensitive)
{
   int32_t nCmp;

   assert(pName!=NULL);

   while (pList!=NULL)
   {
      if (bIsCaseSensitive)
      {
         nCmp=strcmp(pName,pList->pName);
      }
      else
      {
         nCmp=STRICMP(pName,pList->pName);
      }
      if (nCmp>0)
      {
         pList=pList->pRight;
      }
      else if (nCmp<0)
      {
         pList=pList->pLeft;
      }
      else
      {
         break;
      }
   }
   return pList;
}


static S_RESULT static_listSortedAddNode(NODE* pList,NODE* pNode)
{
   int32_t nCmp;

   do {
      nCmp=strcmp(pNode->pName,pList->pName);
      if (nCmp>0)
      {
         if (pList->pRight!=NULL)
         {
            pList=pList->pRight;
         }
         else
         {
            pList->pRight=pNode;
            /* update linked list */
            pNode->pPrevious=pList;
            pNode->pNext=pList->pNext;
            if (pList->pNext!=NULL)
            {
               pList->pNext->pPrevious=pNode;
            }
            pList->pNext=pNode;
            return S_SUCCESS;
         }
      }
      else if (nCmp<0)
      {
         if (pList->pLeft!=NULL)
         {
            pList=pList->pLeft;
         }
         else
         {
            pList->pLeft=pNode;
            /* update linked list */
            pNode->pNext=pList;
            pNode->pPrevious=pList->pPrevious;
            if (pList->pPrevious!=NULL)
            {
               pList->pPrevious->pNext=pNode;
            }
            pList->pPrevious=pNode;
            return S_SUCCESS;
         }
      }
   } while (nCmp!=0);

   TRACE_ERROR("%s already exist !\n",pNode->pName);
   return S_ERROR_ITEM_EXISTS;
}


static S_RESULT SMCPropListSortedAdd(LIST* pList,NODE* pNode)
{
   S_RESULT nResult;

   assert(pList!=NULL && pNode!=NULL);

   if (pNode->pName==NULL)
   {
	   TRACE_ERROR("Trying to insert a NULL node name !\n");
      return S_ERROR_BAD_PARAMETERS;
   }

   if (pList->pRoot==NULL)
   {
      pList->pRoot=pNode;
      pList->pFirst=pNode;
      return S_SUCCESS;
   }
   else
   {
      nResult=static_listSortedAddNode(pList->pRoot,pNode);
      /* update the first node of the linked list */
      if (nResult==S_SUCCESS && pNode->pPrevious==NULL)
      {
         pList->pFirst=pNode;
      }
   }
   return nResult;
}


static NODE* SMCPropListFindElement(LIST* pList,char* pName,bool bIsCaseSensitive)
{
   if (pList->pRoot!=NULL)
   {
      return static_listFindNodeElement(pList->pRoot,pName,bIsCaseSensitive);
   }
   return NULL;
}


static S_RESULT SMCPropYacc(uint8_t* pBuffer, uint32_t nBufferLength,
                     CONF_FILE* pConfFile)
{
   S_RESULT nError=S_SUCCESS;
   LIST *pPublicPropertyList=NULL;
   LIST *pPrivatePropertyList=NULL;
   PROPERTY* pProperty=NULL;
   SERVICE_SECTION* pServSection;
   SERVICE_SECTION* pPreviousService=NULL;

   uint8_t* pName;
   uint32_t nNameLength;
   uint8_t* pValue;
   uint32_t nValueLength;
   char* pNameZ = NULL;
   char* pValueZ = NULL;
   LIB_MANIFEST2_CONTEXT sParserContext;
   char serviceManifestName[1024];

   sParserContext.pManifestName = "Configuration File";
   sParserContext.pManifestContent = pBuffer;
   sParserContext.nManifestLength = nBufferLength;
   sParserContext.nType = LIB_MANIFEST2_TYPE_SOURCE_WITH_SECTIONS;

   libManifest2InitContext(&sParserContext);

   while (true)
   {
      nError = libManifest2GetNextItem(
         &sParserContext,
         &pName,
         &nNameLength,
         &pValue,
         &nValueLength);
      if (nError == S_ERROR_ITEM_NOT_FOUND)
      {
         /* End of parsing */
         nError = S_SUCCESS;
         break;
      }
      else if (nError != S_SUCCESS)
      {
         /* Error */
         goto error;
      }

      /* Duplicate name and value in as zero-terminated strings */
      /* Unclean: those strings are not going to be deallocated
         This is not a problem because this code is run in a tool
      */
      pNameZ = malloc(nNameLength+1);
      if (pNameZ == NULL)
      {
         nError = S_ERROR_OUT_OF_MEMORY;
         goto error;
      }
      memcpy(pNameZ, pName, nNameLength);
      pNameZ[nNameLength] = 0;

      if (pValue == NULL)
      {
         /* It's a section */
         if (STRICMP(pNameZ, SYSTEM_SECTION_NAME) == 0)
         {
            free(pNameZ);
            pPublicPropertyList=&pConfFile->sSystemSectionPropertyList;
         }
         else
         {
            pServSection=(SERVICE_SECTION*)SMCPropListFindElement(
               &pConfFile->sDriverSectionList,
               pNameZ,
               false);
            if (pServSection==NULL)
            {
               pServSection=(SERVICE_SECTION*)SMCPropListFindElement(
                     &pConfFile->sPreinstalledSectionList,
                     pNameZ,
                     false);
            }
            if (pServSection==NULL)
            {
               pServSection=(SERVICE_SECTION*)SMCPropListFindElement(
                  &pConfFile->sSectionList,
                  pNameZ,
                  false);
               if (pServSection==NULL)
               {
                  nError=S_ERROR_ITEM_NOT_FOUND;
                  goto error;
               }
            }
            free(pNameZ);

            pServSection->inSCF=true;
            if (pPreviousService!=NULL)
            {
               pPreviousService->pNextInSCF=pServSection;
            }
            else
            {
               pConfFile->pFirstSectionInSCF=pServSection;
            }
            pPreviousService=pServSection;

            pPublicPropertyList=&pServSection->sPublicPropertyList;
            pPrivatePropertyList=&pServSection->sPrivatePropertyList;
         }
      }
      else
      {
         /* It's a property definition */
         pValueZ = malloc(nValueLength+1);
         if (pValueZ == NULL)
         {
            nError = S_ERROR_OUT_OF_MEMORY;
            goto error;
         }
         memcpy(pValueZ, pValue, nValueLength);
         pValueZ[nValueLength] = 0;

         pProperty=(PROPERTY*)malloc(sizeof(PROPERTY));
         if (pProperty==NULL)
         {
            nError=S_ERROR_OUT_OF_MEMORY;
            goto error;
         }
         memset(pProperty, 0x00, sizeof(PROPERTY));
         pProperty->sNode.pName=pNameZ;

         pProperty->pValue=pValueZ;

         if (pPrivatePropertyList==NULL)
         {
            nError=SMCPropListSortedAdd(pPublicPropertyList,(NODE*)pProperty);
            if (nError!=S_SUCCESS)
            {
               goto error;
            }
         }
         else
         {
            if ((nValueLength > strlen(CONFIG_PROPERTY_NAME)) &&
                (memcmp(pProperty->sNode.pName, CONFIG_PROPERTY_NAME, strlen(CONFIG_PROPERTY_NAME)) == 0))
            {
               nError=SMCPropListSortedAdd(pPrivatePropertyList,(NODE*)pProperty);
            }
            else
            {
               nError=SMCPropListSortedAdd(pPublicPropertyList,(NODE*)pProperty);
            }
            if (nError!=S_SUCCESS)
            {
               goto error;
            }
         }
      }
   }

error:
   if (nError!=S_SUCCESS)
   {
      switch (nError)
      {
      case S_ERROR_BAD_FORMAT:
         /* Error message already output */
         break;
      case S_ERROR_WRONG_SIGNATURE:
         TRACE_ERROR("Configuration file: wrong service UUID: %s\n", pValueZ);
         break;
      case S_ERROR_OUT_OF_MEMORY:
	  TRACE_ERROR("Out of memory\n");
         break;
      case S_ERROR_ITEM_NOT_FOUND:
	  TRACE_ERROR("Configuration file: service \"%s\" not found\n", pNameZ);
         break;
      }
   }
   return nError;
}


S_RESULT static_readFile(const char* pFilename, void** ppFile, uint32_t* pnFileLength)
{
   S_RESULT nResult = S_SUCCESS;
   long nFilesize;
   FILE* pFile = NULL;
   void *pBuff = NULL;

   // open file and get its size...
   if ((pFile = fopen(pFilename, "rb")) == NULL)
   {
      TRACE_ERROR("static_readFile: fopen(%s) failed [%d]", pFilename, GET_LAST_ERR);
	   nResult = S_ERROR_ITEM_NOT_FOUND;
	   return nResult;
   }
   if (fseek(pFile, 0, SEEK_END) != 0)
   {
      TRACE_ERROR("static_readFile: fseek(%s) failed [%d]", pFilename, GET_LAST_ERR);
	   nResult = S_ERROR_UNDERLYING_OS;
	   goto error;
   }
   nFilesize = ftell(pFile);
   if (nFilesize < 0)
   {
      TRACE_ERROR("static_readFile: ftell(%s) failed [%d]", pFilename, GET_LAST_ERR);
	   nResult = S_ERROR_UNDERLYING_OS;
	   goto error;
   }
   rewind(pFile);

   // allocate the buffer
   pBuff = malloc(nFilesize + 1);
   if (pBuff == NULL)
   {
      TRACE_ERROR("static_readFile: out of memory");
      nResult = S_ERROR_OUT_OF_MEMORY;
      goto error;
   }

   // read the file
   if (fread(pBuff, sizeof(uint8_t), (size_t)nFilesize, pFile) != (size_t)nFilesize)
   {
      TRACE_ERROR("static_readFile: fread failed [%d]", GET_LAST_ERR);
      nResult = S_ERROR_UNDERLYING_OS;
      goto error;
   }
   ((char*)pBuff)[nFilesize] = 0;

   *ppFile = pBuff;
   *pnFileLength = nFilesize;
   return S_SUCCESS;

error:
   if (pBuff != NULL)
      free(pBuff);
   fclose(pFile);

   *ppFile = NULL;
   *pnFileLength = 0;
   return nResult;
}


/* ---------------------------------------------------------------------------------
   API functions.
   ---------------------------------------------------------------------------------*/

char* SMCPropGetSystemProperty(CONF_FILE* pConfFile, char* pPropertyName)
{
   PROPERTY* pProperty;

   pProperty=(PROPERTY*)SMCPropListFindElement(
      &pConfFile->sSystemSectionPropertyList,
      pPropertyName,
      true);
   if (pProperty!=NULL)
   {
      return pProperty->pValue;
   }
   return NULL;
}

uint32_t SMCPropGetSystemPropertyAsInt(CONF_FILE* pConfFile, char* pPropertyName)
{
   uint32_t nValue;
   char* pValue=SMCPropGetSystemProperty(pConfFile,pPropertyName);

   if (libString2GetStringAsInt(pValue, &nValue) == S_SUCCESS)
   {
      return nValue;
   }
   return 0;
}


S_RESULT SMCPropParseConfigFile(char* pConfigFilename,CONF_FILE* pConfFile)
{
   S_RESULT nError=S_SUCCESS;
   void* pFile;
   uint32_t nFileLength;
   bool bReuseManifest;

   assert(pConfFile!=NULL);

   TRACE_INFO("Processing configuration file '%s'", pConfigFilename);

   if(pConfigFilename != NULL)
   {
      nError=static_readFile(pConfigFilename,&pFile,&nFileLength);
      if (nError!=S_SUCCESS)
      {
         goto error;
      }
      bReuseManifest = true;
   }
   else
   {
      assert(0);
   }

   nError=SMCPropYacc(pFile,nFileLength,pConfFile);

   if(pConfigFilename != NULL)
   {
      free(pFile);
   }

error:
   return nError;
}