/*
* Copyright (c) 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: Juha Kauppinen, Mika Hokkanen
* 
* Description: Photo Browser
*
*/

// Include files

#include <bautils.h>
#include <IEBgpsInfo.h>


#include "IEEngineImp.h"
#include "IEFileLoader.h"
#include "IEImageFinder.h"
#include "ImageMonitorAO.h"

#ifdef _S60_5x_ACCELEROMETER_
#include "IESensorMonitor.h"
#endif

#define IMAGEFINDERMONITORAO

//_LIT(KFacesPath, "ImagicFaces");


CIEFileLoader* CIEFileLoader::NewL(
        RFs& aFileServer, 
        CIEEngineImp* aEngImp, 
        RCriticalSection* aCritical/*, TRequestStatus& aStatus*/)
    {
    DP0_IMAGIC(_L("CIEFileLoader::NewL++"));
    
	CIEFileLoader* self = new (ELeave) CIEFileLoader(aFileServer, aEngImp, aCritical/*, aStatus*/);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	DP0_IMAGIC(_L("CIEFileLoader::NewL--"));
	return self;
    }

CIEFileLoader::~CIEFileLoader()
    {
    DP0_IMAGIC(_L("CIEFileLoader::~CIEFileLoader++"));
    
    // Save database file if needed
    if (iImageList)
        TRAP_IGNORE(iImageList->WriteDatabaseL());
    
   	DP0_IMAGIC(_L("CIEFileLoader::~CIEFileLoader 1"));
#ifdef IMAGEFINDERMONITORAO
   	if(iImageFinderMonitor->IsActive())
   	    {
   	    DP0_IMAGIC(_L("CIEFileLoader::~CIEFileLoader 1.1"));
   	    iImageFinderMonitor->Cancel();
   	    }
   	
   	DP0_IMAGIC(_L("CIEFileLoader::~CIEFileLoader 2"));
   	delete iImageFinderMonitor;
   	iImageFinderMonitor = NULL;
#endif
   	
	// The object is created in ThreadEngine CreateThreadsL().
    // This is done because thread1 needs to cleanup before killing
    // the thread.
	iImageFinderThread->Stop();
	delete iImageFinderThread;
	iImageFinderThread = NULL;
	DP0_IMAGIC(_L("CIEFileLoader::~CIEFileLoader 3"));

	for(TInt i = 0;i < iFileNameData.Count();i++)
	    delete iFileNameData[i];
	
    for(TInt i = 0;i < iFaceFilenameData.Count();i++)
        delete iFaceFilenameData[i];
        
    iFileNameData.Reset();
    iFileNameData.Close();
    
    iFaceFilenameData.Reset();
    iFaceFilenameData.Close();
    
    delete iImageList;
	
	//delete iFileSystemMonitor;
	DP0_IMAGIC(_L("CIEFileLoader::~CIEFileLoader--"));
    }

CIEFileLoader::CIEFileLoader(
        RFs& aFileServer, 
        CIEEngineImp* aEngImp, 
        RCriticalSection* aCritical) :
        iFileServer(aFileServer),
        iEngImp(aEngImp),
        iCritical(aCritical)
    {
          
    }

void CIEFileLoader::ConstructL()
    {
    DP0_IMAGIC(_L("CIEFileLoader::ConstructL++"));
    
	iCurrentFileIndex = 0;
	//iJpgFileCountingComplete = EFalse;
	iImageFinderState = EImageFinderRunning;

	iImageList = CIEImageList::NewL(iFileNameData, this);
	
	TFileName rootPath;
    
	//iFileSystemMonitor = FileSystemMonitorAO::NewL(iFileServer, this);
	//iFileSystemMonitor->StartMonitoring();
#ifdef IMAGEFINDERMONITORAO		
	iImageFinderMonitor = CImageMonitorAO::NewL(iEngImp);
	iImageFinderMonitor->iStatus = KRequestPending; 
	iImageFinderMonitor->ActiveRequest();
#endif    
	//Create and start ImageFinder thread
	iImageFinderThread = CFileFinderThread::NewL(
	        this, 
	        iFileNameData, 
	        iFaceFilenameData, 
	        iCritical, 
	        rootPath);

	iImageFinderThread->StartL();
	
	iMainThreadId = RThread().Id();
	
	DP0_IMAGIC(_L("CIEFileLoader::ConstructL--"));
}

