/*

* Copyright (c) 2005 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:  RSS parser

*

*/

#include <feedattributes.h>

#include "FeedParserObserver.h"

#include <leaktracker.h>

#include "AtomFeedParser.h"

#include <xmlutils.h>

// Element and attribute names used by this parser.

_LIT8(KHead, "feed");

_LIT8(KTagline, "tagline");

_LIT8(KSubtitle, "subtitle");

_LIT8(KTitle, "title");

_LIT8(KLink, "link");

_LIT8(KId, "id");

_LIT8(KSummary, "summary");

_LIT8(KContent, "content");

_LIT8(KEntry, "entry");

//_LIT8(KXmlns, "xmlns");

_LIT8(KRel, "rel");

_LIT8(KHref, "href");

_LIT8(KType, "type");

_LIT8(KLength, "length");

_LIT8(KPublished, "published");

_LIT8(KUpdated, "updated");

_LIT8(KModified, "modified");

_LIT8(KIssued, "issued");

_LIT(KAlternate, "alternate");

_LIT(KEnclosure, "enclosure");

//_LIT8(KAtom1_0Namespace, "http://www.w3.org/2005/Atom");

// -----------------------------------------------------------------------------

// AtomFeedParser::NewL

//

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CAtomFeedParser* CAtomFeedParser::NewL(CXmlUtils& aXmlUtils)

    {

    CAtomFeedParser* self = new (ELeave) CAtomFeedParser(aXmlUtils);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::CAtomFeedParser

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CAtomFeedParser::CAtomFeedParser(CXmlUtils& aXmlUtils):

        CFeedParser(aXmlUtils), iLeakTracker(CLeakTracker::EAtomFeedParser)

    {

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CAtomFeedParser::ConstructL()

    {

    // The mappings are used to map elements to handler methods.  For example when

    // a <title> element is found its contents are extracted as CDATA and passed

    // on to the observer as a EFeedAttributeTitle.

    //

    // Add mappings to process the children of a channel.

    //

    AddFeedMappingL(KNullDesC8(), KEntry(), EFeedAttributeUnused, ElementHandlerItemL);

    AddFeedMappingL(KNullDesC8(), KTitle(), EFeedAttributeTitle, ElementHandlerTextL);

    AddFeedMappingL(KNullDesC8(), KLink(), EFeedAttributeLink, ElementHandlerLinkL);

    AddFeedMappingL(KNullDesC8(), KTagline(), EFeedAttributeDescription, ElementHandlerCDataL);

    AddFeedMappingL(KNullDesC8(), KSubtitle(), EFeedAttributeDescription, ElementHandlerCDataL);

    AddFeedMappingL(KNullDesC8(), KPublished(), EFeedAttributeTimestamp, ElementHandlerTimestampL); 

    AddFeedMappingL(KNullDesC8(), KUpdated(), EFeedAttributeTimestamp, ElementHandlerTimestampL); 

    AddFeedMappingL(KNullDesC8(), KModified(), EFeedAttributeTimestamp, ElementHandlerTimestampL); 

    AddFeedMappingL(KNullDesC8(), KIssued(), EFeedAttributeTimestamp, ElementHandlerTimestampL);        

    //

    // Add mappings to process the children of an item.

    //

    AddItemMappingL(KNullDesC8(), KTitle(), EItemAttributeTitle, ElementHandlerTextL);

    AddItemMappingL(KNullDesC8(), KLink(), EItemAttributeLink, ElementHandlerLinkL);

    AddItemMappingL(KNullDesC8(), KContent(), EItemAttributeDescription, ElementHandlerCDataL);    

    AddItemMappingL(KNullDesC8(), KSummary(), EItemAttributeDescription, ElementHandlerCDataL); 

    AddItemMappingL(KNullDesC8(), KPublished(), EItemAttributeTimestamp, ElementHandlerTimestampL); 

    AddItemMappingL(KNullDesC8(), KUpdated(), EItemAttributeTimestamp, ElementHandlerTimestampL); 

    AddItemMappingL(KNullDesC8(), KModified(), EItemAttributeTimestamp, ElementHandlerTimestampL); 

    AddItemMappingL(KNullDesC8(), KIssued(), EItemAttributeTimestamp, ElementHandlerTimestampL);        

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::~CAtomFeedParser

// Deconstructor.

// -----------------------------------------------------------------------------

//

CAtomFeedParser::~CAtomFeedParser()

    {

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::IsFeedSupported

//

// Returns true if this feed parser can process the given document. 

// -----------------------------------------------------------------------------

//

TBool CAtomFeedParser::IsFeedSupported(CXmlUtils& aXmlUtils, 

        RXmlEngDocument aDocument, const TDesC& /*aContentType*/)

    {

    TXmlEngElement  node;

    // Get the root element.

    node = aXmlUtils.GetDocumentFirstElement(aDocument);

    // If the root node is missing the feed isn't supported.    

    if (node.IsNull())

        {

        return EFalse;

        }

    // If the root node is not HEAD_STR the feed isn't supported.

    if (!aXmlUtils.IsNamed(node, KHead))

        {

        return EFalse;

        }

    return ETrue;

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::ParseFeedL

//

// Creates a Feed instance from the given document. 

// -----------------------------------------------------------------------------

//

void CAtomFeedParser::ParseFeedL(RXmlEngDocument aDocument, 

        MFeedParserObserver& aObserver)

    {

	TXmlEngElement             rootNode;

    RXmlEngNodeList<TXmlEngElement>  children;

    // Get the feed node.

    rootNode = iXmlUtils.GetDocumentFirstElement(aDocument);

    iFeedTimestampNode = NULL;

    // Process the channel's children.

    aObserver.FeedBeginsL();

    rootNode.GetChildElements(children);

    while (children.HasNext())

        {

        TXmlEngElement    node = children.Next();

        // Process the element.

        HandleFeedChildL(node, aObserver);

        }

    // Set the timestamp attribute.

    if (iFeedTimestampNode.NotNull())

        {

        ElementHandlerDateL(*this, iXmlUtils, iFeedTimestampNode, 

                EFeedAttributeTimestamp, aObserver);

        }

    aObserver.FeedEndsL();

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::ElementHandlerItemL

//

// A ElementHandler function that populates the Item instance with the 

// values from the given item node.

// -----------------------------------------------------------------------------

//

void CAtomFeedParser::ElementHandlerItemL(const CFeedParser& aParser, CXmlUtils& aXmlUtils, 

        TXmlEngElement aNode, TInt /*aValueId*/, MFeedParserObserver& aObserver)

    {

    CAtomFeedParser&  parser(const_cast<CAtomFeedParser&>(static_cast<const CAtomFeedParser&>(aParser)));

    TXmlEngElement          node = NULL;

    // Create an empty Item.

    aObserver.ItemBeginsL();

    // Process the item's children.

    node = aXmlUtils.GetFirstElementChild(aNode);

    parser.iItemTimestampNode = NULL;

    while (node.NotNull())

        {

        // Process the element.

        parser.HandleItemChildL(node, aObserver);

        // Get the next element.

        node = aXmlUtils.GetNextSiblingElement(node);

        }

    // Postprocess the EItemAttributeIdStr attribute.

    parser.SetItemIdStrAttributeL(aNode, aObserver);

    // Postprocess the EItemAttributeTimestamp attribute.

    if (parser.iItemTimestampNode.NotNull())

        {

        ElementHandlerDateL(aParser, aXmlUtils, parser.iItemTimestampNode, 

                EItemAttributeTimestamp, aObserver);

        }

    // Add the Item to the Feed.

    aObserver.ItemEndsL();

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::ElementHandlerLinkL

//

// A ElementHandler function that handles the link element.

// -----------------------------------------------------------------------------

//

void CAtomFeedParser::ElementHandlerLinkL(const CFeedParser& /*aParser*/, CXmlUtils& aXmlUtils, 

        TXmlEngElement aNode, TInt aValueId, MFeedParserObserver& aObserver)

    {

    HBufC*  rel = NULL;

    HBufC*  href = NULL;

    // Get the link's relationship.

    rel = aXmlUtils.AttributeL(aNode, KRel);

    CleanupStack::PushL(rel);

    // Get the link's url.

    // TODO: Resolve the href using the base element or feed url.

    href = aXmlUtils.AttributeL(aNode, KHref);

    CleanupStack::PushL(href);

    if ((href == NULL) || (href->Length() == 0))

        {

        CleanupStack::PopAndDestroy(href);

        CleanupStack::PopAndDestroy(rel);

        return;

        }

    // The link points to an item's full story or feed's main web page.

    if ((rel == NULL) || (rel->CompareF(KAlternate) == 0))

        {

        aObserver.AddAttributeL(aValueId, *href);

        }

    // The link points to an enclsoure.

    else if (rel->CompareF(KEnclosure) == 0)

        {

        HBufC*  type = NULL;

        HBufC*  title = NULL;

        HBufC*  length = NULL;

        type = aXmlUtils.AttributeL(aNode, KType);

        CleanupStack::PushL(type);

        title = aXmlUtils.AttributeL(aNode, KTitle);

        CleanupStack::PushL(title);

        length = aXmlUtils.AttributeL(aNode, KLength);

        CleanupStack::PushL(length);

        aObserver.EnclosureBeginsL();

        if (type != NULL)

            {                    

            aObserver.AddAttributeL(EEnclosureAttributeContentType, *type);

            }

        if (length != NULL)

            {                    

            aObserver.AddAttributeL(EEnclosureAttributeSize, *length);

            }

        if (href != NULL)

            {                    

            aObserver.AddAttributeL(EEnclosureAttributeLink, *href);

            }

        if (title != NULL)

            {                    

            aObserver.AddAttributeL(EEnclosureAttributeTitle, *title);

            }

        aObserver.EnclosureEndsL();

        CleanupStack::PopAndDestroy(length);

        CleanupStack::PopAndDestroy(title);

        CleanupStack::PopAndDestroy(type);

        }

    CleanupStack::PopAndDestroy(href);

    CleanupStack::PopAndDestroy(rel);

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::ElementHandlerTimestampL

//

// A ElementHandler function that determines the timestamp to use.  The

// point is to track the most relevant timestamp (updated and modified take 

// precedence over published and issued).

// -----------------------------------------------------------------------------

//

void CAtomFeedParser::ElementHandlerTimestampL(const CFeedParser& aParser, CXmlUtils& aXmlUtils, 

        TXmlEngElement aNode, TInt aValueId, MFeedParserObserver& /*aObserver*/) 

    {

    CAtomFeedParser&  parser(const_cast<CAtomFeedParser&>(static_cast<const CAtomFeedParser&>(aParser)));

    TXmlEngElement*         timestampNode;

    if (aValueId == EFeedAttributeTimestamp)

        {

        timestampNode = &parser.iFeedTimestampNode;

        }

    else

        {

        timestampNode = &parser.iItemTimestampNode;

        }

    // As updated and modified mean the same thing (Atom 1.0 vs 0.3) just blindly

    // update iTimestamp.

    if (aXmlUtils.IsNamed(aNode, KUpdated))

        {

        *timestampNode = aNode;

        }

    else if (aXmlUtils.IsNamed(aNode, KModified))

        {

        *timestampNode = aNode;

        }

    // Only update iTimestamp if it wasn't already set.

    else if (timestampNode->IsNull())

        {

        if (aXmlUtils.IsNamed(aNode, KPublished))

            {

            *timestampNode = aNode;

            }

        else if (aXmlUtils.IsNamed(aNode, KIssued))

            {

            *timestampNode = aNode;

            }

        }

    }

// -----------------------------------------------------------------------------

// CAtomFeedParser::SetItemIdStrAttributeL

//

// Determine and set the unique IdStr attribute (unique to the feed that is).

// -----------------------------------------------------------------------------

//

void CAtomFeedParser::SetItemIdStrAttributeL(TXmlEngElement aItemNode, 

        MFeedParserObserver& aObserver)

    {    

    const TInt  KStrChunk = 30;

    TDesC*    content = NULL;

    TDesC*    summary = NULL;

    TDesC*    description = NULL;

    TDesC*    title = NULL;

    HBufC*    url = NULL;

    HBufC*    idStr = NULL;

    TXmlEngElement  node;

    // If the id node is present use it.

    node = iXmlUtils.GetFirstNamedChild(aItemNode, KId);

    if (node.NotNull())

        {

        ElementHandlerCDataL(*this, iXmlUtils, node, EItemAttributeIdStr, aObserver);        

        return;

        }

    // Otherwise create a idStr from the first 30 chars of the description and title

    // and the last 30 chars of the url.  This doesn't guarantee a unique id, but 

    // it very likely.

    node = iXmlUtils.GetFirstNamedChild(aItemNode, KSummary);

    summary = iXmlUtils.ExtractSimpleTextL(node, KStrChunk);

    CleanupStack::PushL(summary);

    node = iXmlUtils.GetFirstNamedChild(aItemNode, KContent);

    content = iXmlUtils.ExtractSimpleTextL(node, KStrChunk);

    CleanupStack::PushL(content);

    node = iXmlUtils.GetFirstNamedChild(aItemNode, KTitle);

    title = iXmlUtils.ExtractSimpleTextL(node, KStrChunk);

    CleanupStack::PushL(title);

    node = iXmlUtils.GetFirstNamedChild(aItemNode, KLink);

    url = iXmlUtils.ExtractSimpleTextL(node, KStrChunk, ETrue);

    CleanupStack::PushL(url);

    // Determine whether content or summary will be used for the description.

    description = summary;

    if (content != NULL)

        {

        if (summary == NULL)

            {

            description = content;

            }

        else if (content->Length() > summary->Length())

            {

            description = content;

            }

        }

    // Construct the idStr from the parts.

    TInt  len = 0;

    if (description != NULL)

        {

        len += description->Length();

        }

    if (title != NULL)

        {

        len += title->Length();

        }

    if (url != NULL)

        {

        len += url->Length();

        }

    idStr = HBufC::NewL(len);

    CleanupStack::PushL(idStr);

    TPtr  ptr(idStr->Des());

    if (description != NULL)

        {

        ptr.Append(*description);

        }

    if (title != NULL)

        {

        ptr.Append(*title);

        }

    if (url != NULL)

        {

        ptr.Append(*url);

        }

    // Replace any chars that may interfere with the database.

    _LIT(KSpace, " ");

    for (TInt i = 0; i < ptr.Length(); i++)

        {

        if (ptr[i] == '\'')

            {

            ptr.Replace(i, 1, KSpace());

            }

        }

    // Set the idStr attribute.

    aObserver.AddAttributeL(EItemAttributeIdStr, *idStr);

    CleanupStack::PopAndDestroy(idStr);    

    CleanupStack::PopAndDestroy(url);    

    CleanupStack::PopAndDestroy(title);    

    CleanupStack::PopAndDestroy(content);    

    CleanupStack::PopAndDestroy(summary);    

    }