/*
 ============================================================================
 Name        : GnHDRec.cpp
 Author      : cheney.kan
 Version     : 0.9
 Copyright   : Your copyright notice
 Description : CGnHDRec implementation
 ============================================================================
 */

#include <S32STRM.H>
#include <BAUTILS.H>
#include <S32FILE.H>
#include <BADESCA.H>


#include "GnHDRec.h"

_LIT(KGnHDRecSuffix, ".gnhdrs");




void CGnHDRecFmt::ExternalizeL(RWriteStream& aStream)const
{
    aStream<<iUri;
    aStream<<iPoint;
}
void CGnHDRecFmt::InternalizeL(RReadStream& aStream)
{
    aStream>>iUri;
    aStream>>iPoint;
}





CGnHDRec* CGnHDRec::NewLC()
    {
    CGnHDRec* self = new (ELeave) CGnHDRec();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CGnHDRec* CGnHDRec::NewL()
    {
    CGnHDRec* self = CGnHDRec::NewLC();
    CleanupStack::Pop(); // self;
    return self;
    }

void CGnHDRec::OpenOrCreateRecFileL(const TDesC & aRecFileName)
    {
    iRecFileName = aRecFileName;
    iRecFileName2 = aRecFileName;
    iRecFileName2.Append(KGnHDRecSuffix);
    
    if(!BaflUtils::FileExists(iRFs, iRecFileName)
	    || !BaflUtils::FileExists(iRFs, iRecFileName2))
    	{
        BaflUtils::EnsurePathExistsL(iRFs, iRecFileName);

        ReplaceAllRecFilesL();
    	}
    /*
    iRecFile.Close();
    if(KErrNone == iRecFile.Open(iRFs, iRecFileName2, EFileRead | EFileWrite))
        {
        iRecFile.Close();
        if(KErrNone == iRecFile.Open(iRFs, iRecFileName, EFileRead | EFileWrite))
            {
            iRecFile.Close();
            return;
            }
        }
    //*/

    /*
    iRecFile.Close();
    User::LeaveIfError(
        iRecFile.Replace(iRFs, iRecFileName2, EFileRead | EFileWrite));
    iRecFile.Close();
    User::LeaveIfError(
        iRecFile.Replace(iRFs, iRecFileName, EFileRead | EFileWrite));
    //*/
    }

void CGnHDRec::OpenRecFileL(const TDesC & aRecFileName)
{
    iRecFileName = aRecFileName;
    iRecFileName2 = aRecFileName;
    iRecFileName2.Append(KGnHDRecSuffix);

    /*
    iRecFile.Close();
    User::LeaveIfError(iRecFile.Open(iRFs, iRecFileName2, EFileRead | EFileWrite));
    iRecFile.Close();
    User::LeaveIfError(iRecFile.Open(iRFs, iRecFileName, EFileRead | EFileWrite));
    iRecFile.Close();
    //*/
    if(!BaflUtils::FileExists(iRFs, iRecFileName)
	    || !BaflUtils::FileExists(iRFs, iRecFileName2))
    	{
    	User::Leave(KErrNotFound);
    	}
}

const TDesC & CGnHDRec::GetRecFileName() const
{
    return iRecFileName;
}


TInt32 CGnHDRec::GetPositionPreTimeL(const TDesC8 & aUri)
{
    TInt32 position = -1;

    RFileReadStream rStream;
    User::LeaveIfError(rStream.Open(iRFs, iRecFileName, EFileRead));
    CleanupClosePushL(rStream);

    iIndex = FindIndexL(rStream, aUri);
    
    CleanupStack::PopAndDestroy(); // rStream
    
    if(iIndex >= 0) // catched
        {
        User::LeaveIfError(rStream.Open(iRFs, iRecFileName2, EFileRead));
        CleanupClosePushL(rStream);

        TRAPD(err, position = InternalizeNextTInt32L(rStream, iIndex); );
        CleanupStack::PopAndDestroy(); // rStream
        if(err != KErrNone)
            {
            position = -1;
            ResetL();
            }
        }
        
    return position;
}


void CGnHDRec::UpdateRecPosL(CGnHDRecFmt & aGnHDRecFmt)
{
    RFileReadStream rStream;
    
    User::LeaveIfError(rStream.Open(iRFs, iRecFileName2, EFileRead));
    CleanupClosePushL(rStream);
    RArray<TInt32> posList = InternalizeAllTInt32L(rStream);
    CleanupStack::PopAndDestroy(); // rStream
    
    RFileWriteStream wStream;
    //User::LeaveIfError(
    //    wStream.Open(iRFs, iRecFileName, EFileRead|EFileWrite));
    //CleanupClosePushL(wStream);
    
    if(iIndex >= 0) // catched
        {
        posList[iIndex] = aGnHDRecFmt.iPoint;
        }
    else // not be catched
        {
        posList.InsertL(aGnHDRecFmt.iPoint, 0);
        User::LeaveIfError(rStream.Open(iRFs, iRecFileName, EFileRead));
        CleanupClosePushL(rStream);
        CDesC8Array * desList = InternalizeAllDesL(rStream);
        CleanupStack::PopAndDestroy(); // rStream

        desList->InsertL(0, aGnHDRecFmt.iUri);
        
        User::LeaveIfError(
            wStream.Open(iRFs, iRecFileName, EFileRead|EFileWrite));
        CleanupClosePushL(wStream);
        ExternalizeAllDesL(wStream, *desList);
        CleanupStack::PopAndDestroy(); // wStream
        iIndex = 0;
        }
    User::LeaveIfError(
        wStream.Open(iRFs, iRecFileName2, EFileRead|EFileWrite));
    CleanupClosePushL(wStream);
    ExternalizeAllTInt32L(wStream, posList);
    CleanupStack::PopAndDestroy(); // wStream
}

void CGnHDRec::DeleteRecAndCloseL()
{
    if(iIndex >= 0)
    {
        RFileReadStream rStream;
        RFileWriteStream wStream;

        // for position
        // read
        User::LeaveIfError(rStream.Open(iRFs, iRecFileName2, EFileRead));
        CleanupClosePushL(rStream);
        RArray<TInt32> posList = InternalizeAllTInt32L(rStream);
        CleanupStack::PopAndDestroy(); // rStream
        posList.Remove(iIndex);
        // write
        User::LeaveIfError(
            wStream.Open(iRFs, iRecFileName2, EFileRead));
        CleanupClosePushL(wStream);
        ExternalizeAllTInt32L(wStream, posList);
        CleanupStack::PopAndDestroy(); // wStream

        // for uri
        // read
        User::LeaveIfError(rStream.Open(iRFs, iRecFileName, EFileRead));
        CleanupClosePushL(rStream);
        CDesC8Array * desList = InternalizeAllDesL(rStream);
        CleanupStack::PopAndDestroy(); // rStream
        desList->Delete(iIndex);
        // write
        User::LeaveIfError(
            wStream.Open(iRFs, iRecFileName, EFileRead|EFileWrite));
        CleanupClosePushL(wStream);
        ExternalizeAllTInt32L(wStream, posList);
        CleanupStack::PopAndDestroy(); // wStream
            
        iIndex = -1;
    }
}

void CGnHDRec::RemoveUriInfoFromRecL(const TDesC8 & aUri)
{
    RFileReadStream rStream;
    User::LeaveIfError(rStream.Open(iRFs, iRecFileName, EFileRead));
    CleanupClosePushL(rStream);

    TInt index = FindIndexL(rStream, aUri);
    
    CleanupStack::PopAndDestroy(); // rStream

    if(index > 0)
        {
        RFileReadStream rStream;
        RFileWriteStream wStream;

        // for position
        // read
        User::LeaveIfError(rStream.Open(iRFs, iRecFileName2, EFileRead));
        CleanupClosePushL(rStream);
        RArray<TInt32> posList = InternalizeAllTInt32L(rStream);
        CleanupStack::PopAndDestroy(); // rStream
        posList.Remove(index);
        // write
        User::LeaveIfError(
            wStream.Open(iRFs, iRecFileName2, EFileRead));
        CleanupClosePushL(wStream);
        ExternalizeAllTInt32L(wStream, posList);
        CleanupStack::PopAndDestroy(); // wStream

        // for uri
        // read
        User::LeaveIfError(rStream.Open(iRFs, iRecFileName, EFileRead));
        CleanupClosePushL(rStream);
        CDesC8Array * desList = InternalizeAllDesL(rStream);
        CleanupStack::PopAndDestroy(); // rStream
        desList->Delete(index);
        // write
        User::LeaveIfError(
            wStream.Open(iRFs, iRecFileName, EFileRead|EFileWrite));
        CleanupClosePushL(wStream);
        ExternalizeAllTInt32L(wStream, posList);
        CleanupStack::PopAndDestroy(); // wStream
        }
}

CGnHDRec::~CGnHDRec()
    {
    iRecFile.Close();
    iRFs.Close();
    }

void CGnHDRec::ResetL()
{
    iIndex = -1;
    ReplaceAllRecFilesL();
}

void CGnHDRec::ReplaceAllRecFilesL()
{
    iRecFile.Close();
    User::LeaveIfError(
        iRecFile.Replace(iRFs, iRecFileName2, EFileRead | EFileWrite));
    iRecFile.Close();
    User::LeaveIfError(
        iRecFile.Replace(iRFs, iRecFileName, EFileRead | EFileWrite));
    iRecFile.Close();
}

TInt CGnHDRec::FindIndexL(RReadStream & aStream, const TDesC8 & aUri)
{
    //HBufC8 * tempHBuf = HBufC8::NewLC(255);
    TBuf8<255>  * tempHBuf = new (ELeave) TBuf8<255>();
    CleanupDeletePushL(tempHBuf);
    
    TInt index = 0;
    
    TInt err = KErrNone;
  TRAP(err, 
    while(KErrNone == err)
        {
        //aStream>>(tempHBuf->Des());
        aStream>>(*tempHBuf);
        if( (*tempHBuf) == aUri )
            {
            break;
            }
        index++;
        //RDebug::Print(temp);
        //RDebug::Printf("des=\"%s\",err=%d", temp.Ptr(), err);
        };
  );
    CleanupStack::PopAndDestroy(tempHBuf); tempHBuf = NULL;
    
    if(err != KErrNone)
        {
        index = -1;
        
        if(err != KErrEof)
            User::Leave(err);
        }
    return index;
}

TInt32 CGnHDRec::InternalizeNextTInt32L(RReadStream & aStream, TInt aIndex)
{
    TInt32 value = -1;
  //TRAPD(err, 
    for(TInt i = 0; i <= aIndex; i++)
        {
        aStream>>value;
        }
  //);
    //User::LeaveIfError(err);
    
    return value;
}

RArray<TInt32> CGnHDRec::InternalizeAllTInt32L(RReadStream & aStream)
{
    RArray<TInt32> list;
    TInt32 value = -1;
  TRAPD(err,
    while(ETrue)
    {
        aStream>>value;
        list.AppendL(value);
    };
  );
    if(err != KErrEof)
        User::Leave(err);

    return list;
}

CDesC8Array * CGnHDRec::InternalizeAllDesL(RReadStream & aStream)
{
    CDesC8Array * list = new (ELeave) CDesC8ArraySeg(20);
    CleanupStack::PushL(list);

    //HBufC8 * tempBuf = HBufC8::NewLC(255);
    TBuf8<255>  * tempBuf = new (ELeave) TBuf8<255>();
    CleanupDeletePushL(tempBuf);
    
  TRAPD(err, 
    while(ETrue)
        {
        aStream>>(*tempBuf);
        list->AppendL(*tempBuf);
        };
  );
    CleanupStack::PopAndDestroy(tempBuf); tempBuf = NULL;
    
    if(err != KErrEof)
        User::Leave(err);
    
    CleanupStack::Pop(list);
    return list;
}

void CGnHDRec::ExternalizeAllTInt32L(RWriteStream & aStream, RArray<TInt32> & aList)
{
    TInt count = aList.Count();
    for(TInt i = 0; i < count; i++)
    {
        aStream<<aList[i];
    }
    aStream.CommitL();
}

void CGnHDRec::ExternalizeAllDesL(RWriteStream & aStream, CDesC8Array & aList)
{
    TInt count = aList.MdcaCount();
    //TInt count = aList.Count(); is ok too
    //RDebug::Printf("MdcaCount=%d, Count=%d", count, count1);
    RDebug::Printf("MdcaCount=%d", count);
    
    for(TInt i = 0; i < count; i++)
    {
        aStream<<aList[i];
    }
    aStream.CommitL();
}

CGnHDRec::CGnHDRec()
    {
    // No implementation required
    }


void CGnHDRec::ConstructL()
    {
    iRFs.Connect();
    iIndex = -1;
    }