/*

* Copyright (c) 2000 - 2001 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "nwx_defs.h"

#include "nw_hed_domhelper.h"

#include "nw_dom_element.h"

#include "nw_dom_domvisitor.h"

#include "nw_dom_text.h"

#include "nw_dom_document.h"

#include "nwx_string.h"

#include "nwx_url_utils.h"

#include "nwx_logger.h"

#include "TextReverse.h"

#include "nwx_settings.h"

#include <nwx_status.h>

#include "nwx_statuscodeconvert.h"

#include "nw_xhtml_xhtml_1_0_tokens.h"

#include "BrsrStatusCodes.h"

#include "wml_elm_attr.h"

/* ------------------------------------------------------------------------- *

   private constants

 * ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- *

   private static methods

 * ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

static

NW_Bool NW_HED_DomHelper_ContainsPlainTextVariablesAndEntities (const NW_HED_DomHelper_t* domHelper,

                                                                const NW_String_t* value, 

                                                                NW_Uint32 encoding)

{

  NW_Uint16 charCount;

  NW_Uint16 i;

  NW_Byte* buff;

  NW_Int32 skip;

  NW_ASSERT (domHelper != NULL);

  NW_ASSERT (value != NULL);

  charCount = NW_String_getCharCount ((NW_String_t*) value, encoding);

  buff = value->storage;

  for (i = 0; i < charCount; i++) {

    NW_Ucs2 ucs2Char;

    skip = NW_String_readChar (buff, &ucs2Char, encoding);

    /* found a variable */

    if ((domHelper->context != NULL) && (ucs2Char == WAE_ASCII_DOLLAR)) {

      return NW_TRUE;

    }

    /* Found entity begin. There is support for loose entity i.e. entity 

     * not ending with (;). So, if this entity begin symbol is found then

     * let NW_HED_DomHelper_GetText_Resolve(...) to decide about the text string.

     * */

    if ((domHelper->entitySet != NULL) && (ucs2Char == WAE_URL_AMP_CHAR)) 

    {

      return NW_TRUE;

    }

    buff += skip;

  }

  return NW_FALSE;

}

/* ------------------------------------------------------------------------- */

static

NW_Int32 IsValidDigit (const NW_Ucs2 ch, 

                       NW_Int32 base) 

{

  switch (base) {

    case 10: 

      return NW_Str_Isdigit (ch);

    case 16:

      return NW_Str_Isxdigit (ch);

    default:

      return 0;

  }

}

/* ------------------------------------------------------------------------- */

static

NW_Bool GetNumEntityChar (const NW_Ucs2* instring, 

                          NW_Ucs2 *retchar, 

                          NW_Int32 base) 

{

  NW_Int32 result = 0;

  NW_Int32 prevResult;

  NW_Uint32 currDigit = 0;

  if (*instring == 0) {

    return NW_FALSE;

  }

  while (*instring != 0) {

    if (!(IsValidDigit (*instring, base)))

      return NW_FALSE;

    if (NW_Str_Isdigit (*instring)) {

      currDigit = *instring - WAE_ASCII_0;

      instring++;

    } 

    else {

      currDigit = NW_Str_ToUpper (*instring) - WAE_ASCII_UPPER_A + 10;

      instring++;

    }

    prevResult = result;

    result = result * base + currDigit;

    if (result < prevResult) {

      return NW_FALSE;

    }

  }

  if (result > 0xffff || result < 0x0) 

    return NW_FALSE;

  /* TODO: validate the entity number */

  *retchar = (NW_Ucs2) result;

  return NW_TRUE;

}

// Full support for MS Windows extensions to Latin-1.

// Technically these extensions should only be activated for pages

// marked "windows-1252" or "cp1252", but

// in the standard Microsoft way, these extensions infect hundreds of thousands

// of web pages.  Note that people with non-latin-1 Microsoft extensions

// are SOL.

//

// See: http://www.microsoft.com/globaldev/reference/WinCP.asp

//      http://www.bbsinc.com/iso8859.html

//      http://www.obviously.com/

//

// There may be better equivalents

// We only need this for entities. For non-entity text, we handle this in the text encoding.

static const NW_Ucs2 wml_windowsLatin1Extension[32] = {

    0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, // 80-87

    0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F, // 88-8F

    0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, // 90-97

    0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178  // 98-9F

};

static NW_Ucs2 wml_fixUpChar(NW_Ucs2 c)

{

    if ((c & ~0x1F) != 0x0080)

        return c;

    return wml_windowsLatin1Extension[c - 0x80];

}

