/*
* Copyright (c) 2008 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:  Handles DRM File IO Operations
 *
*/

#include <errno.h>
#include <unistd.h>
#include <string>

#include "s60commonutils.h"
#include "javacommonutils.h"
#include "jniarrayutils.h"
#include "logger.h"
#include "functionserver.h"
#include "fs_methodcall.h"

#include "filedrmcontenthandler.h"
#include "s60filesystemutilities.h"
#include "com_nokia_mj_impl_fileutils_FileDRMContentHandler.h"

using namespace std;
using namespace java::util;
using namespace java::fileutils;

TBool FileDRMContentHandler::isDRMProtectedFile(const TDesC& aFullName)
{
    JELOG2(EJavaFile);
    LOG(EJavaFile, EInfo, "+FileDRMContentHandler::isDRMProtectedFile{}");
    TInt value = 0;
    HBufC* fileName = 0;

    TRAPD(err, fileName = HBufC::NewL(aFullName.Length()));
    if (KErrNone == err)
    {
        TPtr fileNamePtr(fileName->Des());
        fileNamePtr = aFullName;
        S60FileSystemUtilities::ReplaceCharacters(fileNamePtr, '/', '\\');

        ContentAccess::CContent* content = 0;
        // Use CAF to check whether the content is protected
        TRAP(err, content = ContentAccess::CContent::NewL(fileNamePtr));

        if (KErrNone == err)
        {
            LOG(EJavaFile, EInfo,
                "    FileDRMContentHandler::isDRMProtectedFile: " \
                "Getting attribute.");
            err = content->GetAttribute(ContentAccess::EIsProtected, value);
            if (err != KErrNone)
            {
                return EFalse;
            }
            delete content; //Cleanup after NewL
        }
    }
    LOG1(EJavaFile, EInfo,
         "-FileDRMContentHandler::isDRMProtectedFile: returns %d",
         value);
    delete fileName;
    return value ? ETrue : EFalse;
}

ContentAccess::TIntent FileDRMContentHandler::mapIntentToCAF(TInt aIntent)
{
    JELOG2(EJavaFile);
    ContentAccess::TIntent intent;
    switch (aIntent)
    {
    case com_nokia_mj_impl_fileutils_FileDRMContentHandler_Peek:
        intent = ContentAccess::EPeek;
        break;
    case com_nokia_mj_impl_fileutils_FileDRMContentHandler_Play:
        intent = ContentAccess::EPlay;
        break;
    case com_nokia_mj_impl_fileutils_FileDRMContentHandler_View:
        intent = ContentAccess::EView;
        break;
    case com_nokia_mj_impl_fileutils_FileDRMContentHandler_Execute:
        intent = ContentAccess::EExecute;
        break;
    case com_nokia_mj_impl_fileutils_FileDRMContentHandler_Print:
        intent = ContentAccess::EPrint;
        break;
    default:
        intent = ContentAccess::EUnknown;
    }
    return intent;

}

void FileDRMContentHandler::setDrmArguments(TInt aIntent, TBool aExecuteIntent)
{
    LOG2(EJavaFile, EInfo, "FileDRMContentHandler::setDrmArguments(): "
         " Intent to %d and Set Intent?", aIntent, aExecuteIntent);

    mExecuteIntent = aExecuteIntent;
    mDrmIntent = mapIntentToCAF(aIntent);
}

FileDRMContentHandler::FileDRMContentHandler(const std::wstring aName) :
        NativeFileIOHandler(aName), mContent(0), mData(0), mReadPosition(0)
{
    // CContent and CData both use RFile internally.
    // Calling in different thread context will result in a panic.
    // Hence we need to use Function Server to maintain a single thread context.
    LOG(EJavaFile, EInfo, "FileDRMContentHandler: Creating new FunctionServer");
    mFunctionServer = new FunctionServer("FileDRMContentHandler");
    mFunctionServer->createServerToNewThread();
}

FileDRMContentHandler::~FileDRMContentHandler()
{
    JELOG2(EJavaFile);
    CallMethod(this, &FileDRMContentHandler::clearContent, mFunctionServer);
    delete mFunctionServer;
}

void FileDRMContentHandler::clearContent()
{
    if (mContent)
    {
        delete mContent;
        mContent = 0;
    }

    if (mData)
    {
        delete mData;
        mData = 0;
    }
}

long FileDRMContentHandler::skip(const long aOffset)
{
    long result = 0;
    CallMethod(result, this, &FileDRMContentHandler::skipFs, aOffset,
               mFunctionServer);
    return result;
}

long FileDRMContentHandler::skipFs(const long aOffset)
{
    JELOG2(EJavaFile);
    handleReopenCase();

    TInt pos = aOffset;
    TInt currentOffset = mReadPosition;

    LOG1(EJavaFile, EInfo, "FileDRMContentHandler::skip: trying to skip: %d",
         aOffset);

    TInt error = mData->Seek(ESeekCurrent, pos);
    TInt skipped = 0;

    if (KErrNone == error)
    {
        mReadPosition = pos;
        LOG1(EJavaFile, EInfo,
             "FileDRMContentHandler::skip: setting read pos to: %d",
             mReadPosition);
        skipped = (mReadPosition - currentOffset);
    }

    LOG1(EJavaFile, EInfo, "FileDRMContentHandler::skip: skipped: %d", skipped);
    return skipped;
}

