/*
* 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 <e32uid.h>
#include <BAUTILS.H>
#include <IEImageProcessing.h>//thumbnail client
#include "IEEngineImp.h"
#ifdef IMAGE_EDITOR
#include "IEEditor.h"
#endif
#include "IEFileLoader.h"
#include "IEImageList.h"
#include "ImageMonitorAO.h"
#include "IEImageList.h"
#include "IEEngineUtils.h"


// ============================ MEMBER FUNCTIONS =========================== //

EXPORT_C CIEEngine* CIEEngine::NewL(MIEEngineObserver& aObserver)
{
    DP0_IMAGIC(_L("CIEEngine::NewL"));
	return CIEEngineImp::NewL(aObserver);
}

EXPORT_C CIEEngine::~CIEEngine()
    {
    
    }

CIEEngineImp* CIEEngineImp::NewL(MIEEngineObserver& aObserver)
{
    DP0_IMAGIC(_L("CIEEngine::NewL"));
	CIEEngineImp* self = new (ELeave) CIEEngineImp(aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
}

CIEEngineImp::~CIEEngineImp()
    {
    DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp++"));

#if 0
   if(iIEImageProcessing)
       {
       delete iIEImageProcessing;
       iIEImageProcessing = NULL;
       }
#endif

#ifdef IMAGE_EDITOR
     if(iImageEditor)
	 {
         DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iImageEditor"));
         delete iImageEditor;
         iImageEditor = NULL;
	 }
#endif
   
	 if(iFileLoader)
	     {
	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iFileLoader"));
	     delete iFileLoader;
	     iFileLoader = NULL;
	     }
	
	 if(iBitmapLoader)
	     {
	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader"));
	     iBitmapLoader->CancelFullSizeLoading();
	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader 2"));
	     delete iBitmapLoader;
	     iBitmapLoader = NULL;
	     }
	
	 if(iIEBgpsController)
	     {
	     DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iIEBgpsController"));
	     delete iIEBgpsController;
	     iIEBgpsController = NULL;
	     }
#ifdef _ACCELEROMETER_SUPPORTED_
	 if(iSensorMonitor)
	     {
	     iSensorMonitor->StopMonitoring();
	     delete iSensorMonitor;
	     iSensorMonitor = NULL;
	     }
#endif //_ACCELEROMETER_SUPPORTED_

	iFileServer.Close();
	iCritical.Close();
	
	DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp--"));
    }

CIEEngineImp::CIEEngineImp(MIEEngineObserver& aObserver) :
    iEngineObserver(aObserver),
    iIEEngineUtils(iFileServer)
    {
    }

void CIEEngineImp::ConstructL()
    {
    DP0_IMAGIC(_L("CIEEngine::ConstructL++"));
    
    iCritical.CreateLocal();
    
    User::LeaveIfError(iFileServer.Connect());
	
	/*Creating Engine Utility class pointer */
	iCurrentEditingMode = EEditModeNone;
	iEditingMode = EEditModeNone;
	iImageEdited = EFalse;
	iImageArrayMode = EImages;
	iAllFilesScanned = EFalse;
	iPrevDeviceOrientation = EOrientationDisplayLeftUp;
	

	TInt err = KErrNone;
	//Create Bitmap loader
	iBitmapLoader = CIEBitmapLoader::NewL(iFileServer, *this, &iCritical);
	//Create BGPS controller
	iIEBgpsController = CIEBgpsController::NewL(iFileServer, *this, iIEEngineUtils, &iCritical);
	//Create Fileloader
	TRAP(err, iFileLoader = CIEFileLoader::NewL(iFileServer, this, &iCritical));
    if(err != KErrNone)
        {
        DP1_IMAGIC(_L("CIEEngine::ConstructL - Error creating file loader, err: %d"),err);
        User::Leave(err);
        }
    
#ifdef _ACCELEROMETER_SUPPORTED_
    iDeviceOrientation = EOrientationDisplayLeftUp;
    err = KErrNone;
    TRAP(err, iSensorMonitor = CIESensorMonitor::NewL(*this));
    DP1_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor error: %d"), err);
    if(err == KErrNone)
        {
        DP0_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor->StartMonitoring()"));
        iSensorMonitor->StartMonitoring();
        }
    else
        {
        iSensorMonitor = NULL;
        }

#endif

    iIEBgpsController->SetFileLoader(iFileLoader); 
   
    DP0_IMAGIC(_L("CIEEngine::ConstructL--"));
}

void CIEEngineImp::SetDBChanged(CImageData* aImageData)
    {
    TFileName filename;
    aImageData->GetFileName(filename, EFullSize);
    iFileLoader->GetImageList().SetChanged(filename); 
    }

