/*

* Copyright (c) 2000 - 2003 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 <stddef.h>

#include <nwx_assert.h>

#include <nwx_string.h>

#include <nwx_logger.h>

#include "BrsrStatusCodes.h"

#include "CSSDeclListHandle.h"

#include "CSSHandler.h"

#include "CSSRuleList.h"

#include "CSSImageList.h"

#include "LMgrBoxTreeListener.h"

#include "TKeyArrayPtr.h"

#include "urlloader_urlresponse.h"

#include "nw_css_processori.h"

#include "HEDDocumentListener.h"

#include "nw_hed_contenthandler.h"

#include "nw_hed_documentroot.h"

#include "nw_hed_iloadrecipienti.h"

#include "nw_hed_loader.h"

#include "nw_adt_resizablevector.h"

#include "nw_text_ucs2.h"

#include "nw_gdi_utils.h"

#include "nw_lmgr_rootbox.h"

#include "nw_lmgr_simplepropertylist.h"

#include "nw_lmgr_bidiflowbox.h"

#include "nw_lmgr_containerbox.h"

#include "nw_lmgr_marqueebox.h"

#include "nw_lmgr_imgcontainerbox.h"

#include "nw_lmgr_statictablecellbox.h"

#include "nwx_settings.h"

#include "nwx_http_defs.h"

#include "GDIDeviceContext.h"

#include "nw_xhtml_xhtmlcontenthandler.h"

#include "MVCShell.h"

//#include "BrCtl.h"

struct TLoadListEntry

{

  NW_Uint16 iTransactionId;

  NW_Uint8      iLoadType;

  NW_Buffer_t*  iPartialChunkBuffer; // owns

};

typedef CArrayPtrFlat<TLoadListEntry> CCSSLoadList;

/*

**-------------------------------------------------------------------------

**  Internal Functions

**-------------------------------------------------------------------------

*/

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

static NW_LMgr_Box_t*

NW_CSS_Processor_BoxLookupByNode( NW_CSS_Processor_t* thisObj, NW_DOM_ElementNode_t* imageNode )

  {

  //lint -esym(550, status) Symbol not accessed

  NW_ASSERT( thisObj != NULL );

  NW_ASSERT( imageNode != NULL );

  NW_LMgr_Box_t* imageBox = NULL;

  NW_TRY( status )

    {

    NW_LMgr_Box_t* box = NULL;

    NW_LMgr_BoxVisitor_t boxVisitor;

    NW_HED_DocumentRoot_t* documentRoot =

      (NW_HED_DocumentRoot_t*) NW_HED_DocumentNode_GetRootNode( thisObj->owner );

    NW_THROW_ON_NULL( documentRoot, status, KBrsrFailure );

    NW_LMgr_RootBox_t* rootBox = NW_HED_DocumentRoot_GetRootBox( documentRoot );

    NW_THROW_ON_NULL( rootBox, status, KBrsrFailure );

    // create a box visitor to travel through the tree

    if( NW_LMgr_BoxVisitor_Initialize( &boxVisitor, NW_LMgr_BoxOf( rootBox ) ) == KBrsrSuccess )

      {

      while( ( box = NW_LMgr_BoxVisitor_NextBox( &boxVisitor, 0 ) )  != NULL )

        {

        NW_LMgr_PropertyList_t* boxPropList;

        boxPropList = NW_LMgr_Box_PropListGet( box );

        // It must be simple property

        if( boxPropList && NW_Object_IsInstanceOf( boxPropList, &NW_LMgr_SimplePropertyList_Class ) == NW_TRUE )

          {

          // check if this is the node that we are looking for

          if( (NW_DOM_ElementNode_t*)NW_LMgr_SimplePropertyListOf( boxPropList )->domNode == imageNode )

            {

            // return

            imageBox = box;

            break;

            }

          }

        }

      }

    }

  NW_CATCH( status )

    {

    imageBox = NULL;

    }

  NW_FINALLY

    {

    return imageBox;

    }

  NW_END_TRY

  }

static TBrowserStatusCode

NW_CSS_Processor_HandleCSSFetchDisabled( NW_CSS_Processor_t* thisObj,

                                         NW_Text_t* url,

                                         NW_Bool isSavedDeck,

                                         NW_Bool isHistLoad,

										 NW_Bool isReLoad,

                                         TInt cssBufferIndex)

