/*

* Copyright (c) 2000 - 2004 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 "nw_hed_documentrooti.h"

#include "nw_hed_historyentry.h"

#include "nw_hed_urlrequest.h"

#include "nw_hed_urlresponse.h"

#include "nw_hed_treevisitor.h"

#include "nw_hed_appservices.h"

#include "nw_hed_inumbercollector.h"

#include "nw_adt_resizablevector.h"

#include "nw_adt_mapiterator.h"

#include "nw_adt_singleiterator.h"

#include "nw_imagech_epoc32contenthandler.h"

#include "nw_wml1x_epoc32contenthandler.h"

#include "nw_hed_iimageviewer.h"

#include "nw_hed_compositecontenthandleri.h"

#include "urlloader_urlloaderint.h"

#include "LMgrObjectBoxOOCi.h"

#include "HedLoadObserver.h"

#include "nwx_string.h"

#include "nw_evlog_api.h"

#include "nwx_logger.h"

#include "nwx_http_defs.h"

#include <stddef.h>

#include "BrsrStatusCodes.h"

#include "HEDDocumentListener.h"

#include "WmlControl.h"

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

   private methods

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

static

TBrowserStatusCode

NW_HED_PartialLoad_ValidityCheck( NW_HED_DocumentRoot_t* thisObj,

                                  NW_HED_DocumentNode_t** owner,

                                  TBrowserStatusCode loadStatus,

                                  NW_Url_Resp_t* response,

                                  NW_HED_UrlRequest_t* urlRequest )

  {

  TBrowserStatusCode status = KBrsrSuccess;

  NW_ASSERT( thisObj != NULL );

  NW_ASSERT( owner != NULL );

  NW_ASSERT( urlRequest != NULL );

  // TODO remove this wmlscript HACK 

  //

  // Wml-scripts can be executed from a <go> tag -- go's usually replace 

  // the top-level document, but in this case we want to handle it as an

  // embedded resource.  Because of this we must change the url-request

  // reason to NW_HED_UrlRequest_Reason_DocLoadChild.

  if( response != NULL && response->contentTypeString != NULL )

    {

    if( NW_Asc_stricmp( (char*)HTTP_application_vnd_wap_wmlscriptc_string, 

	  		     		  (char*)response->contentTypeString ) == 0 )

      {

      NW_HED_UrlRequest_SetReason( urlRequest, NW_HED_UrlRequest_Reason_DocLoadChild );

      // set the owner back to wml content handler

      NW_ASSERT( thisObj->childNode != NULL );

      // wml script onwed by wml ch

      if( NW_Object_IsInstanceOf( thisObj->childNode, &NW_Wml1x_Epoc32ContentHandler_Class ) == NW_TRUE )

        {

        *owner = thisObj->childNode;

        }

      else

        {

        status = KBrsrWmlbrowserBadContentType;

        }

      }

    }  

  if( loadStatus != KBrsrSuccess ) 

    {

    // we failed to load the page and will not be creating a new box tree.

    // The reason for the load was doing Back - since before issuing request

    // we pushed the history back, we now move it forward. This is not the right

    // way to do things and should be cleaned up in future

    if( ( NW_HED_UrlRequest_GetReason( urlRequest ) == NW_HED_UrlRequest_Reason_ShellPrev ) || 

        ( NW_HED_UrlRequest_GetReason( urlRequest ) == NW_HED_UrlRequest_Reason_DocPrev ) )

      {

      NW_HED_HistoryStack_SetCurrent( thisObj->historyStack, NW_HED_HistoryStack_Direction_Next );

      }

    }

  // if a top-level request is cancelled we don't need to do anything else 

  return status;

  }

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

static

TBrowserStatusCode

NW_HED_DocumentRoot_PushNewHistoryEntry (NW_HED_DocumentRoot_t* thisObj, 

                                         NW_HED_ContentHandler_t* contentHandler,

                                         NW_HED_UrlRequest_t* newReq,

                                         NW_HED_UrlResponse_t* newResp)

  {

  NW_HED_HistoryEntry_t* newEntry;

  TBrowserStatusCode status = KBrsrSuccess;

  const NW_Ucs2* url = NW_HED_UrlRequest_GetRawUrl( newReq );

  TUriParser16 uriParser;

  const TText* linkUrl = NULL;

  NW_Text_t* textUrl = NULL;

  // remove username:password information from the URL

  if (url)

    {

    linkUrl = url;

    TPtrC urlDes (linkUrl, User::StringLength(linkUrl));

    User::LeaveIfError(uriParser.Parse(urlDes));

    if ( uriParser.IsPresent( EUriUserinfo ) )

      {

      // Remove the username and password from the URI

      CUri16* newUri = CUri16::NewLC( uriParser );

      newUri->RemoveComponentL( EUriUserinfo );

      const TText* newUrl = newUri->Uri().UriDes().Ptr();

      textUrl = NW_Text_New(HTTP_iso_10646_ucs_2, (void*)newUrl, newUri->Uri().UriDes().Length(), 

                            NW_Text_Flags_NullTerminated | NW_Text_Flags_Aligned | NW_Text_Flags_Copy);

      // delete the old url from the request

      NW_Object_Delete (newReq->url);

      // assign the new url to the request

      newReq->url = textUrl;

      CleanupStack::PopAndDestroy( newUri ); // newUri

      }

    }

  if (contentHandler != NULL) 

    {

    newEntry = NW_HED_ContentHandler_CreateHistoryEntry (contentHandler,

							 newReq, newResp);

    }

  else 

    {

    newEntry = NW_HED_HistoryEntry_New (newReq, newResp);

    }

  if (newEntry) 

    {

    NW_Ucs2 *responseUrl = NULL;

    status = NW_HED_HistoryStack_PushEntry (thisObj->historyStack, newEntry);

    NW_ASSERT (status == KBrsrSuccess);

    /* We don't want to current entry in the stack to have an invalid url.*/

    responseUrl = (NW_Ucs2 *)NW_HED_UrlResponse_GetRawUrl(newResp);

    if (responseUrl == NULL || NW_Str_Strlen(responseUrl) == 0) 

      {

      NW_HED_HistoryStack_SetCurrent (thisObj->historyStack, 

                                      NW_HED_HistoryStack_Direction_Previous);

      }

    if(url != NULL)

      {

      NW_ASSERT(thisObj->appServices != NULL);

      NW_EvLog_Log( &(thisObj->appServices->evLogApi), NW_EvLog_HISTORY_PUSH,

		    url );

      }

    }

  else 

    {

    status = KBrsrOutOfMemory;

    }

  return status;

  }

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

