/*
* 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 <ExifRead.h>
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "glxcommandhandlerrotateTraces.h"
#endif


GlxCommandHandlerRotate::GlxCommandHandlerRotate()
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_GLXCOMMANDHANDLERROTATE_ENTRY );
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_GLXCOMMANDHANDLERROTATE_EXIT );
    }

GlxCommandHandlerRotate::~GlxCommandHandlerRotate()
    {
    OstTraceFunctionEntry0( DUP1_GLXCOMMANDHANDLERROTATE_GLXCOMMANDHANDLERROTATE_ENTRY );
    OstTraceFunctionExit0( DUP1_GLXCOMMANDHANDLERROTATE_GLXCOMMANDHANDLERROTATE_EXIT );
    }

CMPXCommand* GlxCommandHandlerRotate::CreateCommandL(TInt aCommandId,
        MGlxMediaList& /*aMediaList*/, TBool& aConsume) const
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_CREATECOMMANDL_ENTRY );
    Q_UNUSED(aCommandId);
    Q_UNUSED(aConsume);
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_CREATECOMMANDL_EXIT );
    return NULL;
    }

void GlxCommandHandlerRotate::DoExecuteCommandL(TInt aCommandId,
        MGlxMediaList& aMediaList, TBool& aConsume)
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_DOEXECUTECOMMANDL_ENTRY );
    Q_UNUSED(aCommandId);
    Q_UNUSED(aConsume);
    const TGlxMedia& item = aMediaList.Item(aMediaList.FocusIndex());
    TFileName uri;
    uri.Copy(item.Uri());
    TRAPD(err,RotateImageL(uri));
    if (err != KErrNone)
        {
        OstTrace0( TRACE_NORMAL, GLXCOMMANDHANDLERROTATE_DOEXECUTECOMMANDL, "GlxCommandHandlerRotate::DoExecuteCommandL Exif Update failed" );
        }
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_DOEXECUTECOMMANDL_EXIT );
    }

void GlxCommandHandlerRotate::RotateImageL(TFileName aFileToBeRotated)
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_ROTATEIMAGEL_ENTRY );
    //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();
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_ROTATEIMAGEL_EXIT );
    }

void GlxCommandHandlerRotate::InitializeExifWriterL(
        TFileName aFileToBeRotated)
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_INITIALIZEEXIFWRITERL_ENTRY );
    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);
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_INITIALIZEEXIFWRITERL_EXIT );
    }

TUint16 GlxCommandHandlerRotate::ReadImageOrientationL()
{
	OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_READIMAGEORIENTATIONL_ENTRY );
	TUint16 initialOrientation;
	const CExifRead* exifReader = iExifWriter->Reader(); //not owned
    User::LeaveIfError(exifReader->GetOrientation(initialOrientation));
	OstTrace1( TRACE_NORMAL, GLXCOMMANDHANDLERROTATE_READIMAGEORIENTATIONL, "GlxCommandHandlerRotate::ReadImageOrientationL;initial orientation=%d", initialOrientation );
	OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_READIMAGEORIENTATIONL_EXIT );
	return (initialOrientation);
}

TUint16 GlxCommandHandlerRotate::CalculateFinalOrientationL(
        TUint16 aInitialOrientation)
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_CALCULATEFINALORIENTATIONL_ENTRY );
    /*
     * 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;
        }
    OstTrace1( TRACE_NORMAL, GLXCOMMANDHANDLERROTATE_CALCULATEFINALORIENTATIONL, "GlxCommandHandlerRotate::CalculateFinalOrientationL;finalOrientation=%d", finalOrientation );
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_CALCULATEFINALORIENTATIONL_EXIT );
    return finalOrientation;
    }

void GlxCommandHandlerRotate::SetImageOrientationL(TUint16 aFinalOrientation)
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_SETIMAGEORIENTATIONL_ENTRY );
    iExifWriter->SetOrientationL(aFinalOrientation);
    HBufC8* modifiedexifData = NULL;
    modifiedexifData = iExifWriter->WriteDataL(iExifData->Des());
    User::LeaveIfError(iFileHandle.Write(0, modifiedexifData->Des()));
    delete modifiedexifData;
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_SETIMAGEORIENTATIONL_EXIT );
    }

void GlxCommandHandlerRotate::DestroyExifWriter()
    {
    OstTraceFunctionEntry0( GLXCOMMANDHANDLERROTATE_DESTROYEXIFWRITER_ENTRY );
    iFileHandle.Close();
    if (iExifData != NULL)
        {
        delete iExifData;
        iExifData = NULL;
        }
    if (iExifWriter != NULL)
        {
        delete iExifWriter;
        iExifWriter = NULL;
        }
    OstTraceFunctionExit0( GLXCOMMANDHANDLERROTATE_DESTROYEXIFWRITER_EXIT );
    }