/*
* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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: This file implements class CESMRICalContentLineReader.
*
*/


// Class include.
#include "emailtrace.h"
#include "cesmricalcontentlinereader.h" // CESMRICalContentLineReader

//debug

// System includes.
#include <s32strm.h>    // RReadStream
#include <utf.h>        // CnvUtfConverter

// User includes.
#include "esmricalkeywords.h"   // Literals.

namespace
{
// Constants.
const TInt KICalSkipWhiteSpaceLength = 1;
const TInt KICalSkipCRLength = 1;
const TInt KICalStartChar = 0;

/*
The iCalendar specification states that a content line should be no longer than
75 octets in length, excluding the CRLF delimiter. It appears that MS Outlook
does not include the length of the property string when calculating the length
of a content line, meaning that a content line in an iCalendar exported from MS
Outlook may be longer than the allowed 75 octets. KICalMaxContentLineLength
allows a little extra space to support this.
*/
const TInt KICalMaxContentLineLength = 120;
}//namespace

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::NewL
// ---------------------------------------------------------------------------
//
CESMRICalContentLineReader* CESMRICalContentLineReader::NewL(RReadStream& aStream)
    {
    FUNC_LOG;

    CESMRICalContentLineReader* self = CESMRICalContentLineReader::NewLC(aStream);
    CleanupStack::Pop(self);

    return self;
    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::NewLC
// ---------------------------------------------------------------------------
//
CESMRICalContentLineReader* CESMRICalContentLineReader::NewLC(RReadStream& aStream)
    {
    FUNC_LOG;

    CESMRICalContentLineReader* self = new (ELeave) CESMRICalContentLineReader(aStream);
    CleanupStack::PushL(self);
    self->ConstructL();

    return self;
    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::~CESMRICalContentLineReader
// ---------------------------------------------------------------------------
//
CESMRICalContentLineReader::~CESMRICalContentLineReader()
    {
    FUNC_LOG;

    delete iCurrentLine;
    delete iNextLine;

    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::GetNextContentLine
// ---------------------------------------------------------------------------
//
TInt CESMRICalContentLineReader::GetNextContentLine(TPtrC& aPtr)
    {
    FUNC_LOG;

    if (iFlags & EEof)
        {
        return KErrEof;
        }

    TInt error(KErrNone);

    // Trap errors as the stream will leave with KErrEof when we reach the end.
    TRAP(error, GetNextContentLineL());

    aPtr.Set(iCurrentLine->Des());

    if (error == KErrEof)
        {
        iFlags |= EEof;
        error = KErrNone;
        }

    return error;
    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::SkipComponentL
// ---------------------------------------------------------------------------
//
void CESMRICalContentLineReader::SkipComponentL(const TDesC& aName)
    {
    FUNC_LOG;

    // Take a copy of the name, since GetNextContentLine may corrupt the original
    HBufC* beginName = aName.AllocLC();

    // Find the next BEGIN: or END:
    TPtrC contentLine;
    TInt error(GetNextContentLine(contentLine));
    while (error == KErrNone)
        {
        // Find the colon separator
        const TInt colonPos = contentLine.Locate(KICalColonChar);
        // If there isn't one it's an error
        if (colonPos == KErrNotFound)
            {
            User::Leave(KErrCorrupt);
            }
        // Find the string preceding the colon
        TPtrC name(contentLine.Left(colonPos));
        // If it's a begin, recursively skip this component also
        if (name.CompareF(KICalBegin) == 0)
            {
            TPtrC value(contentLine.Mid(colonPos + 1));
            SkipComponentL(value);
            }
        // If it's an end, check that it's the right end
        else if (name.CompareF(KICalEnd) == 0)
            {
            TPtrC value(contentLine.Mid(colonPos + 1));
            if (value.CompareF(*beginName) == 0)
                {
                // We have successfully skipped the component
                CleanupStack::PopAndDestroy(beginName);
                return;
                }
            else
                {
                User::Leave(KErrCorrupt);
                }
            }
        // If it is neither a begin nor an end, try the next line
        error = GetNextContentLine(contentLine);
        }
    // If any errors occur in reading we may as well leave with them
    if (error != KErrEof)
        {
        User::Leave(error);
        }
    // If we get this far we have failed to find an end
    User::Leave(KErrCorrupt);

    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::CESMRICalContentLineReader
// ---------------------------------------------------------------------------
//
CESMRICalContentLineReader::CESMRICalContentLineReader(RReadStream& aStream)
    : iReadStream(aStream)
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::ConstructL
// ---------------------------------------------------------------------------
//
void CESMRICalContentLineReader::ConstructL()
    {
    FUNC_LOG;

    iCurrentLine = HBufC::NewL(KICalMaxContentLineLength);
    iNextLine = HBufC::NewL(KICalMaxContentLineLength);

    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::GetLineL
// ---------------------------------------------------------------------------
//
/**
Reads from the stream to the next line feed.
@param aPtr A modifiable pointer to a buffer to read the line into.
@leave With KErrEof when the end of the stream is reached or KErrCorrupt if the
line is invalid.
@internalTechnology
*/
void CESMRICalContentLineReader::GetLineL(TPtr& aPtr)
    {
    FUNC_LOG;

    // Read stream as binary. ReadL() will leave with KErrEof when the end of the stream
    // is reached. Note that we will ignore any text read when leaving as the line must end
    // with a carriage return (and line feed) to be valid.
    TBuf8<KICalMaxContentLineLength> text;
    iReadStream.ReadL(text, TChar(KICalCarriageReturnChar));    // Read up to the next CR.

    // Check next char is line feed
    TUint8 nextChar(iReadStream.ReadUint8L());

    if (nextChar != KICalNewlineChar)
        {
        User::Leave(KErrCorrupt);
        }

    // Handle any character set conversion here
    CnvUtfConverter::ConvertToUnicodeFromUtf8(aPtr, text);  // Convert from UTF-8.

    // Set the length of aPtr to exclude the carriage return.
    if (aPtr.Length())
        {
        aPtr.SetLength(aPtr.Length() - KICalSkipCRLength);
        }

    }

// ---------------------------------------------------------------------------
// CESMRICalContentLineReader::GetNextContentLineL
// ---------------------------------------------------------------------------
//
/**
Reads the next content line from the stream into aPtr. If the content line has
been folded, it will be unfolded. After completion aPtr will point to the new
content line
@param aPtr TPtrC& to set to the new content line.
@leave Leaves with KErrEof when we reach the end of the stream.
@internalTechnology
*/
void CESMRICalContentLineReader::GetNextContentLineL()
    {
    FUNC_LOG;

    TPtr currentLine(iCurrentLine->Des());

    if (iNextLine->Length() == 0)
        {
        // If iNextLine is empty then this is the first line of the file.
        GetLineL(currentLine);
        }
    else
        {
        // Copy iNextLine to currentLine.
        currentLine.Copy(*iNextLine);
        }

    // Get the next line.
    TPtr nextPtr(iNextLine->Des());
    GetLineL(nextPtr);

    // Folded lines are delimited by a CRLF followed by single whitepace
    while (iNextLine->Length() && ((nextPtr[KICalStartChar] == KICalSpaceChar) ||
        (nextPtr[KICalStartChar] == KICalHTabChar)))
        {
        // Append the lines - reallocate buffer if needed.
        if (currentLine.MaxLength() < (iCurrentLine->Length() + nextPtr.Length()))
            {
            iCurrentLine = iCurrentLine->ReAllocL(currentLine.MaxLength() + KICalMaxContentLineLength);
            currentLine.Set(iCurrentLine->Des());
            }

        currentLine.Append(nextPtr.Mid(KICalSkipWhiteSpaceLength));
        GetLineL(nextPtr);
        }

    }

// End of File