CIEImageList& CIEEngineImp::GetImageList()
    {
    return iFileLoader->GetImageList();
    }

void CIEEngineImp::AppUIReady()
    {
    DP0_IMAGIC(_L("CIEEngine::AppUIReady"));
    
    //Create ImageProcessing
    iIEBgpsController->CreateImageProcessing();
    }

void CIEEngineImp::CancelFullSizeLoading()
    {
    DP0_IMAGIC(_L("CIEEngine::CancelLoading"));
    
    iBitmapLoader->CancelFullSizeLoading();
    }


void CIEEngineImp::SetImageDataMode(TImageArrayMode aMode)
    {
    iImageArrayMode = aMode;
    
    iBitmapLoader->SetImageDataMode(aMode);
    }

MIEEngineObserver& CIEEngineImp::GetObserver() 
    {
    return iEngineObserver;
    }

void CIEEngineImp::TNGenerationComplete(TThumbSize aTNRes)
    {
    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++"));
    
    iEngineObserver.TNCreationCompleteL(aTNRes);
    
    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--"));
    }

void CIEEngineImp::SingleTNGenerationComplete(TInt aIndex, TThumbSize aTNRes)
    {
    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++"));
    
    iEngineObserver.SingleTNCreationCompletedL(aIndex, aTNRes);
    
    DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--"));
    }

void CIEEngineImp::FaceDetectionComplete()
    {
    DP0_IMAGIC(_L("CIEEngine::FaceDetectionComplete"));
    iEngineObserver.FaceDetectionComplete();
    }

void CIEEngineImp::SingleFaceDetectionComplete()
    {
    DP0_IMAGIC(_L("CIEEngine::SingleFaceDetectionComplete"));
    
    iEngineObserver.SingleFaceDetectionComplete();
    }

void CIEEngineImp::AllFilesAddedToFilenameArrayL()
    {
    DP0_IMAGIC(_L("CIEEngine::AllFilesAddedToFilenameArrayL"));
    
    iIEBgpsController->AllFilesAddedToFilenameArrayL();
    iEngineObserver.AllFilesScanned();
    iAllFilesScanned = ETrue;
    }

CIEEngineUtils * CIEEngineImp::GetEngineUtils()
    {
    DP0_IMAGIC(_L("CIEEngine::GetEngineUtils"));
    
    return &iIEEngineUtils;
    }

CIEFileLoader* CIEEngineImp::GetFileLoader()
    {
    DP0_IMAGIC(_L("CIEEngineImp::GetFileLoader"));
    
    return iFileLoader;
    }

void CIEEngineImp::BitmapsLoadedL(TInt aError)
{
    DP0_IMAGIC(_L("CIEEngineImp::BitmapsLoaded"));
    
	iEngineObserver.ImagesLoadedL(aError);
}

TBool CIEEngineImp::IsScanningFiles() const
    {
    return !iAllFilesScanned;
    }

void CIEEngineImp::GetTotalNumOfImages(TInt& aNumOfImages, TInt& aNumOfFaces)
    {
    //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages"));
    
    iFileLoader->GetTotalNumOfImages(aNumOfImages, aNumOfFaces);
    }

TInt CIEEngineImp::GetTotalNumOfImages()
    {
    //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages"));
    //return iFileLoader->GetTotalNumOfImages();
    
    TInt numOfImages, numOfFaces;
    if(iImageArrayMode == EImages)
        {
        iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces);
        return numOfImages;
        }
        
    else if(iImageArrayMode == EFaces)
        {
        iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces);
        return numOfFaces;
        }
    else
        return 0;
    
    }

TInt CIEEngineImp::DeleteFile(TInt aIndex)
    {  
    DP0_IMAGIC(_L("CIEEngineImp::DeleteFile++"));
    TInt err;
    if(iImageArrayMode == EImages)
        {
        err = iFileLoader->DeleteFile(aIndex);
        iIEBgpsController->FilenameArrayCountChanged(iFileLoader->GetFileNameArray());
        }
    else//EFaces
        {
        err = iFileLoader->DeleteFaceFile(aIndex);
        TInt numOfImages = 0;
        TInt numOfFaces = 0;
        iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces);
        }
    DP1_IMAGIC(_L("CIEEngineImp::DeleteFile-- %d"), err);
    return err;
    }

TInt CIEEngineImp::GetImageName(const TInt aIndex, TFileName& aFileName, TThumbSize aThumbRes)
    {
    DP0_IMAGIC(_L("CIEEngineImp::GetImageName"));
    
    TInt error = KErrNone;
    TRAP(error, iFileLoader->GetFileNameL(aIndex, aFileName, aThumbRes));
    return error;
    }

