/*
* 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 JAR file for JAD file
*
*/


#include <apmstd.h>
#include "appmngr2midletmanifestreader.h"
#include "javacommonutils.h"
#include "jcfjadjarmatcherscanjarfiles.h"
#include "logger.h"

_LIT(KSearchMask, "*.*");
_LIT(KJarExt, ".jar");

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


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


// ---------------------------------------------------------------------------
//    To execute this state. This method starts long running task,
//    which seeks JAR files and does JAD/JAR matching for them.
// -----------------------------------------------------------------------------
void CJcfJadJarMatcherScanJarFiles::ExecuteL(const TDesC& aJadName,
        const TDesC& aDirName,
        TDes* aJarNamePtr)
{
    JELOG2(EJavaStorage);

    Cleanup();

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

    reader->ReadManifestL(aJadName, iAttributes);

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

    TPtrC jadName = aJadName.Mid(slashOffset, (postfixOffset-slashOffset));

    iFullJadName.reset(jadName.Alloc());

    iDir = aDirName.AllocL();
    iJarFileNamePtr = aJarNamePtr;

    iState = EOpenJadFile;
    SetObjectActive();
}


// ---------------------------------------------------------------------------
//    To match JAR and JAD files. This method seeks JAR files from
//    given directory. If matching JAR file is found, then notification is sent
//    to the observer of this object and execution of this active object is
//    stopped. Otherwise if matching JAR 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 iff 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 CJcfJadJarMatcherScanJarFiles::RunL()
{
    switch (iState)
    {
        // EOpenJadFile Preconditions. - Successfull call of Cleanup().
        // Postconditions. - iFl is initialized.
    case EOpenJadFile:
    {
        TParsePtrC parse(iDir->Des());
        TPtrC drive = parse.Drive();

        // Check whether drive is specified (absolute path) or not
        // (relative path).
        iIsAbsolute = (0 != drive.Length());

        if (iIsAbsolute)
        {
            User::LeaveIfError(iFf.FindWildByDir(
                                   KSearchMask, parse.DriveAndPath(), iFl));
        }
        else
        {
            User::LeaveIfError(iFf.FindWildByDir(
                                   KSearchMask, parse.Path(), iFl));
        }

        // Start scanning loop.
        iIndex = 0;
        iAdHocGuess = ETrue;
        iState = EScanJarFile;
        SetObjectActive();
        break;
    }

    // EScanJarFile Preconditions. - iFl is initialized. Postconditions. -
    // One file is checked whether it matches or not.
    case EScanJarFile:
        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.
            TBool  foundMatchingJar = EFalse;
            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;
                TInt index = 0;

                // 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));
                        TPtrC jadName(iFullJadName->Des());

                        if (0 == jadName.Compare(name))
                        {
                            // The beginning of the file name matches,
                            // but is the suffix ".jar" ?
                            TPtrC suffix((*iFl)[index].iName.Mid(offset));
                            if (0 == suffix.CompareF(KJarExt))
                            {
                                foundMatchingJar = ETrue;
                                break;
                            }
                        }
                    }
                }

                if (foundMatchingJar)
                {
                    namePtr.Append((*iFl)[index].iName);
                }
                else
                {
                    namePtr.Append((*iFl)[iIndex++].iName);
                }
            }
            else
            {
                namePtr.Append((*iFl)[iIndex++].iName);
            }

            TParsePtrC absName(*nameBuf);

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

            RPointerArray<Java::MJavaAttribute>jarAttributes;

            TRAPD(parseErr, reader->ReadManifestL(namePtr, jarAttributes));

            if (KErrNone == parseErr)
            {
                if (Match(iAttributes, jarAttributes))
                {
                    LOG(EJavaStorage, EInfo, "JAR and JAD match");
                    iJarFileNamePtr->SetLength(0);
                    iJarFileNamePtr->Append(namePtr);

                    iValue = KErrNone;
                    iState = EEnd;
                }
            }
            jarAttributes.ResetAndDestroy();
            SetObjectActive();
        }
        else
        {
            delete iFl;
            iFl = NULL;

            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 JAR
//    file scanning.
// -----------------------------------------------------------------------------
void CJcfJadJarMatcherScanJarFiles::DoCancel()
{
    NotifyObserver(KErrCancel);
    Cleanup();
}


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

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

    iState = EBegin;
}