/* ------------------------------------------------------------------------- */

static 

TBrowserStatusCode ResolveEntity (const NW_HED_EntitySet_t* entitySet, 

                           NW_String_t* entityName, 

                           NW_Ucs2* entityChar)

{

  NW_Ucs2* rawEntity = NULL;

  NW_TRY (status) {

    const NW_Ucs2 EREF_HEXSIGN = 'x';

    /* get the raw entity */

    rawEntity = NW_Str_New (entityName->length);

    NW_THROW_OOM_ON_NULL (rawEntity, status);

    NW_Str_Strncpy (rawEntity, (NW_Ucs2*) entityName->storage, entityName->length);

    *(rawEntity + entityName->length)  = 0;

    /* check and validate for hex numeric char entity */

    if ((*(rawEntity) == WAE_URL_FRAG_CHAR) &&

        (*(rawEntity + 1) == EREF_HEXSIGN) &&

        (GetNumEntityChar(rawEntity + 2, entityChar, 16) != 0)) {

      NW_THROW_SUCCESS (status);

    }

    /* check and validate for dec numeric char entity */

    if((*rawEntity == WAE_URL_FRAG_CHAR) &&

       (GetNumEntityChar (rawEntity+1, entityChar, 10) != 0)) {

      NW_THROW_SUCCESS (status);

    }

    /* check if it is a named char entity */

    if ((*entityChar = NW_HED_EntitySet_GetEntityChar (entitySet, rawEntity)) != 0) { 

      NW_THROW_SUCCESS (status);

    }

  }

  NW_CATCH (status) { /* empty */ }

  NW_FINALLY {

    NW_Str_Delete (rawEntity);

    /* Map Windows Latin1 extensions to their Unicode equivalents */

    *entityChar = wml_fixUpChar(*entityChar);

    return status;

  } NW_END_TRY

}

/* ------------------------------------------------------------------------- */

static

NW_Ucs2* NW_HED_DomHelper_ResolveVariable (const NW_HED_Context_t* context,

                                           NW_Uint16 variableType,

                                           const NW_Ucs2* varName)

{

  NW_String_t vName;

  const NW_String_t* varValue;

  NW_Ucs2* vValue;

  /* get the value of the variable */

  if (StatusCodeConvert(NW_String_initialize (&vName, (void *) varName, HTTP_iso_10646_ucs_2)) != KBrsrSuccess) {

    return NULL;

  }

  varValue = NW_HED_Context_GetVariable(context, &vName);

  if (varValue == NULL) {

    return NULL;

  }

  switch (variableType) {

    /* escape the variable's value */

    case NW_WBXML_EXT_I_0:

    case NW_WBXML_EXT_T_0:

      vValue = NW_Str_New (NW_Url_EscapeStringLen ((NW_Ucs2 *) varValue->storage));

      if (vValue) {

        (void) NW_Url_EscapeString ((NW_Ucs2 *) varValue->storage, vValue);

      }

      break;

    /* unescape the variable's value */

    case NW_WBXML_EXT_I_1:

    case NW_WBXML_EXT_T_1:

      vValue = NW_Str_New (NW_Url_UnEscapeStringLen ((NW_Ucs2 *) varValue->storage));

      if (vValue) {

        (void) NW_Url_UnEscapeString ((NW_Ucs2 *) varValue->storage, vValue);

      }

      break;

    /* just copy the variable's value */

    default:

      NW_String_stringToUCS2Char (varValue, HTTP_iso_10646_ucs_2, &vValue);

      break;

  }

  return vValue;

}

/* ------------------------------------------------------------------------- */

static

NW_Bool

IsEndofVar (NW_Ucs2 varChar, 

            NW_Ucs2 endVar)

{

  if (NW_Str_Isalnum(varChar) || (varChar == WAE_ASCII_UNDERSCORE) ||

     ((varChar == WAE_ASCII_COLON) && (endVar == WAE_ASCII_RIGHT_BRACE))) {

    return NW_FALSE;

  }

  return NW_TRUE;

}

/* ------------------------------------------------------------------------- */

static

NW_Uint16

getVariableType (NW_Ucs2* conv)