void CIEEngineImp::GetBitmapL(CImageData* aImageData, CFbsBitmap* aBitmap, TThumbSize aThumbRes)
    {
    DP0_IMAGIC(_L("CIEEngineImp::GetBitmapL"));
    
    iBitmapLoader->GetOneBitmapL(aImageData, aBitmap, aThumbRes);
    }

void CIEEngineImp::GetFileNameL(const TInt aIndex, TThumbSize aThumbRes, TFileName& aFilename)
    {
    iFileLoader->GetFileNameL(aIndex, aFilename, aThumbRes);
    }

void CIEEngineImp::StopTNGeneration(TInt& /*aValue*/)
    {
    //iIEBgpsController->StopTNGeneration(aValue);
    iIEBgpsController->CancelTNGeneration();
    }

TReal CIEEngineImp::GetAspectRatio(TInt aIndex)
    {
    return iIEBgpsController->GetAspectRatio(aIndex);
    }

TReal CIEEngineImp::GetFacesAspectRatio(TInt aIndex)
    {
    return iIEBgpsController->GetFacesAspectRatio(aIndex);
    }

//This function is called in editing mode only when we did not have 320x320 TN ready
void CIEEngineImp::GenerateThumbNailL(const TDes &aOrgFile, TThumbSize aTNResolution)
    {
    DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail++"));
    
    iIEBgpsController->GenerateThumbNailL(aOrgFile, aTNResolution);

    DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail--"));
    }

//This is used to get face coords from already processed image
void CIEEngineImp::GetFaceCoordinates(const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)
    {
    DP0_IMAGIC(_L("CIEEngineImp::GetFaceCoordinates"));
    aFaceCoordinateArray.Reset();
    //iIEBgpsController->GetFaceCoordinates(aTNFileName, aFaceCoordinateArray);
    }

void CIEEngineImp::AddImageToFaceNameArray()
    {
    DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray++"));
    
    //Tarkista etta jos kuva on jo olemassa sita ei lisata enaa uudelleen 
    
    for(TInt i=0; i<iCroppedFilenames.Count(); i++)
        {
        //Add newly cropped filenames to filename array
        CImageData* tmpImageData = CImageData::NewL(EFullSize);
        
        TRAP_IGNORE(tmpImageData->SetFileNameL(iCroppedFilenames[i]));
        
        DP1_IMAGIC(_L("CIEEngineImp::FaceCroppingComplete - Add face, Filename: %S"), &iCroppedFilenames[i] );
        
        TSize size;
        TRAPD(err, iIEEngineUtils.GetImageSizeL(iCroppedFilenames[i], size));
        if (err == KErrNone)
            tmpImageData->SetSize(size);
        
        iFileLoader->AddNewFaceCropImage(tmpImageData, 0);    
        }
    
    TInt numOfImages, numOfFaces;
    iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces);
    
    //TotalNumberOfFaceImagesChanged(numOfFaces);
    
    //Empty data from array after using it
    TInt count = iCroppedFilenames.Count();
    for(TInt i=0; i<count; i++)
        {
        iCroppedFilenames.Remove(0);
        }
    //iFileLoader->StopFileSystemMonitoring();
    
    DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray--"));
    }

//If background face Detection is still continuing, we have to use GetSingleFaceCoordinates() function to get face coordinates
void CIEEngineImp::GetSingleFaceCoordinates(TInt aIndex, const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)
    {
    DP0_IMAGIC(_L("CIEEngineImp::GetSingleFaceCoordinates"));
    
    iIEBgpsController->GetSingleFaceCoordinates(aIndex, aTNFileName, aFaceCoordinateArray);
    }


CImageData* CIEEngineImp::GetImageData(TInt aIndex/*, TImageArrayMode aMode*/)
    {
    return iFileLoader->GetImageData(aIndex/*, aMode*/);
    }

void CIEEngineImp::SetImageData(TInt aIndex, CImageData* aGridData)
    {
    iFileLoader->SetImageData(aIndex, aGridData);
    }

TInt CIEEngineImp::GetSelectedImageIndex()
    {
    return iEngineObserver.GetImageIndex();
    }
    


#ifdef _ACCELEROMETER_SUPPORTED_