int FileDRMContentHandler::readBytes(char* aBuffer, int aLength)
{
    int result = 0;
    CallMethod(result, this, &FileDRMContentHandler::readBytesFs, aBuffer,
               aLength, mFunctionServer);
    return result;
}

int FileDRMContentHandler::readBytesFs(char* aBuffer, int aLength)
{
    JELOG2(EJavaFile);
    handleReopenCase();

    HBufC8* data = HBufC8::New(aLength + 1);
    TPtr8 buffer(data->Des());
    LOG(EJavaFile, EInfo, "FileDRMContentHandler::readBytes() Reading data...");

    TInt error = mData->Read(buffer, aLength);
    TInt bytesRead = buffer.Size();

    memcpy(aBuffer, buffer.Ptr(), bytesRead);
    aBuffer[bytesRead] = 0;

    mReadPosition += bytesRead;
    delete data;

    LOG1(EJavaFile, EInfo, "FileDRMContentHandler::readBytes: returning: %d",
         bytesRead);
    return bytesRead;
}

int FileDRMContentHandler::writeBytes(char* /*aBuffer*/, int /*aLength*/)
{
    JELOG2(EJavaFile);
    // There is no write for DRM protected content. We should not be here.
    return 0;
}

void FileDRMContentHandler::stopReading()
{
    JELOG2(EJavaFile);
    mReadPosition = 0;
}

void FileDRMContentHandler::stopWriting()
{
    JELOG2(EJavaFile);
    ELOG(EJavaFile, "FileDRMContentHandler::stopWriting() "
         " WE SHOULD NEVER BE HERE. SOMETHING WRONG.");
    // NOTE: There is no write for DRM protected content. We should not be here.
}

void FileDRMContentHandler::initializeAndOpenL()
{
    JELOG2(EJavaFile);

    LOG(EJavaFile, EInfo, "+FileDRMContentHandler::initializeAndOpenL() ");

    // Check and initialize DRM content here.
    HBufC* fileName = S60CommonUtils::wstringToDes(mFileName.c_str());
    TPtr fileNameDes(fileName->Des());
    S60FileSystemUtilities::ReplaceCharacters(fileNameDes, '/', '\\');

    CleanupStack::PushL(fileName);

    mContent = ContentAccess::CContent::NewL(fileNameDes);
    mData = mContent->OpenContentL(mDrmIntent);
    LOG(EJavaFile, EInfo,
        "    FileDRMContentHandler::initializeAndOpenL(): Content opened.");

    int error = mData->EvaluateIntent(mDrmIntent);
    User::LeaveIfError(error);

    LOG(EJavaFile, EInfo,
        "    FileDRMContentHandler::initializeAndOpenL(): Intent evaluated");

    if (mExecuteIntent)
    {
        LOG(EJavaFile, EInfo,
            "    FileDRMContentHandler::initializeAndOpenL(): Executing intent");

        // Initialize and open should be called only once until the file is not closed.
        error = mData->ExecuteIntent(mDrmIntent);
        User::LeaveIfError(error);
    }

    CleanupStack::PopAndDestroy(fileName);
    LOG(EJavaFile, EInfo, "-FileDRMContentHandler::initializeAndOpenL() ");
}

void FileDRMContentHandler::openForReading()
{
    JELOG2(EJavaFile);
    LOG1(EJavaFile, EInfo, "FileDRMContentHandler::openForReading(): "
         " Opening: %S", mFileName.c_str());

    TRAPD(error, CallMethodL(this,
                             &java::fileutils::FileDRMContentHandler::initializeAndOpenL,
                             mFunctionServer));

    if ((KErrCANoPermission == error) || (KErrCANoRights == error)
            || (KErrCAPendingRights == error))
    {
        ELOG1(EJavaFile, "FileDRMContentHandler::openForReading() Open failed."
              " Error: %d", error);
        throw EPERM;
    }

    if (KErrNone != error)
    {
        ELOG1(EJavaFile, "FileDRMContentHandler::openForReading() Open failed."
              " Error: %d", error);
        throw EIO;
    }

    mReadPosition = 0;
}

void FileDRMContentHandler::openForWriting(const long /*aOffset*/)
{
    JELOG2(EJavaFile);
    // NOTE: There is no write for DRM protected content. We should not be here.
    ELOG(EJavaFile, "FileDRMContentHandler::openForWriting(): "
         " Trying to write into DRM file. Throwing exception EPERM.");
    throw EPERM;
}

void FileDRMContentHandler::closeFileToReopen()
{
    JELOG2(EJavaFile);
    // We never close file to re-open again.
}

void FileDRMContentHandler::handleReopenCase()
{
    JELOG2(EJavaFile);
    // File is never closed temporarily in case of DRM files.
    // Kept for future use.
}

long FileDRMContentHandler::available()
{
    JELOG2(EJavaFile);
    TInt fileLength = 0;
    TRAPD(error, CallMethodL(mData, &ContentAccess::CData::DataSizeL,
                             fileLength, mFunctionServer));

    TInt total = 0;
    if (KErrNone == error)
    {
        total = fileLength - mReadPosition;
    }

    LOG1(EJavaFile, EInfo, "FileDRMContentHandler::available: Returning: %d",
         total);
    return total;
}