{

  static const NW_Ucs2 DEPRECATED_CONV_NOESC[] = { 'n', 'o', 'e', 's', 'c', 0};

  static const NW_Ucs2 DEPRECATED_CONV_ESCAPE[] = { 'e', 's', 'c', 'a', 'p', 'e', 0};

  static const NW_Ucs2 DEPRECATED_CONV_UNESC[] = { 'u', 'n', 'e', 's', 'c', 0};

  NW_Ucs2 *pChar = conv;

  if(conv == NULL) {

    return 0;

  }

  if (NW_Str_Strnicmp (pChar, (NW_Ucs2 *) DEPRECATED_CONV_NOESC, 1) == 0) {

    if ((*(pChar + 1) != WAE_ASCII_NULL) &&

       (NW_Str_Strnicmp (pChar, (NW_Ucs2 *) DEPRECATED_CONV_NOESC, 5) != 0)) {

      return 0;

    }

    return NW_WBXML_EXT_I_2;

  }

  else if (NW_Str_Strnicmp (pChar, (NW_Ucs2 *) DEPRECATED_CONV_ESCAPE, 1) == 0)

  {

    if ((*(pChar + 1) != WAE_ASCII_NULL) &&

       (NW_Str_Strnicmp (pChar, (NW_Ucs2 *) DEPRECATED_CONV_ESCAPE, 6) != 0)) {

      return 0;

    }

    return NW_WBXML_EXT_I_0;

  }

  else if (NW_Str_Strnicmp (pChar, (NW_Ucs2 *) DEPRECATED_CONV_UNESC, 1) == 0)

  {

    if ((*(pChar + 1) != WAE_ASCII_NULL) &&

       (NW_Str_Strnicmp (pChar, (NW_Ucs2 *) DEPRECATED_CONV_UNESC, 5) != 0)) {

      return 0;

    }

    return NW_WBXML_EXT_I_1;

  }

  return 0;

}

/* ------------------------------------------------------------------------- */

static

TBrowserStatusCode getVarValue (const NW_HED_Context_t* context,

                         NW_Ucs2* varName, 

                         NW_Ucs2** varValue,

                         NW_Ucs2** varEnd,

                         NW_Uint16 variableType

                         )

{

  NW_Ucs2 varRefEnd = ' ';

  NW_Ucs2* nameStart; 

  NW_Ucs2* tmpName = NULL;

  NW_Uint32 nameLen;

  TBrowserStatusCode status = KBrsrSuccess;

  /* skip $ char */

  nameStart = ++varName;

  /* is $$ */

  if (*varName == WAE_ASCII_DOLLAR) {

    varName++; /* skip second dollar */

    NW_THROWIF_NULL (*varValue = NW_Str_New(1));

    NW_Str_Strncpy (*varValue, nameStart , 1);

    *(*varValue + 1)  = 0;

    *varEnd = varName;

    return status;

  }

  /* is "$(" Variable ")" type variable */

  if (*varName == WAE_ASCII_LEFT_BRACE) {

    varRefEnd = WAE_ASCII_RIGHT_BRACE;

    nameStart = ++varName; /* skip left brace */

    while (!IsEndofVar (*varName, varRefEnd)) {

      varName++;

    }

    if (*varName == WAE_ASCII_RIGHT_BRACE) {

      NW_Ucs2* convStart = NULL;

      NW_Ucs2 convChar = 0;

      NW_Uint16 varType = 0;

      nameLen = varName - nameStart;

      NW_THROWIF_NULL (tmpName = NW_Str_New (nameLen));

      NW_Str_Strncpy (tmpName, nameStart, nameLen);

      *(tmpName + nameLen)  = 0;

      varName++; /* skip ) char */

      /* Support for conv and deprecated-conv */

      convStart = NW_Str_Strchr (tmpName, WAE_ASCII_COLON);

      if(convStart) {

        convChar = *convStart;

        *convStart = 0;

        convStart++;

        varType = getVariableType (convStart);

        if(varType) {

          *varValue = NW_HED_DomHelper_ResolveVariable(context, varType, tmpName);

        }

        /* unexpected conv char, copy as is */

        else {

          nameLen = varName - nameStart + 2; /* To include the "$(" chars */

          NW_THROWIF_NULL (*varValue = NW_Str_New (nameLen));

          NW_Str_Strncpy (*varValue, (nameStart - 2), nameLen);

          *(*varValue + nameLen)  = 0;

        }

        convStart--;

        *convStart = convChar;

      }

      else {

          *varValue = NW_HED_DomHelper_ResolveVariable (context, variableType, tmpName);

      }

      NW_Str_Delete(tmpName);

      *varEnd = varName;

      return status;

    }

    /* Found "$(" but no corresponding ")", so copy as is */

    nameLen = varName - nameStart + 2; /* To include the "$(" chars */

    NW_THROWIF_NULL (*varValue = NW_Str_New (nameLen));

    NW_Str_Strncpy (*varValue, (nameStart - 2), nameLen);

    *(*varValue + nameLen)  = 0;

    *varEnd = varName;

    return status;

  }

  /* is "$" Variable " " type variable */

  if(NW_Str_Isalpha (*varName) || (*varName == WAE_ASCII_UNDERSCORE)) {

    while (!IsEndofVar (*varName, varRefEnd)) {

      varName++;

    }

    nameLen = varName - nameStart;

    NW_THROWIF_NULL (tmpName = NW_Str_New (nameLen));

    NW_Str_Strncpy (tmpName, nameStart, nameLen);

    *(tmpName + nameLen)  = 0;

    *varValue = NW_HED_DomHelper_ResolveVariable (context, NW_WBXML_EXT_I_2, tmpName);

    NW_Str_Delete (tmpName);

    *varEnd = varName;

    return status;

  }

  /* If we reach here that means its just a $, copy as is */

  NW_THROWIF_NULL (*varValue = NW_Str_New (1));

  NW_Str_Strncpy (*varValue, varName - 1 , 1);

  *(*varValue + 1) = 0;

  *varEnd = varName;

  return status;

NW_CATCH_ERROR

  return KBrsrOutOfMemory;

}