void CIEEngineImp::SensorDataAvailable(TImagicDeviceOrientation aOrientation, TBool aValue)
    {
    //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable++"));
    
    if(iPrevDeviceOrientation == aOrientation)
        {
        //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Orientation not changed--"));
        return;
        }

    iPrevDeviceOrientation = aOrientation;
    
    CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages);
    TInt totalImages = GetTotalNumOfImages();
    
    switch ( aOrientation )
        {
#ifdef _S60_3x_ACCELEROMETER_
        case EOrientationDisplayDown: // Portrait Up
#else if _S60_5x_ACCELEROMETER_
        case TSensrvOrientationData::EOrientationDisplayUp: // Portrait Up
        //case TSensrvOrientationData::EOrientationDisplayDown: // Portrait Up
#endif            
            {               
            DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayUp"));
            
            for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ )
                {
                currentImage = GetImageData(imageIndex); 
                currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() + 90)%360;
                
                TReal targetA = currentImage->iGridData.iTargetRotationAngle;
                TReal currentA = currentImage->iGridData.iRotationAngle;
                
                currentImage->iGridData.iTargetRotationAngle = targetA;
                
                }
            
            iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayDown;
            break;
            }

#ifdef _S60_3x_ACCELEROMETER_
        case EOrientationDisplayLeftUp: // Landscape Up
#else if _S60_5x_ACCELEROMETER_
        case TSensrvOrientationData::EOrientationDisplayRightUp: // Landscape Up
        //case TSensrvOrientationData::EOrientationDisplayLeftUp: // Landscape Up
#endif            
                {
            DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayLeftUp"));
            
            for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ )
                {
                currentImage = GetImageData(imageIndex); 
                if ( currentImage->iGridData.iRotationAngle == 270 )
                    {
                    currentImage->iGridData.iRotationAngle = -90; // Rotate
                    }
                currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() )%360;
                
                TReal targetA = currentImage->iGridData.iTargetRotationAngle;
                TReal currentA = currentImage->iGridData.iRotationAngle;
                
                currentImage->iGridData.iTargetRotationAngle = targetA;
                }              
  
            iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayLeftUp;
            break;
            }

            default:
                {
                DP1_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Ignored orientation: %d"),aOrientation);
                //progressBuf.Append( _L( "Unknown orientation" ) );
                break;
                }
            }
    iEngineObserver.ImageRotated(iDeviceOrientation);
    
    DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable--"));
   }

void CIEEngineImp::SetImageRotation(TInt aIndex)
    {
    CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages);
    //TInt totalImages = GetTotalNumOfImages();
    
    currentImage = GetImageData(aIndex); 
    
    TReal targetAngle = (currentImage->GetOrientation())%360;
    //TReal currentAngle = currentImage->iGridData.iRotationAngle;
    
    currentImage->iGridData.iTargetRotationAngle = targetAngle;
    
    }
    

TImagicDeviceOrientation CIEEngineImp::GetDeviceOrientation()
    {
    DP1_IMAGIC(_L("CIEEngineImp::GetDeviceOrientation: %d"),iDeviceOrientation);
    return iDeviceOrientation;
   }

void CIEEngineImp::SetDeviceOrientation(TImagicDeviceOrientation aOrientation)
    {
    DP1_IMAGIC(_L("CIEEngineImp::SetDeviceOrientation: %d"),aOrientation);
    
    SensorDataAvailable(aOrientation, EFalse);
   }

void CIEEngineImp::StartAccSensorMonitoring()
    {
    if(iSensorMonitor)
        {
        DP0_IMAGIC(_L("CIEEngineImp::StartAccSensorMonitoring"));
        iSensorMonitor->StartMonitoring();
        }
        
    }

void CIEEngineImp::StopAccSensorMonitoring()
    {
    if(iSensorMonitor)
        {
        DP0_IMAGIC(_L("CIEEngineImp::StopAccSensorMonitoring"));
        iSensorMonitor->StopMonitoring();
        }
    }

#endif

void CIEEngineImp::Stop()
    {
    /*TInt err = KErrNone;
    StopTNGeneration(err); 
    StopFaceDetection(err);*/
    iFileLoader->StopImageFinder();
    }

TBool CIEEngineImp::IsRunning()
    {
    //iIEBgpsController->
    return (iFileLoader->ImageFinderState() != CIEFileLoader::EImageFinderStopped);
    //return ETrue;
    }
 
TBool CIEEngineImp::IsAccelerometerExists()
    {
    DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists"));
    
#ifdef _S60_3x_ACCELEROMETER_
#ifdef SENSOR_API_LOAD_DYNAMICALLY
    DP1_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor exists: %d"),iSensorMonitor);
    return (iSensorMonitor != NULL);
#endif
#endif
    DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor not exists"));
    return EFalse;
    }

TInt CIEEngineImp::GetGleMaxRes()
    {
    return iEngineObserver.GetGleMaxRes();
    }

    
// EOF