static

TBrowserStatusCode

NW_HED_DocumentRoot_UpdateHistory (NW_HED_DocumentRoot_t* thisObj,

                                   NW_HED_ContentHandler_t* contentHandler,

                                   NW_HED_UrlRequest_t* urlRequest,

                                   NW_Url_Resp_t* response)

{

  NW_HED_UrlResponse_t* newResp = NULL;

  NW_Url_Resp_t* tempResponse = NULL;

  /* get the new and current url-responses */ 

  if (response == NULL) {

    tempResponse = UrlLoader_UrlResponseNew(NW_HED_UrlRequest_GetRawUrl (urlRequest),

    NULL, 0, NULL, NULL, NULL, NW_FALSE, NULL, NULL, 0, NULL, 0, 0, 0, 0);

    NW_THROWIF_MEM (tempResponse);

    response = tempResponse;

  }

  if (contentHandler == NULL) {

    newResp = NW_HED_UrlResponse_New (response);

  }

  else {

    newResp = NW_HED_ContentHandler_NewUrlResponse (contentHandler, response);

  }

  NW_THROWIF_MEM (newResp);

  /* this is no longer needed */

  if (tempResponse != NULL) {

    UrlLoader_UrlResponseDelete (tempResponse);

    tempResponse = NULL;

  }

  /* if the request is non-history-based "push" a new history-entry */

  // urlRequest->loadType == NW_HED_UrlRequest_Reason_ShellReload is a temporary

  // fix on the Meta refresh issue when the meta starts a request with ShellReload type

  // and that request returns a different response url ("redirection") to what we already have in

  // the history list. In this case we need to update the history entry with the

  // redirected url otherwise no relative url will work.

  if ((NW_HED_UrlRequest_IsHistoricRequest (urlRequest) == NW_FALSE || 

       urlRequest->reason == NW_HED_UrlRequest_Reason_ShellReload )) 

    {

    NW_HED_HistoryEntry_t* currentEntry;

    currentEntry = NW_HED_HistoryStack_GetEntry( thisObj->historyStack, NW_HED_HistoryStack_Direction_Current );

    if( !currentEntry || !NW_HED_UrlRequest_Equal( currentEntry->urlRequest,urlRequest ) )

      {

      // this is a new request. let's push it to the history stack.

      NW_THROWIF_ERROR( NW_HED_DocumentRoot_PushNewHistoryEntry( thisObj, contentHandler, urlRequest, newResp ) );

      }

    else if( currentEntry )

      {

      // check if the response url has been changed. - redirection case from www.x.com to www2.x.com

      if( currentEntry->urlResponse )

        {

        if( !NW_HED_UrlResponse_Equal( currentEntry->urlResponse, newResp ) )

          {

          // If currentEntry's URL is same as referrer, clear referer before deleting.

          const NW_Text_t* referrerUrl = NW_HED_DocumentRoot_GetDocumentReferrer( thisObj );

          if ( referrerUrl )

            {

            if ( referrerUrl->storage == currentEntry->urlResponse->rawUrl )

              {

              NW_HED_DocumentRoot_SetDocumentReferrer( thisObj, NULL );

              }

            }

          // update response entry

          NW_Object_Delete( currentEntry->urlResponse );

          currentEntry->urlResponse = newResp;

          }

        else

          {

          // free response entry if we do not add it to the history stack

          NW_Object_Delete( newResp );

          }

        }

      }

    }

  /* 

  ** We are navigating in history or preforming a reload.  So we don't need to 

  ** create a new history entry.

  */

  else 

    {

    /* 

    ** TODO we should probably replace the urlResponse found in the history

    ** entry with this one.  The question is how do we know which history 

    ** entry contains the response we want to update?

    */

    NW_Object_Delete (newResp);

    }

  return KBrsrSuccess;

NW_CATCH_ERROR

  NW_Object_Delete (newResp);

  UrlLoader_UrlResponseDelete(tempResponse);

  return KBrsrFailure;

NW_CATCH_MEM

  NW_Object_Delete (newResp);

  UrlLoader_UrlResponseDelete(tempResponse);

  return KBrsrOutOfMemory;

}

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