CIEFileLoader::TImageFinderState CIEFileLoader::ImageFinderState() const
    {
    return iImageFinderState;
    //return (iImageFinderThread != NULL);
    }

CIEImageList& CIEFileLoader::GetImageList()
    {
    return *iImageList;
    }

void CIEFileLoader::StopImageFinder()
    {
    DP0_IMAGIC(_L("CIEFileLoader::Stop++"));
    if (iImageFinderState == EImageFinderRunning)
        iImageFinderState = EImageFinderStopping;
    DP0_IMAGIC(_L("CIEFileLoader::Stop--"));
    }

void CIEFileLoader::ImageFinderStopped()
    {
    iImageFinderState = EImageFinderStopped;
    }

void CIEFileLoader::ImageListChanged(TInt aIndex, TBool aAdded) 
    {
    iEngImp->GetObserver().ImageListChanged(aIndex, aAdded);
    }

/* Added new image */
void CIEFileLoader::AddNewImage(CImageData* aTmpImageData, TInt aImageIndex)
    {
    //Insert new image data to filename array
    iFileNameData.Insert(aTmpImageData, aImageIndex);
    }   

/* Added new image */
void CIEFileLoader::AddNewFaceCropImage(CImageData* aTmpImageData, TInt aImageIndex)
    {
    
    //Insert new image data to filename array
    aTmpImageData->iGridData.iCorrupted = EFalse;
    aTmpImageData->iGridData.iRotationAngle = 0;//rotation angle of one image
    aTmpImageData->iGridData.iTargetRotationAngle = 0;//target rotation angle of one image
    aTmpImageData->iGridData.iX = aTmpImageData->iGridData.iY = aTmpImageData->iGridData.iZ = 0;//OpenGL Z coord
    aTmpImageData->iGridData.iScale = 0;//OpenGL iScale
    aTmpImageData->iGridData.iGlLQ32TextIndex = 0;//OpenGL 32x32 texture index
    aTmpImageData->iGridData.iGlLQ128TextIndex = 0;//OpenGL 128x128 texture index
    aTmpImageData->iGridData.iGlHQ512TextIndex = 0;//OpenGL 512x512 texture index
    aTmpImageData->iGridData.iGlSuperHQTextIndex = 0;//OpenGL 2048x2048 texture index
    
    iFaceFilenameData.Insert(aTmpImageData, aImageIndex);
    }   


/*
void CIEFileLoader::StartFileSystemMonitoring()
    {
    //iFileSystemMonitor->StartMonitoring();    
    }

void CIEFileLoader::StopFileSystemMonitoring()
    {
    //iFileSystemMonitor->StopMonitoring();    
    }

void CIEFileLoader::FileSystemChanged()
    {
    
    }
*/
CIEEngineImp* CIEFileLoader::GetEngineImpPtr()
    {
    return iEngImp;
    }
    
void CIEFileLoader::ModifyImageData(CImageData* aTmpImageData, TInt aImageIndex)
    {
    //Insert new image data to filename array
    iFileNameData[aImageIndex] = aTmpImageData;
    }


/* All files are added to fine name array */
void CIEFileLoader::AllFilesAddedToFilenameArray()
    {
#ifdef IMAGEFINDERMONITORAO        
    TRequestStatus* status = &iImageFinderMonitor->iStatus;
    RThread mainThread;
    mainThread.Open( iMainThreadId );
    mainThread.RequestComplete( status, KErrNone );
#else    
    iEngImp->AllFilesAddedToFilenameArrayL();
#endif    
    DP0_IMAGIC(_L("CIEFileLoader::AllFilesAddedToFilenameArray 1"));
    //JPG File counting completed
    //iJpgFileCountingComplete = ETrue;
    
    }

