/*

* 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 "IEBgpsController.h"

#include "debug.h"

#include "ImagicConsts.h"

// ====================== MEMBER FUNCTION ================================== //

CIEBgpsController* CIEBgpsController::NewL(RFs& aFileServer,

                                        MIEBgpsControllerObserver& aIEBgpsControllerObserver, 

                                        CIEEngineUtils& aEngineUtils,

                                        RCriticalSection* aCritical)

    {

    CIEBgpsController* self = new (ELeave) CIEBgpsController(aFileServer,

                                                            aIEBgpsControllerObserver, 

                                                            aEngineUtils,

                                                            aCritical);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CIEBgpsController::CIEBgpsController(RFs& aFileServer, MIEBgpsControllerObserver& aIEBgpsControllerObserver, 

                                     CIEEngineUtils& aEngineUtils, RCriticalSection* aCritical)

    :iFileServer(aFileServer),

    iIEBgpsControllerObserver(aIEBgpsControllerObserver),

    iFileLoader(NULL),

    iIEEngineUtils(aEngineUtils),

    iCritical(aCritical)

    {

    }

CIEBgpsController::~CIEBgpsController()

    {

    DP0_IMAGIC(_L("CIEBgpsController::~CIEBgpsController++"));

    if(iIEBgpsClient)

        {

        delete iIEBgpsClient;

        iIEBgpsClient = NULL;    

        }

    iFaceCropImageDataArray.Close();

    iFBCoordinateArray.Close();

    DP0_IMAGIC(_L("CIEBgpsController::~CIEBgpsController--"));

    }

void CIEBgpsController::ConstructL()

    {

    DP0_IMAGIC(_L("CIEBgpsController::ConstructL++"));

    iImageIndex = 0;

    iSingleTNGeneration = EFalse;

    iTnCreationCancelled = EFalse;

    iAllTNsDone = EFalse;

    //iIEBgpsClient = CIEImageProcessing::NewL(*this);

    DP0_IMAGIC(_L("CIEBgpsController::ConstructL--"));

    }

void CIEBgpsController::SetFileLoader(CIEFileLoader* aFileLoader)

    {

    DP0_IMAGIC(_L("CIEBgpsController::SetFileLoader"));

    iFileLoader = aFileLoader;

    }

void CIEBgpsController::CreateImageProcessing()

    {

    DP0_IMAGIC(_L("CIEBgpsController::CreateImageProcessing"));

    iIEBgpsClient = CIEImageProcessing::NewL(*this);

    }

void CIEBgpsController::ThumbnailGenerationCompleted(TInt aErrorCode)

    {

    DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted++"));

    if (aErrorCode == KErrCancel)

        return;

    /*CImageData* imageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex, EImages);

    TFileName filename;

    imageData->GetFileName(filename, ESize512x512);

    DP1_IMAGIC(_L("CFaceBrowser::BrowseFacesL 512x512TNFile = %S ++"), &filename);*/

    //Single TN generation ----------->

    if(aErrorCode != KErrNone)

        {

        DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Error in TN creation: %d"), aErrorCode);

        CImageData* imageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex);

        //Mark image as corrupted so we do not try to generate TN or load it

        imageData->iGridData.iCorrupted = ETrue;

        //In Error case any way delete the iCorrupted Thumbnail + file we were trying to generate TN(if it is not original)

        if(!iSingleFaceDetectionOn)

            {

            DeleteCorruptedThumbNailFile(iTNFilename);

            if(iJpegFilename.Find(KPAlbTNFilePath) != KErrNotFound)

                {

                DeleteCorruptedThumbNailFile(iJpegFilename);

                }

            }

        }

    iSingleFaceDetectionOn = EFalse;

    //If no error mark that TN was created

    if(aErrorCode == KErrNone)

        {

        if(i512x512TNCreationOn)

            {

            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - i512x512TNCreationOn"));

            iImageDataArray[iTnCreationIndex]->iGridData.iCorrupted = EFalse;

            iImageDataArray[iTnCreationIndex]->SetImageReady(ESize512x512, ETrue);

            iIEBgpsControllerObserver.SingleTNGenerationComplete(iTnCreationIndex, ESize512x512);

/*#ifdef FACE_DETECTION

            TInt count = iFBCoordinateArray.Count();

            for(TInt i=0; i<count; i++)

                iFBCoordinateArray.Remove(0);

            iSingleFBCoordinateArray = &iFBCoordinateArray;

            iImageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex, EImages);

            iIEBgpsClient->StartSingleFaceDetection(iTnCreationIndex, *iSingleFBCoordinateArray, iImageData);

            iSingleFaceDetectionOn = ETrue;

#endif*/

            }

        if(i128x128TNCreationOn)

            {

            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - i128x128TNCreationOn"));

            iImageDataArray[iTnCreationIndex]->SetImageReady(ESize128x128, ETrue);

            iIEBgpsControllerObserver.SingleTNGenerationComplete(iTnCreationIndex, ESize128x128);

            }

        if(i32x32TNCreationOn)

            {

            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - i32x32TNCreationOn"));

            iImageDataArray[iTnCreationIndex]->SetImageReady(ESize32x32, ETrue);

            iIEBgpsControllerObserver.SingleTNGenerationComplete(iTnCreationIndex, ESize32x32);

#ifdef FACE_DETECTION

            TInt count = iFBCoordinateArray.Count();

            for(TInt i=0; i<count; i++)

                iFBCoordinateArray.Remove(0);

            iSingleFBCoordinateArray = &iFBCoordinateArray;

            iImageData = iIEBgpsControllerObserver.GetImageData(iTnCreationIndex);

            //iIEBgpsClient->StartSingleFaceDetection(iTnCreationIndex, *iSingleFBCoordinateArray, iImageData);

            iSingleFaceDetectionOn = ETrue;

#endif

            }

        }

    if(aErrorCode != KErrNone || !iSingleFaceDetectionOn)

        {

        TThumbSize res;

        iTnCreationIndex = FindMissingTN(res);

        iAllTNsDone = ETrue;

        //Check if all TN images are done

        for(TInt i=0; i<iImageDataArray.Count(); i++)

            {

            if((!iImageDataArray[i]->IsImageReady(ESize512x512) || 

               !iImageDataArray[i]->IsImageReady(ESize128x128) ||

               !iImageDataArray[i]->IsImageReady(ESize32x32)) &&

               !iImageDataArray[i]->iGridData.iCorrupted )

                {

                iAllTNsDone = EFalse;

                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Continue TN creation from index: %d"), i);

                break;

                }

            }

        if(!iAllTNsDone && iTnCreationIndex >= 0)

            {

            //Start creating thumbnails by calling TN creator

            if(res == ESize512x512)

                {

                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Res: ESize512x512, Index: %d"),iTnCreationIndex);

                i512x512TNCreationOn = ETrue;

                i128x128TNCreationOn = EFalse;

                i32x32TNCreationOn = EFalse;

                Generate512x512Thumbnails(iTnCreationIndex);

                }

            else if(res == ESize128x128)

                {

                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Res: ESize128x128, Index: %d"),iTnCreationIndex);

                i128x128TNCreationOn = ETrue;

                i512x512TNCreationOn = EFalse;

                i32x32TNCreationOn = EFalse;

                Generate128x128Thumbnails(iTnCreationIndex);

                }

            else if(res == ESize32x32)

                {

                DP1_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - Res: ESize32x32, Index: %d"),iTnCreationIndex);

                i32x32TNCreationOn = ETrue;

                i512x512TNCreationOn = EFalse;

                i128x128TNCreationOn = EFalse;

                Generate32x32Thumbnails(iTnCreationIndex);

                }

            }

        // Callback after completion of all TNs 

        if(iAllTNsDone)

            {

            i32x32TNCreationOn = EFalse;

            i128x128TNCreationOn = EFalse;

            i512x512TNCreationOn = EFalse;

            DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted - All thumbnails are created, start face Detection"));

            //iIEBgpsClient->StartFaceDetection(iImageDataArray);

            //iBackGroundFaceDetectionOn = ETrue;

            iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);

            }

        }

    DP0_IMAGIC(_L("CIEBgpsController::ThumbnailGenerationCompleted --"));    

    }

