/**

   This file is part of CWRT package **

   Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). **

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU (Lesser) General Public License as

   published by the Free Software Foundation, version 2.1 of the License.

   This program is distributed in the hope that it will be useful, but

   WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

   (Lesser) General Public License for more details. You should have

   received a copy of the GNU (Lesser) General Public License along

   with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include <QByteArray>

#include "serviceipclocalsocket_p.h"

namespace WRT

{

// CONSTANTS

const char* REQUEST_COMPLETE_TOKEN = ";ROK";

const int REQUEST_COMPLETE_TOKEN_LENGTH = 4;

const char REQUEST_DELIMITER_TOKEN = ';';

/*!

 \class ServiceLocalSocketIPC

 QLocalSocket based IPC client-side backend

 */

/*!

 Constructor

 */

ServiceLocalSocketIPC::ServiceLocalSocketIPC() : m_BufferType( ENoBuffer )

{

    m_Socket = new QLocalSocket();

    QObject::connect(m_Socket, SIGNAL( error( QLocalSocket::LocalSocketError ) ),

    this, SLOT( handleError( QLocalSocket::LocalSocketError ) ) );

}

/*!

 Destructor

 */

ServiceLocalSocketIPC::~ServiceLocalSocketIPC()

{

    delete m_Socket;

}

/*!

 Connect to the server

 @param aServerName name of the server to connect to

 @return true if connected, false otherwise

 */

bool ServiceLocalSocketIPC::connect(const QString& aServerName)

{

    bool rtn;

    m_Socket->connectToServer(aServerName);

    rtn = m_Socket->waitForConnected();

    return rtn;

}

/*!

 Disconnect from the server

 */

void ServiceLocalSocketIPC::disconnect()

{

    m_Socket->close();

}

/*!

 Starts the service

 @param aServerName name of the server to connect to

 @param aExeName name of the server executable

 @return true if server started, false otherwise

 */

bool ServiceLocalSocketIPC::startServer(const QString& aServerName,

                                        const QString& aExeName)

{

    bool started(true);

    //Semaphore with 1 initial count,

    //Use system semaphore to ensure no contention exists across multiple processes

    //According to QT documentation for System Semaphores on Windows, 

    //the semaphore is automatically cleaned up if a process crashes, thus preventing deadlock

    //

    QSystemSemaphore funcSem(aServerName + FUNCTIONSEM, 1);

    funcSem.acquire();

    // Shared chunk to check if the server has been started or not

    QSharedMemory sharedMem(aServerName);

    char* data(NULL);

    bool attached = sharedMem.attach();

    if (attached) {

        data = (char*) sharedMem.data();

    }

    // Shared memory not created or the flag was not set properly

    if (!attached || strcmp(data, SERVERNOTSTARTED) == 0) {

        // Create the server wait semaphore. When the server has listened, 

        // it will signaled after listen has started

        //

        QSystemSemaphore sem(aServerName + SERVERSEM, 0);

        // Start the server, since this function is mutex'ed by the global semaphore 

        // only 1 process/thread can reach here

        //

        started = QProcess::startDetached(aExeName);

        // Wait until the server signals

        if (started) {

            sem.acquire();

        }

    }

    // Test if server started successfully

#if _DEBUG

    attached = sharedMem.attach();

    if( attached )

    {

        data = (char*)sharedMem.data();

        if( strcmp( data, SERVERSTARTED ) == 0 )

        {

            qDebug() << "Server Started Successfully";

        }

    }

#endif // _DEBUG

    // Free shared memory

    sharedMem.detach();

    // Release the function semaphore

    funcSem.release(1);

    return started;

}

/*!

 Send a request synchronously

 @param aRequestType type of request, toAscii() will be called to serialize the data

 @param aData aData data to send to the server

 @return true if data is sent, false otherwise

 */

bool ServiceLocalSocketIPC::sendSync(const QString& aRequestType,

                                     const QByteArray& aData)

{

    QByteArray data;

    data.setNum(aData.length());

    data.append(REQUEST_DELIMITER_TOKEN);

    data.append(aRequestType.toAscii());

    data.append(REQUEST_DELIMITER_TOKEN);

    data.append(aData);

    int count = m_Socket->write(data);

    m_Socket->flush();

    m_BufferType = ESyncBuffer;

    return (count > 0);

}

