// Copyright (c) 2005-2010 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:

// Name        : wfindfirst.cpp

// Part of     : libc library

// The _wfindfirst function provides information about the first 

// instance of a file name that matches the file specified in the 

// filespec argument. Any wildcard combination supported by the host 

// operating system can be used in filespec. 

// File information is returned in a _wfinddata_t structure, defined in wchar.h

// FUNCTIONS

// _wfindfirst, _wfindnext, _findclose

// INDEX

// _wfindfirst

// _wfindnext

// _findclose

// ANSI_SYNOPSIS

// #include <wchar.h>

// int _wfindnext(intptr_t, struct _wfinddata_t *); 

// intptr_t wfindfirst(const wchar_t* , struct _wfinddata_t* );

// int findclose( intptr_t handle);

// The _wfindfirst function provides information about the first 

// instance of a file name that matches the file specified in the 

// filespec argument. Any wildcard combination supported by the host 

// operating system can be used in filespec. 

// File information is returned in a _wfinddata_t structure, defined in wchar.h

// wfindnext find the next name, if any, that matches the filespec argument 

// in a previous call to _findfirst, and then alter the fileinfo structure 

// contents accordingly.

// _findclose  

// Closes the specified search handle and releases associated resources.

// RETURNS

// _findclose

// If successful, returns 0. Otherwise, it returns –1 and sets errno to ENOENT

// _wfindnext

// If successful, returns 0. Otherwise, returns –1 and sets errno to a value indicating the nature of the failure. Possible error codes are shown below. 

// EINVAL

// Invalid parameter: fileinfo was NULL. Or, the operating system returned an unexpected error.

// ENOENT

// No more matching files could be found.

// _wfindfirst

// If successful, _findfirst returns a unique search handle identifying the file or group of files

// matching the filespec specification, which can be used in a subsequent call to _findnext or to 

// _findclose. Otherwise, _findfirst returns –1 and sets errno to one of the following values.

// EINVAL

// Invalid parameter: filespec or fileinfo was NULL. Or, the operating system returned an unexpected error.

// ENOENT

// File specification that could not be matched.

// ENOMEM

// Not enough memory or the file name given was greater than MAX_PATH.

// EINVAL

// Invalid file name specification.

//

#include <stdlib.h>

#include <wchar.h>

#include <errno.h> 

#include "sysif.h"

#include<e32base.h>

#include<e32cmn.h>

#include<ltime.h>

#define MAXPATHLEN  260 

#define ATTMASK (_A_ARCH|_A_HIDDEN|_A_NORMAL|_A_RDONLY|_A_SYSTEM|_A_SUBDIR )

class CFindFileByPath : public CBase

    {

    public:

        CFindFileByPath(RFs& aFs) : iFinder(aFs),iLastCount(-1)

            {  

            }

        ~CFindFileByPath()

            {

            delete iDir;

            iDir = NULL;

            }

        const TEntry& Entry()

            {

            return (*iDir)[iLastCount];

            }

        TInt FindFirst(const TDesC&,const TDesC&);

        TInt FindNext();

    private:

        TFindFile iFinder;

        CDir* iDir;

        TInt iLastCount;

        TBuf<MAXPATHLEN> iPath;

    };

TInt CFindFileByPath::FindFirst(const TDesC &aPattern, const TDesC& aPath)

    {

    iPath = aPath;

    TInt ret = iFinder.FindWildByPath(aPattern,&iPath,iDir);

    if(ret != KErrNone)

        {

        return ret;

        }

    return FindNext();

    }

TInt CFindFileByPath::FindNext()

    {

    TInt count = iDir->Count();

//    Results from the search either in pattern path or in the cwd.

    if(++iLastCount<count)

        {

        return KErrNone;

        }

    return KErrNotFound;

    }

void UpdateFileInfo(struct _wfinddata_t* aFileinfo, CFindFileByPath& aFinder)

    {

    wcscpy(aFileinfo->name ,(wchar_t *)aFinder.Entry().iName.Ptr());

    TInt k = aFinder.Entry().iName.Size()/sizeof(wchar_t);

    aFileinfo->name[k] = L'\0';

    aFileinfo->size = aFinder.Entry().iSize;

    // Unmask unnecessary attributes in iAtt. 

    // All constant definitions are in sync with what is expected in finddata structure.

    aFileinfo->attrib = aFinder.Entry().iAtt;    

    aFileinfo->attrib &= (ATTMASK);

    time_t time_modify = as_time_t(aFinder.Entry().iModified); 

    aFileinfo->time_write = time_modify;

    aFileinfo->time_create = -1L;

    aFileinfo->time_access = -1L;

    }

extern "C" 

{

     //RFs FileServerSession ; 

EXPORT_C intptr_t wfindfirst(const wchar_t*  filespec, struct _wfinddata_t* fileinfo)

 {

   if(!filespec||!fileinfo)

   return EINVAL;

   long handle = -1;    

   wchar_t *dirf =(wchar_t*)malloc(MAXPATHLEN * sizeof(wchar_t)); // getting the cuurent directory

   wgetcwd(dirf,MAXPATHLEN);

   TPtrC16 dird((const TUint16*)dirf); // converting it into descriptor

   TPtrC16 fsd((const TUint16*)filespec );

   CFindFileByPath *temp1= new CFindFileByPath(Backend()->FileSession());    

   if(temp1== NULL)

       {

       return EINVAL;

       }

   int k = temp1->FindFirst(fsd,dird);

   if(k==KErrNone)

       {        

       UpdateFileInfo(fileinfo,*temp1);

       handle = reinterpret_cast<long>(temp1);

       }

   else

       {

        handle = -1;

        delete temp1;

        errno = ENOENT ;

       }

   delete dirf; // delete directory pointer 

   return handle;

 }

EXPORT_C intptr_t wfindnext(intptr_t handle, struct _wfinddata_t * fileinfo)

 {

        if((handle<=0)||!fileinfo)

    return EINVAL;  

    CFindFileByPath *temp1 = reinterpret_cast<CFindFileByPath *>(handle); 

    int k = temp1->FindNext();

    if(KErrNone==k)

    {

    UpdateFileInfo(fileinfo,*temp1);

    return 0;   

    }

    else 

    {

        errno = ENOENT ;

        return -1;

    }

 }

 EXPORT_C int findclose( intptr_t handle)

 {

    if(handle <=0)

    {

        errno = ENOENT ;

        return -1;

    }

    CFindFileByPath *temp1 = reinterpret_cast<CFindFileByPath *>(handle); 

    delete temp1;

    return 0;

  }

}