void CIEBgpsController::HandleError(TInt aError)

    {

    DP0_IMAGIC(_L("CIEBgpsController::HandleError"));

    //Handle BGPS errors here

    //Cancel UI frame blinking, we can not do anythign else if BGPS is jammed??

    //iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);

    if(i32x32TNCreationOn || i128x128TNCreationOn || i512x512TNCreationOn)

        {

        DP0_IMAGIC(_L("CIEBgpsController::HandleError - Error on TN generation, try to continue"));

        ThumbnailGenerationCompleted(aError);

        }

    else

        {

        iIEBgpsControllerObserver.TNGenerationComplete(ENotDefined);

        }

    }

void CIEBgpsController::ThumbnailGenerationCancelled(TInt /*aErrorCode*/)

    {

    //Start TN generation again if it was stopped

    if(iTnCreationCancelled)

        ;//StartSingleFaceDetection();

    }

void CIEBgpsController::GenerateThumbNailL(const TDes &aOrgFile, TThumbSize /*aTNResolution*/)

    {

    DP0_IMAGIC(_L("CIEBgpsController::GenerateThumbNailL ++"));

    iSavedFileName.Copy(aOrgFile);

    /*Generating Thumbnail path for 320x320 */

    iIEEngineUtils.GenerateThumbnailFileName(ESize32x32,iSavedFileName,iTNFilename);

    /*Creating folder if not exists */

    TParse parser;

    parser.Set(iTNFilename, NULL, NULL );

    TFileName name = parser.NameAndExt();//image file name

    TFileName tnPath = parser.DriveAndPath();

    CIEEngineUtils::CreateTNFolder(iFileServer, tnPath);

    /*Generating TN file with absolute path */

    tnPath.Append(name);

    /* TN file name with absolute path*/

    iTNFilename.Copy(tnPath);

    /*Set Single Thumbnail generation flag on */

    iSingleTNGeneration = ETrue; 

    /*Generate TN for 320x320 resolution */

    iLatestCreatedTNSize = ESize32x32;

    iTmpImageData = CImageData::NewL();

    TSize originalSize;

    iIEEngineUtils.GetImageSizeL(iSavedFileName, originalSize);

    DP1_IMAGIC(_L("iTNFilename: %S"), &iTNFilename);

    TSize size(320, 320);

    if (originalSize.iWidth && originalSize.iHeight)

        {

        if(originalSize.iWidth > originalSize.iHeight)

            { // Landscape

            size.iHeight = 320 * originalSize.iHeight / originalSize.iWidth;

            if(size.iHeight%2 != 0)

                size.iHeight++;

            }

        else // Portrait

            {

            size.iWidth = 320 * originalSize.iWidth / originalSize.iHeight;

            if(size.iWidth%2 != 0)

                size.iWidth++;

            }

        }

    iTmpImageData->SetSize(size);

    iIEBgpsClient->GenerateTN(iSavedFileName, iTNFilename, size);

    DP0_IMAGIC(_L("CIEBgpsController::GenerateThumbNailL--"));

    }