{

  NW_CSS_Processor_PendingLoad_t* pendingLoad = NULL;

  NW_ASSERT (thisObj != NULL);

  NW_ASSERT (url != NULL);

  NW_TRY (status) {

    void* dynEntry;

    pendingLoad = (NW_CSS_Processor_PendingLoad_t*) NW_Mem_Malloc(sizeof *pendingLoad);

    NW_THROW_OOM_ON_NULL (pendingLoad, status);

    pendingLoad->isSavedDeck = isSavedDeck;

    pendingLoad->isHistLoad = isHistLoad;

	pendingLoad->isReLoad = isReLoad;

    pendingLoad->url = NW_Text_Copy(url, NW_TRUE);

    pendingLoad->cssBufferIndex = cssBufferIndex;

    if(thisObj->pendingLoads == NULL)

    {

      thisObj->pendingLoads = (NW_ADT_DynamicVector_t*)

        NW_ADT_ResizableVector_New (sizeof (NW_CSS_Processor_PendingLoad_t*), 5, 10);

      NW_THROW_OOM_ON_NULL (thisObj->pendingLoads, status);

    }

    dynEntry = NW_ADT_DynamicVector_InsertAt (thisObj->pendingLoads, &pendingLoad,

                                           NW_ADT_Vector_AtEnd);

    NW_THROW_OOM_ON_NULL (dynEntry, status);

  }

  NW_CATCH (status) {

    NW_ADT_Vector_Metric_t size;

    NW_ADT_Vector_Metric_t index;

    NW_Object_Delete(pendingLoad->url);

    NW_Mem_Free (pendingLoad);

    size =  NW_ADT_Vector_GetSize(thisObj->pendingLoads);

    for (index =0; index <size; index++)

    {

      NW_CSS_Processor_PendingLoad_t* load;

      load = *(NW_CSS_Processor_PendingLoad_t**)

        NW_ADT_Vector_ElementAt (thisObj->pendingLoads, index);

      NW_Object_Delete(load->url);

      NW_Mem_Free(load);

    }

    NW_Object_Delete(thisObj->pendingLoads);

  }

  NW_FINALLY {

    return status;

  } NW_END_TRY

}

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

static

NW_Cache_Mode_t NW_CSS_Processor_GetCacheMode(NW_Bool isSavedDeck, NW_Bool isHistLoad, NW_Bool isReLoad)

{

    if (isSavedDeck)

        return NW_CACHE_ONLYCACHE;

    else if(isHistLoad)

        return NW_CACHE_HISTPREV;

	else if (isReLoad)

		return NW_CACHE_NOCACHE;

    return NW_CACHE_NORMAL;

}

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

static

NW_Uint32

NW_CSS_Processor_ComputeEncoding(NW_Byte* data,

                                 NW_Uint32 length,

                                 NW_Uint32 encoding)

{

  /*

    The goal here is to permit the content author to do something

    which is within current specifications and can be depended on to

    work.

    If the server and loader can identify the charset as something

    other than Latin-1 then that charset is accepted as accurate.

    If the charset is Latin-1 (ISO-8859-1) then this either means that

    the server and loader accurately communicated the charset as

    Latin-1 or they did not communicate and the charset defaulted to

    Latin-1.  Thus, Latin-1 cannot be relied on to be accurate.  So

    for Latin-1 we apply the following constraint to determine the

    charset:

    Content authors must place a byte order mark (BOM) at the

    beginning of the document only if the encoding is UCS-2 or UTF-8.

    If the first bytes are:

    0xFE 0xFF ## ## where the two ## bytes are not both zero then the

    encoding is UCS-2 (UCS-2 is roughly a subset of UTF-16 in our use)

    0xEF 0xBB 0xBF then the encoding is UTF-8

    otherwise the encoding is left as Latin-1.

    Differentiating ASCII from Latin-1 is never an issue because it is

    a subset of Latin-1 which is the default.

    You can find a discussion of this type of encoding detection at

    http://www.w3.org/TR/2000/REC-xml-20001006#sec-guessing

  */

  if ((encoding != HTTP_iso_8859_1) || (data == NULL))

  {

    return encoding;

  }

  if (length >= 3) {

    if ((data[0] == 0xef) && (data[1] == 0xbb) && (data[2] == 0xbf)) {

      return HTTP_utf_8;

    }

  }

  if (length >= 4) {

    if (((data[0] == 0xfe) && (data[1] == 0xff))

        && ((data[2] != 0x00) || (data[3] != 0x00))) {

      return HTTP_iso_10646_ucs_2;

    }

  }

  return encoding;

}

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