/*!

 Send a request asynchronously

 @param aRequestType type of request, toAscii() will be called to serialize the data

 @param aData data to send to the server

 */

void ServiceLocalSocketIPC::sendAsync(const QString& aRequestType,

                                      const QByteArray& aData)

{

    QByteArray data;

    data.setNum(aData.length());

    data.append(REQUEST_DELIMITER_TOKEN);

    data.append(aRequestType.toAscii());

    data.append(REQUEST_DELIMITER_TOKEN);

    data.append(aData);

    m_Socket->write(data);

    // Connect the signal and reset aync data buffer

    m_AsyncData.clear();

    QObject::connect(m_Socket, SIGNAL( readyRead() ),

    this, SLOT( handleReadyRead() ) );

    m_BufferType = EAsyncBuffer;

}

/*!

 Reads all data pending in the buffer

 @return QByteArray data that has been read

 */

QByteArray ServiceLocalSocketIPC::readAll()

{

    QByteArray result;

    // If asynchronous read all data from the socket 

    //

    if ( m_BufferType == ESyncBuffer ) {

        // Wait for all data to be completed before returning

        //

        bool done = false;

        do {

            result.append(m_Socket->readAll());

            if (result.right(REQUEST_COMPLETE_TOKEN_LENGTH)

                            == REQUEST_COMPLETE_TOKEN) {

                // Chop the end token

                result.chop(REQUEST_COMPLETE_TOKEN_LENGTH);

                done = true;

            }

        } while (done == false);

    }

    // If async, return the internal databuffer

    else if( m_BufferType == EAsyncBuffer ){

        // Should be just a d-ptr copy

        result = m_AsyncData;

        QObject::disconnect(m_Socket, SIGNAL( readyRead() ),

        this, SLOT( handleReadyRead() ) );

    }

    m_BufferType = ENoBuffer;

    return result;

}

/*!

 Waits until data is available for reading 

 @return bool true if data can be read

 */

bool ServiceLocalSocketIPC::waitForRead()

{

    return m_Socket->waitForReadyRead();

}

/*!

 Handle any socket errors

 @param socketError error

 */

void ServiceLocalSocketIPC::handleError(QLocalSocket::LocalSocketError aSocketError)

{

    // Use base class to send this

    emitError(doMapErrors(aSocketError));

}

/*!

 Handle when data is ready to be read

 */

void ServiceLocalSocketIPC::handleReadyRead()

{

    m_AsyncData.append(m_Socket->readAll());

    if (m_AsyncData.right(REQUEST_COMPLETE_TOKEN_LENGTH)

                    == REQUEST_COMPLETE_TOKEN) {

        // Chop the end token

        m_AsyncData.chop(REQUEST_COMPLETE_TOKEN_LENGTH);

        // Use base class to send signal when all the data has been assembled

        emitReadyRead();

    }

}

int ServiceLocalSocketIPC::doMapErrors( int aError )

{

    int error(0);

    // Map QT Local Socket error codes to custom error codes

    //

    switch( aError ) {

    case QLocalSocket::ConnectionError:

    case QLocalSocket::ConnectionRefusedError: {

        error = ServiceFwIPC::EConnectionError;

        break;

        }

    case QLocalSocket::PeerClosedError: {

        error = ServiceFwIPC::EConnectionClosed;

        break;

        } 

    case QLocalSocket::ServerNotFoundError: {

        error = ServiceFwIPC::EServerNotFound;

        break;

        } 

    case QLocalSocket::SocketAccessError:

    case QLocalSocket::SocketResourceError:

    case QLocalSocket::SocketTimeoutError:

    case QLocalSocket::DatagramTooLargeError:

    case QLocalSocket::UnsupportedSocketOperationError: {

        error = ServiceFwIPC::EIPCError;

        break;

        }    

    case QLocalSocket::UnknownSocketError: {

        error = ServiceFwIPC::EUnknownError;

        break;

        }

    }

    return error;

}

}

// END OF FILE