//Filename array has been filled(completetely) when this function is called

void CIEBgpsController::AllFilesAddedToFilenameArrayL()

    {

    DP0_IMAGIC(_L("CIEBgpsController::AllFilesAddedToFilenameArrayL++"));

    //Get filename array

    iImageDataArray = iFileLoader->GetFileNameArray();

    // Start TN generation

    if(iImageDataArray.Count() > 0)

        {

        StartTNCreatorL();

        }

    DP0_IMAGIC(_L("CIEBgpsController::AllFilesAddedToFilenameArrayL--"));

    }

TReal CIEBgpsController::GetAspectRatio(TInt aIndex)

    {

    DP0_IMAGIC(_L("CIEBgpsController::GetAspectRatio"));

    iImageDataArray = iFileLoader->GetFileNameArray();

    if(aIndex < iImageDataArray.Count())

        {

        return iImageDataArray[aIndex]->GetAspectRatio();

        }

    else

        {

        return 0;

        }

    }

TReal CIEBgpsController::GetFacesAspectRatio(TInt aIndex)

    {

    DP0_IMAGIC(_L("CIEBgpsController::GetAspectRatio"));

    iImageDataArray = iFileLoader->GetFacesFileNameArray();

    if(aIndex < iImageDataArray.Count())

        {

        return iImageDataArray[aIndex]->GetAspectRatio();

        }

    else

        return 0;

    }

void CIEBgpsController::GenerateTNForEditedImage(const TFileName aEditedFileName, const TReal aAspectRatio)

    {

    DP0_IMAGIC(_L("CIEBgpsController::GenerateTNForEditedImage++"));

    iSavedFileName.Copy(aEditedFileName);

    //set iSingleTNGeneration mode on

    iSingleTNGeneration = ETrue; 

    iAspectRatio = aAspectRatio;

    /*Generating 128x128 Thumbnail path */

    iIEEngineUtils.GenerateThumbnailFileName(ESize128x128, aEditedFileName, iTNFilename);

    //Create new imagedata instance to be appended to filename array

    iTmpImageData = CImageData::NewL();

    iTmpImageData->SetSize(TSize(128 * iAspectRatio, 128)); // TODO no size info

    iLatestCreatedTNSize = ESize128x128;

    iIEBgpsClient->GenerateTN(aEditedFileName, iTNFilename, TSize(128,128));

    //iIEBgpsClient->GenerateTN(aEditedFileName, iTNFilename, TSize(32,32));//mikares32

    DP0_IMAGIC(_L("CIEBgpsController::GenerateTNForEditedImage--"));

    }

void CIEBgpsController::FilenameArrayCountChanged(const RArray<CImageData*>& aImageDataArray)

    {

    iImageDataArray = aImageDataArray;

    //iIEBgpsControllerObserver.TotalNumberOfImagesChanged(iImageDataArray.Count());

    }