//Only used for getting number of TNs in file system 
#if 0
void CIEFileLoader::SearchFileCountL(const TDesC& aRootPath, const TDesC& aSearchName, TInt& aImageFileCount, TInt& aFacesFileCount)
    {
    DP0_IMAGIC(_L("CIEFileLoader::SearchFileCountL++"));
    TInt error = KErrNone;
    TInt tnFileCount = 0;
    
    CDirScan* dirScan = CDirScan::NewL(iFileServer);
    dirScan->SetScanDataL(aRootPath, KEntryAttDir|KEntryAttMatchExclusive, ESortNone, CDirScan::EScanDownTree);
    
    while(1)
        {
         CDir* dir = NULL;
         dirScan->NextL(dir);
         
         if(error || !dir)
          break;
         
         delete dir;
         
         TBool isFace = EFalse;
         TPtrC FacesDir = dirScan->FullPath();
         if(FacesDir.Find(KFacesPath) != KErrNotFound)
             {
             aFacesFileCount += ScanDirFileCountL(dirScan->FullPath(), aSearchName);    
             }
         else
             {
             aImageFileCount += ScanDirFileCountL(dirScan->FullPath(), aSearchName);    
             }
         } 
    
    delete dirScan;
    dirScan = NULL;
    
    DP0_IMAGIC(_L("CIEFileLoader::SearchFileCountL--"));
    }


//Only used for getting number of TNs in file system
TInt CIEFileLoader::ScanDirFileCountL(const TDesC& aDir, const TDesC& aWild)
{
    DP0_IMAGIC(_L("CIEFileLoader::ScanDirFileCountL++"));
    TParse parse;
    TInt count = 0;
    
    parse.Set(aWild, &aDir, NULL);
    TPtrC spec(parse.FullName());

    TFindFile findFile(iFileServer);
    CDir* dir;
    
    if (!findFile.FindWildByPath(parse.FullName(), NULL, dir))
    {
        CleanupStack::PushL(dir);
        
        count = dir->Count(); 

        CleanupStack::PopAndDestroy(dir);
    }
 
    return count;

}
#endif

/* Deleting all corresponding Thumbnails including Gallery TNs */
TInt CIEFileLoader::DeleteFile(TInt aIndex)
    {
    TInt err = KErrNotFound;
    if(aIndex < iFileNameData.Count())
        {
        err = DeleteFile(iFileNameData[aIndex]);
    
        if (err == KErrNone)
            {
            CImageData* imageData = iFileNameData[aIndex];
            iFileNameData.Remove(aIndex);
            delete imageData;
            iNumberOfImages = iFileNameData.Count();
            }
        }
    return err;
    }

