/*
* Copyright (c) 2005-2006 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 class is used to find matching JAD file for given JAR
*                file.
*
*/


#include "appmngr2midletmanifestreader.h"
#include "javacommonutils.h"
#include "jcfjadjarmatcherscanjadfiles.h"
#include "logger.h"

_LIT(KJadMask, "*.jad");

// ---------------------------------------------------------------------------
//    To construct new CJcfJadJarMatcherScanJadFiles.
// -----------------------------------------------------------------------------
CJcfJadJarMatcherScanJadFiles::CJcfJadJarMatcherScanJadFiles(
    MJcfJadJarMatcherObserver*  aObs, RFs&  aFs) :
        CJcfJadJarMatcherState(aObs),
        iFf(aFs),
        iFs(aFs)
{
}


// ---------------------------------------------------------------------------
//    To destruct CJcfJadJarMatcherScanJadFiles. Cancel any
//    outstanding request. Delete all C-objects owned by this object.
// -----------------------------------------------------------------------------
CJcfJadJarMatcherScanJadFiles::~CJcfJadJarMatcherScanJadFiles()
{
    Cancel();
    Cleanup();
}


// ---------------------------------------------------------------------------
//    To execute this state. This method starts long running task,
//    which seeks JAD files and does JAD/JAR matching for them. Make clean-up.
//    Open JAR file asynchronously. Set new state.
// -----------------------------------------------------------------------------
void CJcfJadJarMatcherScanJadFiles::ExecuteL(const TDesC& aJarName,
        const TDesC& aDirName,
        TDes* aJadNamePtr)
{
    JELOG2(EJavaStorage);
    Cleanup();

    std::auto_ptr<AppMngr2MidletManifestReader> reader(
        new(ELeave) AppMngr2MidletManifestReader(iFs));

    reader->ReadManifestL(aJarName, iAttributes);

    iIndex = 0;
    iDir = aDirName.AllocL();

    // Take only name without path and postfix.
    TInt postfixOffset = aJarName.LocateReverse('.');
    TInt slashOffset = aJarName.LocateReverse('\\');
    ++slashOffset;

    TPtrC jarName = aJarName.Mid(slashOffset, (postfixOffset-slashOffset));

    iFullJarName.reset(jarName.Alloc());
    iJadFileNamePtr = aJadNamePtr;

    iState = EOpenJarFile;
    SetObjectActive();
}