CImageData* CIEBgpsController::GetImageData(const TInt aIndex)

    {

    DP1_IMAGIC(_L("CIEBgpsController::GetImageData %d"), aIndex);

    return (aIndex <= iImageDataArray.Count()) ? iImageDataArray[aIndex] : NULL;

    }

void CIEBgpsController::GetFaceCoordinates(const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)

    {

    DP0_IMAGIC(_L("CIEBgpsController::GetFaceCoordinates"));

    aFaceCoordinateArray.Reset();

    //iIEBgpsClient->FindFaces(aTNFileName, aFaceCoordinateArray);

    }

//If background face Detection is still continuing, we have to use GetSingleFaceCoordinates() function to get face coordinates

void CIEBgpsController::GetSingleFaceCoordinates(TInt aIndex, const TFileName /*aTNFileName*/, RArray<TRect>& aFaceCoordinateArray)

    {

    DP0_IMAGIC(_L("CIEBgpsController::GetSingleFaceCoordinates++"));

    if(i128x128TNCreationOn || i512x512TNCreationOn || i32x32TNCreationOn)

        {

        iTnCreationCancelled = ETrue;

        CancelTNGeneration();

        i128x128TNCreationOn = EFalse;

        i512x512TNCreationOn = EFalse;

        i32x32TNCreationOn = EFalse;

        }

    iSingleFBIndex = aIndex;

    iSingleFBCoordinateArray = &aFaceCoordinateArray;

    //If BGPS face Detection was on, we have to stop it first. Othervice we can contiue directly to StartSingleFaceDetection() 

    if(iBackGroundFaceDetectionOn)

        {//We just cancel background face Detection, when cancel is complete we get callback to StartSingleFaceDetection()

        //iIEBgpsClient->CancelFaceDetection();

        iBackGroundFaceDetectionOn = EFalse;

        }

    else

        {

        //StartSingleFaceDetection();

        }

    DP0_IMAGIC(_L("CIEBgpsController::GetSingleFaceCoordinates--"));

    }

/* Creating Single Thumbnails for Editing. After editing the image we are 

 * genereating the thumbnails 128x128 & 640x480 resolution*/

void CIEBgpsController::CreateSingleTNL()

    {

    DP0_IMAGIC(_L("CIEBgpsController::CreateSingleTN++"));

    if(iLatestCreatedTNSize == ESize128x128)  

        {

        //Create and set data to image data item

        iTmpImageData->SetFileNameL(iSavedFileName);

        iImageDataArray[iImageIndex]->SetImageReady(EFullSize, ETrue);

        iImageDataArray[iImageIndex]->SetImageReady(ESize32x32, EFalse);

        iImageDataArray[iImageIndex]->SetImageReady(ESize512x512, EFalse);

        iImageDataArray[iImageIndex]->SetImageReady(ESize128x128, ETrue);

        //Insert new image data to filename array

        iFileLoader->AddNewImage(iTmpImageData, iImageIndex);

        iImageDataArray = iFileLoader->GetFileNameArray();

        //iIEBgpsControllerObserver.TotalNumberOfImagesChanged(iImageDataArray.Count());

        /*Generating 320x320 Tumbnail path */

        iIEEngineUtils.GenerateThumbnailFileName(ESize32x32,iSavedFileName,iTNFilename);

        iIEBgpsControllerObserver.TNGenerationComplete(ESize128x128);

        iLatestCreatedTNSize = ESize32x32;

        TSize size;

        TInt w, h;

        if(iImageDataArray[iImageIndex]->GetAspectRatio() > 1)

            {//Landscape

            w=320;

            h = 320/iImageDataArray[iImageIndex]->GetAspectRatio();

            if(h%2 != 0)

                h++;

            }

        else//Portrait

            {

            h = 320;

            w = 320 * iImageDataArray[iImageIndex]->GetAspectRatio();

            if(w%2 != 0)

                w++;

            }

        size.iHeight = h;

        size.iWidth = w;

        iTNSize = size;

        iIEBgpsClient->GenerateTN(iSavedFileName, iTNFilename, size);

        }

    else if(iLatestCreatedTNSize == ESize32x32)

        {

        iImageDataArray = iFileLoader->GetFileNameArray();

        iImageDataArray[iImageIndex]->SetImageReady(ESize32x32, ETrue);

        //iSingleTNGeneration = EFalse;

        iIEBgpsControllerObserver.TNGenerationComplete(ESize32x32);

        TSize size;

        size.iHeight = 512;

        size.iWidth = 512;

        iIEEngineUtils.GenerateThumbnailFileName(ESize512x512, iSavedFileName, iTNFilename);

        iTNSize = size;

        iIEBgpsClient->GenerateTN(iSavedFileName, iTNFilename, size);

        iLatestCreatedTNSize = ESize512x512;

        }

    //TN creation complete

    else

        {

        iSingleTNGeneration = EFalse;