/*
* Copyright (c) 2008-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:  JavaStorageImpl
*
*/


#include "javacommonutils.h"
#include "javaoslayer.h"
#include "javastorageimpl.h"
#include "javastorageexception.h"
#include "javastoragenames.h"
#include "javauid.h"
#include "logger.h"
#include "messagedispatcher.h"

const int CLOSED = 0;
const int OPEN = 1;

using namespace java::storage;
using namespace java::util;
using namespace std;

JavaStorageImpl::JavaStorageImpl()
        : mConnectionStatus(CLOSED), mTransactionStatus(CLOSED)
{
    JELOG2(EJavaStorage);
    mMsgDispatcher.reset(new MessageDispatcher());
}

OS_EXPORT JavaStorageImpl::~JavaStorageImpl()
{
    if (OPEN == mConnectionStatus)
    {
        close();
    }
}

OS_EXPORT void JavaStorageImpl::open() throw(JavaStorageException)
{
    open(JAVA_DATABASE_NAME);
}

OS_EXPORT void JavaStorageImpl::open(const std::string& aStorageName)
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (CLOSED == mConnectionStatus)
    {
        LOG1(EJavaStorage, EInfo, "Opening connection to %s ",
             aStorageName.c_str());

        if (aStorageName == "")
        {
            throw JavaStorageException(EInvalidStorage, "Invalid storage name",
                                       __FILE__, __FUNCTION__, __LINE__);
        }

        mSessionID = mMsgDispatcher->createAndSendMessage(
                         JavaStorageMessage::EOpen, "", aStorageName);

        if (mSessionID == "")
        {
            ELOG(EJavaStorage, "No sessionID received");
            throw JavaStorageException(EInternalError, "Internal Server Error",
                                       __FILE__, __FUNCTION__, __LINE__);
        }

        LOG1(EJavaStorage, EInfo, "Connection sessionID %s ",
             mSessionID.c_str());

        mConnectionStatus = OPEN;
    }
    else
    {
        WLOG(EJavaStorage, "Connection already open");
    }
}

OS_EXPORT void JavaStorageImpl::close() throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN == mConnectionStatus)
    {
        string tempSessionId = mSessionID;
        mSessionID = "";    // Clean in one place.
        mConnectionStatus = CLOSED;
        mTransactionStatus = CLOSED;

        mMsgDispatcher->createAndSendMessage(JavaStorageMessage::EClose,
                                             tempSessionId,
                                             "");
    }
    else
    {
        WLOG(EJavaStorage, "Connection not open");
    }
}

OS_EXPORT void JavaStorageImpl::startTransaction() throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN == mConnectionStatus
            && CLOSED == mTransactionStatus)
    {
        mMsgDispatcher->createAndSendMessage(
            JavaStorageMessage::EStartTransaction, mSessionID, "");

        mTransactionStatus = OPEN;
    }
    else
    {
        WLOG(EJavaStorage, "Cannot open new transaction because \
            connection closed or already in trasaction");
    }
}

OS_EXPORT void JavaStorageImpl::commitTransaction()
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN == mConnectionStatus && OPEN == mTransactionStatus)
    {
        mTransactionStatus = CLOSED;

        mMsgDispatcher->createAndSendMessage(
            JavaStorageMessage::ECommit, mSessionID, "");
    }
    else
    {
        WLOG(EJavaStorage,
             "Cannot commit because connection closed or not in trasaction");
    }
}

OS_EXPORT void JavaStorageImpl::rollbackTransaction()
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN == mConnectionStatus && OPEN == mTransactionStatus)
    {
        mTransactionStatus = CLOSED;

        mMsgDispatcher->createAndSendMessage(
            JavaStorageMessage::ERollback, mSessionID, "");
    }
    else
    {
        /*
         * Transaction is reset. If connection is already closed there is no
         * possibility to recover transaction. SQLite DB will create hot journal
         * and create auto-rollback at some stage. To prevent that storage
         * server does rollback if close is called while in transaction. This
         * way server and client transactions keep in sync.
         */
        mTransactionStatus = CLOSED;
        WLOG(EJavaStorage,
             "Cannot rollback because connection closed or not in trasaction");
    }
}