TInt CIEFileLoader::DeleteFile(const CImageData* aImageData)
    {
    TFileName fileName;
    TInt err = KErrNone;

    if(aImageData->IsImageReady(EFullSize))
        {
        aImageData->GetFileName(fileName, EFullSize);            
        TInt err = iFileServer.Delete(fileName);
        if (err != KErrNone)
            return err;
        }
    
    //Here if condition is not required. If the file does not exists
    //then it returns not found system error code ?
    //There is no value addition for extra check any way we have to remove
    // that index from the array...( Cross check)
    if(aImageData->IsImageReady(ESize128x128)) 
        {
        aImageData->GetFileName(fileName, ESize128x128);
        iFileServer.Delete(fileName);
        }
        
    if(aImageData->IsImageReady(ESize512x512))
        {
        aImageData->GetFileName(fileName, ESize512x512);        
        iFileServer.Delete(fileName);
        }
            
    if(aImageData->IsImageReady(ESize32x32))
        {
        aImageData->GetFileName(fileName, ESize32x32);
        iFileServer.Delete(fileName);
        }
    
    // Delete standard gallery thumbnail files
    TFileName path, imageName;
    aImageData->GetPath(path);
    aImageData->GetFileName(imageName);
    
    const TPtrC thumbPaths[] = { 
        _L("_PAlbTN\\320x320\\"), _L("_320x320"),
        _L("_PAlbTN\\320x240\\"), _L(""),
        _L("_PAlbTN\\170x128\\"), _L("_170x128"),        
        _L("_PAlbTN\\"), _L("_128x96"),
        _L("_PAlbTN\\64x64dat\\"), _L(""),
        _L("_PAlbTN\\56x42\\"), _L("_56x42")
    };
    
    for (TInt i = 0;i < sizeof(thumbPaths) / sizeof(TPtrC) ;i+=2)
        {
        fileName = path;
        fileName.Append(thumbPaths[i]);
        fileName.Append(imageName);
        fileName.Append(thumbPaths[i + 1]);
        iFileServer.Delete(fileName);
        }

    return err;
    }

/* Deleting all corresponding Thumbnails including Gallery TNs */
TInt CIEFileLoader::DeleteFaceFile(TInt aIndex)
    {
    TInt err = KErrNotFound;
    if(aIndex < iFaceFilenameData.Count())
        {
        //Here if condition is not required. If the file does not exists
        //then it returns not found system error code ?
        //There is no value addition for extra check any way we have to remove
        // that index from the array...( Cross check)
        err = DeleteFile(iFaceFilenameData[aIndex]);
        CImageData* imageData = iFaceFilenameData[aIndex];
        iFaceFilenameData.Remove(aIndex);
        delete imageData;
        iNumberOfFaces = iFaceFilenameData.Count();
        }
    return err;
    }

 
RArray<CImageData*>& CIEFileLoader::GetFileNameArray()
{
    return iFileNameData;
}

RArray<CImageData*>& CIEFileLoader::GetFacesFileNameArray()
{
    return iFaceFilenameData;
}

TInt CIEFileLoader::GetTotalNumOfImages()
{
    //return iNumberOfImages;
    return iFileNameData.Count();
}

void CIEFileLoader::GetTotalNumOfImages(TInt& aNumOfImages, TInt& aNumOfFaces)
    {
    aNumOfImages = iFileNameData.Count();
    aNumOfFaces = iFaceFilenameData.Count();
    }

void CIEFileLoader::GetUpdatedNumOfImages(TInt& aNumOfImages, TInt& aNumOfFaces)
    {
    aNumOfImages = iFileNameData.Count();
    aNumOfFaces = iFaceFilenameData.Count();
    }

void CIEFileLoader::GetFileNameL(TInt aFileIndex, TFileName& aFileName, TThumbSize aThumbRes)
{
	if(aFileIndex < 0 || aFileIndex > iFileNameData.Count())
	    {
		User::Leave(KErrArgument);
	    }
	else
	    {
        iFileNameData[aFileIndex]->GetFileName(aFileName, aThumbRes);
    	}
}

/*CImageData* CIEFileLoader::GetImageData(TInt aIndex)
    {
    return (aIndex < iFileNameData.Count()) ? iFileNameData[aIndex] : NULL;
    }*/

CImageData* CIEFileLoader::GetImageData(TInt aIndex/*, TImageArrayMode aMode*/)
    {
    return (aIndex >= 0 && aIndex < iFileNameData.Count()) ? iFileNameData[aIndex] : NULL;
    }

void CIEFileLoader::SetImageData(TInt aIndex, CImageData* aGridData)
    {
    if(aIndex < iFileNameData.Count())
        iFileNameData[aIndex] = aGridData;
    }

#ifdef _ACCELEROMETER_SUPPORTED_
TImagicDeviceOrientation CIEFileLoader::DeviceOrientation()
    {
    return iEngImp->GetDeviceOrientation();
    }
#endif

// EOF