static

TBrowserStatusCode

NW_CSS_Processor_ProcessExternalBuffer(NW_CSS_Processor_t* thisObj,

                                       NW_Byte* data,

                                       NW_Uint32 length,

                                       NW_Uint32 charset,

                                       TInt bufferIndex)

{

  CCSSBufferList* bufferList;

  CCSSRuleList* ruleList = (CCSSRuleList*)thisObj->ruleList;

  NW_ASSERT (thisObj != NULL);

  NW_ASSERT (data != NULL);

  NW_TRY(status)

  {

    /* for convenience */

    bufferList = ruleList->GetBufferList();

    if (charset == 0)

    {/* implies - value not found in header */

      charset = bufferList->GetEncoding(bufferIndex);

      if (charset ==0){/* default to Latin1 */

        charset = HTTP_iso_8859_1;

      }

    }

    charset = NW_CSS_Processor_ComputeEncoding(data, length, charset);

    ruleList->SetCurrentBufferIndex(bufferIndex);

    TCSSParser parser(data, length, charset);

    charset = parser.ParseCharset();

    bufferList->UpdateEntry(data, length, charset, bufferIndex);

    // Parse the complete style sheet -- ignore all problems except

    // out of memory.  This allows it to apply at least some of the

    // style.

    status =  parser.ParseStyleSheet((MCSSEventListener*)(ruleList));

    NW_THROW_ON(status, KBrsrOutOfMemory);

    /* finally apply stylesheet */

    status = NW_CSS_Processor_ApplyStyleSheet(thisObj);

  }

  NW_CATCH (status)

  {}

  NW_FINALLY

  {

    ruleList->SetCurrentBufferIndex(-1);

    return status;

  }

  NW_END_TRY

}

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

static

TBrowserStatusCode

NW_CSS_Processor_HandleCSSLoadComplete( NW_CSS_Processor_t* thisObj, NW_Uint16 transactionId,

                                        NW_Url_Resp_t* response, void* clientData )

  {

  TLoadListEntry* findEntry = NULL;

  NW_ASSERT( thisObj != NULL );

  NW_TRY( status )

    {

    CCSSLoadList* loadList = (CCSSLoadList*)(thisObj->iLoadList);

    TInt index = 0;    

    NW_ASSERT( response != NULL );

    findEntry = (TLoadListEntry*)NW_Mem_Malloc( sizeof( TLoadListEntry ) );

    NW_THROW_OOM_ON_NULL( findEntry, status );

    findEntry->iTransactionId = transactionId;

    TNumKeyArrayPtr matchkey( _FOFF( TLoadListEntry, iTransactionId ), ECmpTUint16 );

    NW_CSS_Processor_LoadContext_t* loadContext = (NW_CSS_Processor_LoadContext_t*) clientData;

    // if found the element remove it

    if( loadList->FindIsq( findEntry, matchkey, index ) == 0 )

      {

      TLoadListEntry* tempEntry = loadList->At( index );

      // If the image has not loaded the PartialChunkBuffer will be

      // null. Rather than crash we should handle it.

      NW_Byte* data;

      NW_Uint32 length;

      if (tempEntry->iPartialChunkBuffer)

        {

        data = tempEntry->iPartialChunkBuffer->data;

        length = tempEntry->iPartialChunkBuffer->length;

        }

      else

        {

        data = NULL;

        length = 0;

        }

      // css markup itself

      if( tempEntry->iLoadType == NW_CSS_Processor_LoadCSS )

        {

        NW_Http_CharSet_t charset = response->charset;

        // find out if the server response contained any charset

        // This gets the highest priority

        if( NW_Settings_GetEncoding() == EAutomatic )

          {

          charset = response->charset;

          }

        if (data)

            {

            status = NW_CSS_Processor_ProcessExternalBuffer( thisObj, data, length,

                              charset, loadContext->bufferIndex );

            NW_ASSERT( status == KBrsrSuccess );

            // NW_CSS_Processor_ProcessExternalBuffer takes data ownership

            if( status == KBrsrSuccess )

                {

                tempEntry->iPartialChunkBuffer->data = NULL;

                tempEntry->iPartialChunkBuffer->length = 0;

                }

            }

        }

      // it is an image

      else if( tempEntry->iLoadType == NW_CSS_Processor_LoadImage )

        {

        NW_Text_UCS2_t* url;

        url =

          NW_Text_UCS2_New( response->uri, 0, NW_Text_Flags_TakeOwnership );

        if( url == NULL )

          {

          NW_Mem_Free( data );

          status = KBrsrOutOfMemory;

          }

        else

          {

          // make a deep copy of the data 

          NW_Byte* retData = (NW_Byte*) NW_Mem_Malloc( length );

          if (retData == NULL)

                {

                  NW_Mem_Free( data );

                  status = KBrsrOutOfMemory;

                }

          NW_Mem_memcpy( retData, data, length );

          status = NW_CSS_Processor_SetImage( thisObj, retData, length,

                                             response->contentTypeString, NW_TextOf( url ) );

          response->uri = NULL;

  	      if( status != KBrsrSuccess )

            {

            NW_Mem_Free( data );

            }

          NW_Object_Delete( url );

          }

        }

      else

        {

        NW_Mem_Free( data );

        }

      loadList->Delete( index );

      NW_Buffer_Free(tempEntry->iPartialChunkBuffer);

      NW_Mem_Free( tempEntry );

      loadList->Compress();

      }

    }

  NW_CATCH( status )

    {

    }

  NW_FINALLY

    {

    NW_Mem_Free( findEntry );

    // free response

    UrlLoader_UrlResponseDelete( response );

    return status;

    }

  NW_END_TRY

  }

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