/*****************************************************************

  Name:         NW_HED_DocumentRoot_CreateTopLevelContentHandler

  Description:  Creates content handler for a given top level context

  Parameters:   See below

  Return Value: loadStatus, *contentHandler

*****************************************************************/

static 

TBrowserStatusCode

NW_HED_DocumentRoot_CreateTopLevelContentHandler(NW_HED_DocumentRoot_t* thisObj,

                                                 NW_HED_DocumentNode_t* owner,

                                                 NW_Url_Resp_t* response,

                                                 NW_HED_UrlRequest_t* urlRequest,

                                                 NW_HED_ContentHandler_t** newContentHandler)

    {

    NW_HED_ContentHandler_t* contentHandler = NULL;

    TBrowserStatusCode status = KBrsrSuccess;

    // parameter assertion block 

    NW_ASSERT(urlRequest != NULL);

    NW_ASSERT(response != NULL);

    NW_ASSERT(response->contentTypeString != NULL);

    NW_ASSERT(NW_HED_UrlRequest_IsTopLevelRequest(urlRequest) != NW_FALSE);

    // Check if we want to create a top-level content handler

    if ((NW_Asc_stricmp((char*)HTTP_text_vnd_wap_wmlscript_string, 

                        (char*)response->contentTypeString) == 0)) 

        {

        // Script cannot be at top level

        status = KBrsrScriptBadContent;

        }

    // Try to create a content handler for     

    if (status == KBrsrSuccess)

        {

        // create content handler

        contentHandler = NW_HED_MimeTable_CreateContentHandler(thisObj->mimeTable,

                                                               owner,

                                                               response->contentTypeString,

                                                               urlRequest, response, NW_TRUE);

        // we do support the content-type so initialize the newly created

        // content-handler

        if (contentHandler != NULL) 

            {

            NW_HED_HistoryEntry_t* currentEntry;

            NW_Bool deleteBoxTree = NW_TRUE;

            thisObj->documentListener->NewDocument (thisObj, urlRequest, deleteBoxTree);

            // update the history 

            NW_HED_DocumentRoot_UpdateHistory(thisObj, contentHandler, urlRequest, response);

            // associate content handler with current history entry 

            currentEntry = NW_HED_HistoryStack_GetEntry(thisObj->historyStack, 

                                                        NW_HED_HistoryStack_Direction_Current);

            NW_HED_ContentHandler_SetAssociatedHistoryEntry(contentHandler, currentEntry);

            // delete old certInfo, store the new certInfo

            NW_Mem_Free(thisObj->certInfo);

            thisObj->certInfo = NULL;

            if (response != NULL)

                {

                thisObj->certInfo = response->certInfo;

                // take ownership

                response->certInfo = NULL;

                }

            // set childnode. current childnode is saved as previous at 

            // MHEDDocumentListener::NewDocument

            thisObj->childNode = NW_HED_DocumentNodeOf( contentHandler );

            }

        else

            {

            // if this is null we don't support the content-type of the response

            status = KBrsrWmlbrowserBadContentType;

            }

        }

    *newContentHandler = contentHandler;

    return status;

    }

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

static

NW_Bool

NW_HED_DocumentRoot_OnLoadError (NW_HED_DocumentRoot_t* thisObj,

                                 NW_Int16 errorClass,

                                 NW_WaeError_t error)