OS_EXPORT void JavaStorageImpl::read(const string& aTablename,
                                     const Uid& aUid,
                                     JavaStorageApplicationEntry_t& aEntries)
throw(JavaStorageException)

{
    JELOG2(EJavaStorage);

    if (OPEN != mConnectionStatus)
    {
        throw JavaStorageException(EInvalidConnection, "No connection",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    if (aTablename == "" || aUid.toString() == L"")
    {
        throw JavaStorageException(EInvalidArgument, "Invalid argument",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    JavaStorageEntry entry;
    entry.setEntry(ID, aUid.toString());
    aEntries.insert(entry);

    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::ERead,
                                         mSessionID,
                                         aTablename,
                                         aEntries);
}

OS_EXPORT void JavaStorageImpl::write(
    const string& aTablename,
    const JavaStorageApplicationEntry_t& aEntries)
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN != mConnectionStatus)
    {
        throw JavaStorageException(EInvalidConnection, "No connection",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    if (aTablename == "" || aEntries.size() == 0)
    {
        throw JavaStorageException(EInvalidArgument, "Invalid argument",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::EWrite,
                                         mSessionID,
                                         aTablename,
                                         aEntries);
}

OS_EXPORT void JavaStorageImpl::update(
    const string& aTablename,
    const JavaStorageApplicationEntry_t& aUpdateEntry,
    const JavaStorageApplicationEntry_t& aMatchEntry)
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN != mConnectionStatus)
    {
        throw JavaStorageException(EInvalidConnection, "No connection",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    if (aTablename == "" || aUpdateEntry.size() < 1 || aMatchEntry.size() < 1)
    {
        throw JavaStorageException(EInvalidArgument, "Invalid argument",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    mMsgDispatcher->handleUpdate(JavaStorageMessage::EUpdate,
                                 mSessionID,
                                 aTablename,
                                 aUpdateEntry,
                                 aMatchEntry);
}

OS_EXPORT void JavaStorageImpl::search(
    const string& aTablename,
    const JavaStorageApplicationEntry_t& aSearchPattern,
    JavaStorageApplicationList_t& aApplicationList)
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN != mConnectionStatus)
    {
        throw JavaStorageException(EInvalidConnection, "No connection",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    if (aTablename == "")
    {
        throw JavaStorageException(EInvalidArgument, "Invalid argument",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    mMsgDispatcher->handleSearch(JavaStorageMessage::ESearch,
                                 mSessionID,
                                 aTablename,
                                 aSearchPattern,
                                 aApplicationList);
}

OS_EXPORT int JavaStorageImpl::remove(
    const std::string& aTablename,
    const JavaStorageApplicationEntry_t& aRemoveQuery)
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (aTablename == "")
    {
        throw JavaStorageException(EInvalidArgument, "Invalid argument",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    if (OPEN != mConnectionStatus)
    {
        throw JavaStorageException(EInvalidConnection, "No connection",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    return mMsgDispatcher->createAndSendMessage(JavaStorageMessage::ERemove,
            mSessionID,
            aTablename,
            aRemoveQuery);
}

OS_EXPORT void JavaStorageImpl::createTable(
    const string& aTablename,
    const JavaStorageApplicationEntry_t& aTableColumns)
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN != mConnectionStatus)
    {
        throw JavaStorageException(EInvalidConnection, "No connection",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    if (aTablename == "" || aTableColumns.size() < 1)
    {
        throw JavaStorageException(EInvalidArgument, "Invalid argument",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::ECreateTable,
                                         mSessionID,
                                         aTablename,
                                         aTableColumns);
}

OS_EXPORT void JavaStorageImpl::appendTable(
    const string& aTablename,
    const JavaStorageApplicationEntry_t& aTableColumns)
throw(JavaStorageException)
{
    JELOG2(EJavaStorage);

    if (OPEN != mConnectionStatus)
    {
        throw JavaStorageException(EInvalidConnection, "No connection",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    if (aTablename == "" || aTableColumns.size() < 1)
    {
        throw JavaStorageException(EInvalidArgument, "Invalid argument",
                                   __FILE__, __FUNCTION__, __LINE__);
    }

    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::EAppendTable,
                                         mSessionID,
                                         aTablename,
                                         aTableColumns);
}