/* ------------------------------------------------------------------------- */

static 

TBrowserStatusCode NW_HED_DomHelper_ResolveVariables (const NW_HED_Context_t* context,

                                               const NW_Ucs2* origText,                                              

                                                      NW_String_t* destString,

                                                      NW_Uint16 variableType

                                                      )

{

  NW_Ucs2* sourceWalker = NULL;

  NW_Ucs2* varStart = NULL;

  NW_Ucs2* varEnd = NULL;

  NW_Ucs2* varValue = NULL;

  NW_Bool done = NW_FALSE;

  NW_String_t tmpString;

  TBrowserStatusCode status = KBrsrDomNoStringReturned;

  /* Initialising the dest to NULL */

  destString->length = 0;

  destString->storage = NULL;

  tmpString.length = 0;

  tmpString.storage = NULL;

  /* Initialise sourceWalker to origText */

  sourceWalker = (NW_Ucs2*) origText;

  /* Itarate through sourceWalker to substitute all variables */

  while (!done) {

    /* Find a variable */

    varStart = NW_Str_Strchr (sourceWalker, WAE_ASCII_DOLLAR);

    /* Resolve variable */

    if(varStart) {

        NW_THROWIF_ERROR (status = getVarValue (context, varStart, &varValue, &varEnd, variableType));

    }

    /* append rest to the dest string, if no more variables */

    if(varStart == NULL) {

      if(destString != NULL) {

        tmpString.length =  NW_Str_Strsize (sourceWalker);

        tmpString.storage = (NW_Byte*) sourceWalker;

        NW_THROWIF_ERROR (status = NW_HED_DomHelper_CatString (destString, &tmpString, HTTP_iso_10646_ucs_2));

      }

      done = NW_TRUE;

      NW_Str_Delete (varValue);

      continue;

    }

    /* append the text before variable and the variable Value to the destSting */

    if(varStart != sourceWalker) {

      tmpString.length =  (varStart - sourceWalker) * sizeof (NW_Ucs2);

      tmpString.storage = (NW_Byte*) sourceWalker;

      NW_THROWIF_ERROR (status = NW_HED_DomHelper_CatString (destString, &tmpString, HTTP_iso_10646_ucs_2));

    }

    if(varValue && NW_Str_Strlen(varValue)) {

      tmpString.length =  NW_Str_Strlen (varValue) * sizeof (NW_Ucs2);

      tmpString.storage = (NW_Byte*) varValue;

      NW_THROWIF_ERROR (status = NW_HED_DomHelper_CatString (destString, &tmpString, HTTP_iso_10646_ucs_2));

      NW_Str_Delete (varValue);

      varValue = NULL;

    }

    /* set the sourceWlaker to the next iteration */

    sourceWalker = varEnd;

  }

  return status;

NW_CATCH_ERROR

  NW_Str_Delete (varValue);

  NW_String_deleteStorage (destString);

  destString->length = 0;

  destString->storage = NULL;

  if (status != KBrsrOutOfMemory) {

    status = KBrsrDomNoStringReturned;

  }

  return status;

}