// ---------------------------------------------------------------------------
//    To match JAR and JAD files. This method seeks JAD files from
//    given directory. If matching JAD file is found, then notification is sent
//    to the observer of this object and execution of this active object is
//    stopped. Otherwise if matching JAD file is not found and relative path
//    (without driver) is defined, method starts to seek the file from same
//    directory in different driver. All available drivers searched in
//    descenting order: Y: -> A: and finally Z:. The JAD file 'jad' and the JAR
//    file 'jar' is said to be matching if Match('jad', 'jar') == true
//    Otherwise files are said to be unmatching. This method is assumed to be
//    long running. When all directories are scanned, complete notification
//    (KErrNotFound) is sent.
// -----------------------------------------------------------------------------
void CJcfJadJarMatcherScanJadFiles::RunL()
{
    switch (iState)
    {
        // EOpenJarFile Preconditions. - Successfull call of Cleanup().
        // Postconditions. - iFl is initialized.
    case EOpenJarFile:
        if (KErrNone == iStatus.Int())
        {
            TParsePtrC parse(iDir->Des());
            TPtrC drive = parse.Drive();
            iIsAbsolute = (0 != drive.Length());

            // Check whether a drive is specified (absolute path) or not
            // (relative path).
            if (iIsAbsolute)
            {
                TPtrC path = parse.DriveAndPath();
                User::LeaveIfError(iFf.FindWildByDir(KJadMask, path, iFl));
            }
            else
            {
                TPtrC path = parse.Path();
                User::LeaveIfError(iFf.FindWildByDir(KJadMask, path, iFl));
            }

            // Start scanning loop.
            iIndex = 0;
            iAdHocGuess = ETrue;
            iState = EScanJadFile;
        }
        else
        {
            iValue = KErrArgument;
            iState = EEnd;
        }

        SetObjectActive();
        break;

        // EScanJadFile Preconditions. - iFl is initialized. Postconditions. -
        // One file is checked whether it matches or not.
    case EScanJadFile:
        if (iIndex < iFl->Count())
        {
            // Generate a name for a file to be opened next. An ad hoc
            // guess is that it's likely that the matching file has same
            // name as the argument. If the guess is right, the whole
            // matching is very fast. On the other hand if the guess is
            // wrong, the only penalty is that one file is matched twice.
            std::auto_ptr<HBufC>nameBuf(HBufC::NewL(KMaxFileName));
            TPtr namePtr(nameBuf->Des());
            TParsePtrC driveAndPath(iFf.File());
            namePtr.Append(driveAndPath.Drive());
            namePtr.Append(driveAndPath.Path());

            if (iAdHocGuess)
            {
                iAdHocGuess = EFalse;
                TBool find = EFalse;
                TInt index = 0;
                TParsePtrC argName(*iFullJarName);

                // Check (case-sensitive) the names in the file list.
                for (; index < iFl->Count(); index++)
                {
                    TInt offset = (*iFl)[index].iName.LocateReverse('.');
                    if (KErrNotFound != offset)
                    {
                        TPtrC name((*iFl)[index].iName.Left(offset));
                        if (0 == argName.Name().Compare(name))
                        {
                            find = ETrue;
                            break;
                        }
                    }
                }

                if (find)
                {
                    namePtr.Append((*iFl)[index].iName);
                }
                else
                {
                    namePtr.Append((*iFl)[iIndex++].iName);
                }
            }
            else    // !iAdHocGuess
            {
                namePtr.Append((*iFl)[iIndex++].iName);
            }

            LOG1WSTR(EJavaStorage, EInfo, "Matching to jad file: %s",
                     (const wchar_t*)namePtr.PtrZ());

            // Parse JAD File attributes for the matching.
            std::auto_ptr<AppMngr2MidletManifestReader> reader(
                new(ELeave) AppMngr2MidletManifestReader(iFs));

            RPointerArray<Java::MJavaAttribute>jadAttributes;
            reader->ReadManifestL(namePtr, jadAttributes);

            if (Match(iAttributes, jadAttributes))
            {
                LOG(EJavaStorage, EInfo, "JAR and JAD match");
                iJadFileNamePtr->SetLength(0);
                iJadFileNamePtr->Append(namePtr);

                iValue = KErrNone;
                iState = EEnd;
            }

            jadAttributes.ResetAndDestroy();
            SetObjectActive();
        }
        else    // all entries in iF1 have scanned
        {
            delete iFl;
            iFl = NULL;

            // If path was absolute, there wasn't matching JAD file.
            if (iIsAbsolute || KErrNotFound == iFf.FindWild(iFl))
            {
                // End of loop.
                iValue = KErrNotFound;
                iState = EEnd;
            }

            iIndex = 0;
            iAdHocGuess = ETrue;
            SetObjectActive();
        }
        break;

        // EEnd Preconditions. - None. Postconditions. - Matching round is
        // completed. The ExecuteL() activates a new one
    case EEnd:
        Cleanup();
        NotifyObserver(iValue);
    }
}


// ---------------------------------------------------------------------------
//    To cancel this object activity. This method cancels the JAD
//    file scanning.
// -----------------------------------------------------------------------------
void CJcfJadJarMatcherScanJadFiles::DoCancel()
{
    NotifyObserver(KErrCancel);
    Cleanup();
}


// ---------------------------------------------------------------------------
//    To complete pending request and set this object active.
// -----------------------------------------------------------------------------
void CJcfJadJarMatcherScanJadFiles::SetObjectActive()
{
    TRequestStatus *status = &iStatus;
    User::RequestComplete(status, KErrNone);
    if (!IsActive())
    {
        SetActive();
    }
}


// ---------------------------------------------------------------------------
//    To do clean-up for next round.
// -----------------------------------------------------------------------------
void CJcfJadJarMatcherScanJadFiles::Cleanup()
{
    delete iDir;
    iDir = NULL;
    delete iFl;
    iFl = NULL;
    iFullJarName.reset(0);
    iAttributes.ResetAndDestroy();

    iState = EBegin;
}