/*

* 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:

*

* Description: 

*

*/

#include <mpxcollectionpath.h>

#include <mglxmedialist.h>

#include <glxcommandfactory.h>

#include <GlxCommandHandlerRotate.h>

#include <QDebug>

#include <ExifRead.h>

GlxCommandHandlerRotate::GlxCommandHandlerRotate()

{

    qDebug("GlxCommandHandlerRotate::GlxCommandHandlerRotate() ");

}

GlxCommandHandlerRotate::~GlxCommandHandlerRotate()

{

    qDebug("GlxCommandHandlerRotate::~GlxCommandHandlerRotate() ");

}

CMPXCommand* GlxCommandHandlerRotate::CreateCommandL(TInt aCommandId, MGlxMediaList& aMediaList, TBool& aConsume) const 

{

	Q_UNUSED(aCommandId);

	Q_UNUSED(aConsume);

    qDebug("GlxCommandHandlerRotate::CreateCommandL");

    return NULL;

}

void GlxCommandHandlerRotate::DoExecuteCommandL(TInt aCommandId, MGlxMediaList& aMediaList, TBool& aConsume)

{

	Q_UNUSED(aCommandId);

	Q_UNUSED(aConsume);

    qDebug("GlxCommandHandlerRotate::DoExecuteCommandL");

    const TGlxMedia& item = aMediaList.Item( aMediaList.FocusIndex() );

	TFileName uri;

	uri.Copy(item.Uri());

	TRAPD(err,RotateImageL(uri));

	if(err != KErrNone) {

		qDebug("GlxCommandHandlerRotate::DoExecuteCommandL Exif Update failed");

	}

}

void GlxCommandHandlerRotate::RotateImageL(TFileName aFileToBeRotated)

{

	//Start an IFS session

	//File system 

    User::LeaveIfError(iFs.Connect());

	//first initialize the Exif Writer which is responsible for reading and writing the Exif Data

	//Will leave here itself in cases where the Exif data is absent

	InitializeExifWriterL(aFileToBeRotated);

	//read the Orientation tag stored in  the Exif Data

	TUint16 initialOrientation = ReadImageOrientationL();

	//as the image is rotated to 90 degrees clockwise calculate the new orientation by adding that angle

	TUint16 finalOrientation = CalculateFinalOrientationL(initialOrientation);

	// Set the Final Orientation on the file

	SetImageOrientationL(finalOrientation);

	// Clear the sessions acquired

	DestroyExifWriter();

	//close the File Session

	iFs.Close();

}

void GlxCommandHandlerRotate::InitializeExifWriterL(TFileName aFileToBeRotated)

{

	User::LeaveIfError(iFileHandle.Open(iFs,

                    aFileToBeRotated, EFileWrite));

	TInt filesize;

    User::LeaveIfError(iFileHandle.Size(filesize));

	iExifData = HBufC8::NewL(filesize);

	TPtr8 ptr(iExifData->Des());

    User::LeaveIfError(iFileHandle.Read(ptr));

   	iExifWriter = CExifModify::NewL(*iExifData,CExifModify::EModify,CExifModify::ENoJpegParsing);

}

TUint16 GlxCommandHandlerRotate::ReadImageOrientationL()

{

	TUint16 initialOrientation;

	const CExifRead* exifReader = iExifWriter->Reader(); //not owned

    User::LeaveIfError(exifReader->GetOrientation(initialOrientation));

	qDebug("GlxCommandHandlerRotate::ReadImageOrientationL initial orientation = %d", initialOrientation);

	return (initialOrientation);

}

TUint16 GlxCommandHandlerRotate::CalculateFinalOrientationL(TUint16 aInitialOrientation)

{

	/*

     * possible orientation state with angles for rotation

     * Possible Angles 0 - 90 - 180 - 270

     * Possible states 1 - 8 - 3 - 6 without a Flip

     * Possible states 2 - 7 - 4 - 5 when Flip is on

     */

	TUint16 finalOrientation = aInitialOrientation;

	if(aInitialOrientation >8 ) {

		//invalid orientation passed Leave

        User::Leave(KErrCorrupt);

    }

	TInt rotOffset = 1;

	TInt isOrientationOdd = aInitialOrientation % 2;

	TInt initStateIndex = 0;

    TInt finalStateIndex = 0;

    //Setting the orientation states for the initial unflipped orientation combinations

    TInt orientationStateArray[] = {1,8,3,6};

    //Seting the index for current orientation

    if(aInitialOrientation < 3)

        {

        initStateIndex = 0;

        }

    else if(aInitialOrientation >= 3 && aInitialOrientation < 5)

        {

        initStateIndex = 2;

        }

    else if(aInitialOrientation >= 5 && aInitialOrientation < 7)

        {

        initStateIndex = 3;

        }

    else if(aInitialOrientation >= 7 && aInitialOrientation <= 8)

        {

        initStateIndex = 1;

        }

    //Calculating the final orientation using the cyclic orientationStateArray. 

    //folding final index so that it behaves like a cyclic machine 

    finalStateIndex = (initStateIndex+rotOffset)%4;

    finalOrientation = orientationStateArray[finalStateIndex];

    //Checking if a Flip was present 

    if(aInitialOrientation>4 && isOrientationOdd )

        {

        finalOrientation -= 1;

        }

    if(aInitialOrientation<5 && !isOrientationOdd)

        {

        finalOrientation += 1;

        }

	qDebug("GlxCommandHandlerRotate::CalculateFinalOrientationL final orientation = %d", finalOrientation);

    return finalOrientation;

}

void GlxCommandHandlerRotate::SetImageOrientationL(TUint16 aFinalOrientation)

{

	iExifWriter->SetOrientationL(aFinalOrientation);

	HBufC8* modifiedexifData=NULL;

	modifiedexifData = iExifWriter->WriteDataL(iExifData->Des());

	User::LeaveIfError(iFileHandle.Write(0,modifiedexifData->Des()));

    delete modifiedexifData;	

}

void GlxCommandHandlerRotate::DestroyExifWriter()

{

	iFileHandle.Close();

	if(iExifData != NULL)

        {

        delete iExifData;

        iExifData = NULL;

        }

    if(iExifWriter != NULL)

        {

        delete iExifWriter;

        iExifWriter = NULL;

        } 

}