static

TBrowserStatusCode

NW_CSS_Processor_BufferPartialChunk( NW_CSS_Processor_t* thisObj, NW_Uint16 transactionId,

                                     NW_Int32 chunkIndex, NW_Url_Resp_t* response  )

  {

  TLoadListEntry* findEntry = NULL;

  NW_ASSERT( thisObj != NULL );

  NW_ASSERT( response != NULL );

  NW_TRY( status )

    {

    CCSSLoadList* loadList = (CCSSLoadList*)( thisObj->iLoadList );

    if( response->body != NULL )

      {

      TInt index = 0;

      findEntry = (TLoadListEntry*)NW_Mem_Malloc( sizeof( TLoadListEntry ) );

      NW_THROW_OOM_ON_NULL( findEntry, status );

      findEntry->iTransactionId = transactionId;

      // look-up the element in the load list

      TNumKeyArrayPtr matchkey( _FOFF( TLoadListEntry, iTransactionId ), ECmpTUint16 );

      if( loadList->FindIsq( findEntry, matchkey, index ) == 0 )

        {

        TLoadListEntry* tempEntry = loadList->At( index );

        // first chunk

        if( chunkIndex == 0 )

          {

          // pass response body ownership

          tempEntry->iPartialChunkBuffer = response->body;

          response->body = NULL;

          loadList->At( index ) = tempEntry;

          }

        else if( chunkIndex != -1 )

          {

          // append body to the buffer

          status = NW_Buffer_AppendBuffers( tempEntry->iPartialChunkBuffer, response->body );

          _NW_THROW_ON_ERROR( status );

          }

        else

          {

          // last partial response has no body. should not reach this code

          NW_ASSERT( NW_TRUE );

          }

        }

      else

        {

        // must find an item in the list

        NW_ASSERT( NW_TRUE );

        }

      }

    }

  NW_CATCH( status )

    {

    }

  NW_FINALLY

    {

    NW_Mem_Free( findEntry );

    // free response

    UrlLoader_UrlResponseDelete( response );

    return status;

    }

  NW_END_TRY

  }

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

TBrowserStatusCode

NW_CSS_Processor_ProcessLoadRequest(NW_CSS_Processor_t* thisObj,

                                    NW_Text_t* url,

                                    NW_Uint8 loadType,

                                    NW_Bool isSavedDeck,

                                    NW_Bool isHistLoad,

									NW_Bool isReLoad,

                                    TInt cssBufferIndex)

{

  NW_CSS_Processor_LoadContext_t* loadContext = NULL;

  NW_Uint16 transactionId = 0;

  NW_Bool deleteLoadOnFailure = NW_FALSE;

  NW_HED_Loader_t *loader = NULL;

  NW_Ucs2* urlUcs2 = NULL;

  CBodyPart* bodyPart = NULL;

  TBool isUrlInMultipart = EFalse;

  NW_ASSERT (thisObj != NULL);

  NW_ASSERT (url != NULL);

  NW_TRY (status)

  {

    NW_HED_DocumentRoot_t* docRoot =

      (NW_HED_DocumentRoot_t*)NW_HED_DocumentNode_GetRootNode( thisObj->owner );

    NW_THROW_ON_NULL( docRoot, status, KBrsrFailure );