{

   return thisObj->documentListener->LoadEnd (thisObj, errorClass, error);

  /* Be careful adding code after this line, since we may already exitted the browser */

}

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

static

void

NW_HED_DocumentRoot_HandleLoadError (NW_HED_DocumentRoot_t* thisObj,

                                     NW_HED_DocumentNode_t* owner,

                                     const NW_HED_UrlRequest_t *urlRequest,

                                     NW_Int16 errorClass,

                                     TBrowserStatusCode error)

{

  (void) urlRequest;

  /* 

  ** only handle errors generated by the document-root or the 

  ** current content handler.

  */

  if ((owner == NW_HED_DocumentNodeOf (thisObj)) || 

      (owner == NW_HED_DocumentNodeOf (thisObj->childNode))) {

    thisObj->documentErrorClass = errorClass;

    thisObj->documentError = error;

    (void)NW_HED_DocumentNode_Cancel (thisObj, NW_HED_CancelType_Error);

  }

}

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

static

void

NW_HED_DocumentRoot_HandleIntraPageNavError (NW_HED_DocumentRoot_t* thisObj,

                                             NW_HED_DocumentNode_t* owner,

                                             const NW_HED_UrlRequest_t *urlRequest,

                                             NW_Int16 errorClass,

                                             TBrowserStatusCode error)

{

  (void) urlRequest;

  /* 

  ** only handle errors generated by the document-root or the 

  ** current content handler.

  */

  if ((owner == NW_HED_DocumentNodeOf (thisObj)) || 

      (owner == NW_HED_DocumentNodeOf (thisObj->childNode))) {

    thisObj->documentErrorClass = errorClass;

    thisObj->documentError = error;

    (void)NW_HED_DocumentNode_Cancel (thisObj, NW_HED_CancelType_Error);

  }

}

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

static

NW_Bool

NW_HED_DocumentRoot_HandleSteadyStateError (NW_HED_DocumentRoot_t* thisObj,

                                            NW_HED_DocumentNode_t* owner,

                                            const NW_HED_UrlRequest_t *urlRequest,

                                            NW_Int16 errorClass,

                                            TBrowserStatusCode error)

{

  (void) owner;

  (void) urlRequest;

  /* simply show the error */

  return thisObj->documentListener->ReportError (thisObj, errorClass, (NW_WaeError_t) error, NULL);

}

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

static

TBrowserStatusCode

NW_HED_DocumentRoot_GetRestoreHistoryDirection (NW_HED_DocumentRoot_t* thisObj,

                                                NW_HED_HistoryStack_Direction_t* restoreDir)

{

  NW_HED_HistoryEntry_t* entry = NULL;

  const NW_HED_UrlRequest_t* urlReq = NULL;

  TBrowserStatusCode status = KBrsrSuccess;

  NW_Uint8 reason;

  NW_ASSERT (NW_Object_IsInstanceOf (thisObj, &NW_HED_DocumentRoot_Class));

  NW_ASSERT (restoreDir);

  /* get the reason the current load was issued */

  NW_THROWIF_NULL (entry = NW_HED_HistoryStack_GetEntry (thisObj->historyStack,

                                        NW_HED_HistoryStack_Direction_Current));

  NW_THROWIF_NULL (urlReq = NW_HED_HistoryEntry_GetUrlRequest (entry));

  reason = NW_HED_UrlRequest_GetReason (urlReq);

  /* 

  ** given the reason for the load that just failed determine the history

  ** direction that would "restore" it.  If the reason was either restore-next

  ** or restore-prev then the "restored" page failed for some reason and we

  ** should do nothing.

  */

  switch (reason)

  {

    case NW_HED_UrlRequest_Reason_ShellPrev:

    case NW_HED_UrlRequest_Reason_DocPrev:

		  *restoreDir = NW_HED_HistoryStack_Direction_RestoreNext;

		  break;

    case NW_HED_UrlRequest_Reason_DocLoad:

    case NW_HED_UrlRequest_Reason_ShellLoad:

    case NW_HED_UrlRequest_Reason_ShellNext:

		  *restoreDir = NW_HED_HistoryStack_Direction_RestorePrevious;

		  break;

    case NW_HED_UrlRequest_Reason_ShellReload:

    case NW_HED_UrlRequest_Reason_Undefined:

    case NW_HED_UrlRequest_Reason_DocLoadChild:

		  status = KBrsrFailure;

		  break;

	  case NW_HED_UrlRequest_Reason_RestorePrev:

    case NW_HED_UrlRequest_Reason_RestoreNext:

		  status = KBrsrFailure;

		  break;

  }

  return status;

NW_CATCH_ERROR

  status = KBrsrFailure;

  return status;