/*
* 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:  ?Description
*
*/

#include <errno.h>
#include "monitor.h"
#include "TestHarness.h"
#include "logger.h"

#include "commsserverendpoint.h"
#include "commsclientendpoint.h"
#include "commsmessage.h"
#include "echoserver.h"

using namespace java::comms;
using java::util::Monitor;

TEST_GROUP(Connect)
{
    CommsServerEndpoint comms;

    TEST_SETUP()
    {
        comms.start(IPC_ADDRESS_COMMS_MODULE_TEST);
    }

    TEST_TEARDOWN()
    {
        comms.stop();
    }
};

/**
 * Test open connection
 * 1. Normal connect, disconnect
 * 2. Multiple connect calls without disconnect
 * 3. Disconnect before connect
 * 4. Connect to non-existing host
 */

TEST(Connect, OpenConnection)
{
    CommsClientEndpoint client;

    // 1. Normal connect, disconnect
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!client.disconnect());

    // 2. Multiple connect calls without disconnect
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!client.disconnect());

    // 3. Disconnect before connect
    CHECK(!client.disconnect());
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!client.disconnect());

    // 4. Connect to non-existing host
    CHECK(client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+666));
    CHECK(!client.disconnect());
}

/**
 * Test open connection with multiple clients
 * 1. Normal connect, disconnect
 * 2. Multiple connect/disconnects
 */

TEST(Connect, MultiClient)
{
    CommsClientEndpoint a, b, c, d, e;

    // 1. Normal connect, disconnect
    CHECK(!a.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!b.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!c.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!d.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!e.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!e.disconnect());
    CHECK(!d.disconnect());
    CHECK(!c.disconnect());
    CHECK(!b.disconnect());
    CHECK(!a.disconnect());

    // 2. Multiple connect/disconnects
    for (int i=0; i<10; i++)
    {
        CHECK(!a.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
        CHECK(!b.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
        CHECK(!c.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
        CHECK(!d.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
        CHECK(!e.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
        CHECK(!e.disconnect());
        CHECK(!d.disconnect());
        CHECK(!c.disconnect());
        CHECK(!b.disconnect());
        CHECK(!a.disconnect());
    }
}

/**
 * Test server cases
 * 1. Server exits while client is connected
 * 2. Address is already in use
 * 3. Start/Connect using different addresses
 */

TEST(Connect, Server)
{
    CommsServerEndpoint server;
    CommsClientEndpoint client;
    int ADDR = IPC_ADDRESS_COMMS_MODULE_TEST + 1;

    // 1. Server exits while client is connected
    CHECK(!server.start(ADDR));
    CHECK(!client.connect(ADDR));
    CHECK(!server.stop());
    CHECK(!client.disconnect());

    // 2. Address is already in use
    CHECK(server.start(IPC_ADDRESS_COMMS_MODULE_TEST)!=0);
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!server.stop());
    CHECK(!client.disconnect());

    // 3. Start/Connect using different addresses
    CHECK(!server.start(ADDR));
    CHECK(!client.connect(ADDR));
    CHECK(!client.disconnect());
    CHECK(!server.stop());

    CHECK(!server.start(ADDR+1));
    CHECK(!client.connect(ADDR+1));
    CHECK(!client.disconnect());
    CHECK(!server.stop());

}

/**
 * Test connect/disconnect from separate threads
 * 1. connect/disconnect from separate threads
 * 2. start/stop from separate threads
 */

void doDisconnect(CommsClientEndpoint* aClient)
{
    CHECK(!aClient->disconnect());
}
void* disconnectThread(void* aComms)
{
    CommsClientEndpoint* client = reinterpret_cast<CommsClientEndpoint*>(aComms);
    doDisconnect(client);
    return 0;
}

void doStop(CommsServerEndpoint* aServer)
{
    CHECK(!aServer->stop());
}
void* stopThread(void* aComms)
{
    CommsServerEndpoint* server = reinterpret_cast<CommsServerEndpoint*>(aComms);
    doStop(server);
    return 0;
}

TEST(Connect, separateThread)
{
    CommsServerEndpoint server;
    CommsClientEndpoint client;
    int ADDR = IPC_ADDRESS_COMMS_MODULE_TEST + 1;

    CommsMessage msg;

    // 1. connect/disconnect from separate threads
    CHECK(!server.start(ADDR));
    CHECK(!client.connect(ADDR));

    CHECK(client.send(msg) == 0);
    pthread_t threadId = 0;
    pthread_create(&threadId, 0, disconnectThread, &client);
    pthread_join(threadId, 0);
    CHECK(client.send(msg) != 0);

    // 2. start/stop from separate threads
    pthread_create(&threadId, 0, stopThread, &server);
    pthread_join(threadId, 0);

    CommsServerEndpoint server2;
    CHECK(!server2.start(ADDR));
    CHECK(!server2.stop());
}

/**
 * Check that onStart and onExit callbacks are done
 * (ensures that ipc provider implementation is done correctly)
 * 1. Callbacks are done after connect/disconnect
 * 2. Callbacks are done after start/stop
 */

class OnStartExitClient : public CommsClientEndpoint
{
public:
    OnStartExitClient() : mOnStart(false), mOnExit(false) {}

    virtual void onStart()
    {
        mOnStart = true;
    }
    virtual void onExit()
    {
        mOnExit = true;
    }

    bool mOnStart;
    bool mOnExit;
};

class OnStartExitServer : public CommsServerEndpoint
{
public:
    OnStartExitServer() : mOnStart(false), mOnExit(false) {}

    virtual void onStart()
    {
        mOnStart = true;
    }
    virtual void onExit()
    {
        mOnExit = true;
    }

    bool mOnStart;
    bool mOnExit;
};

TEST(Connect, onStartExit)
{
    // 1. Callbacks are done after connect/disconnect
    OnStartExitClient client;
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
    CHECK(!client.disconnect());
    CHECK(client.mOnStart);
    CHECK(client.mOnExit);

    // 2. Callbacks are done after start/stop
    OnStartExitServer server;
    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
    CHECK(!server.stop());
    CHECK(server.mOnStart);
    CHECK(server.mOnExit);
}


/**
 * Test disconnect/stop while sendReceive is pending
 * 1. disconnect while sendReceive is pending in client
 * 2. stop while sendReceive is pending in client
 * 3. disconnect while sendReceive is pending in server
 * 4. stop while sendReceive is pending in server
 */

void doSendReceive(CommsEndpoint* aComms)
{
    CommsMessage msg;
    msg.setModuleId(MODULE_ID_NO_REPLY);
    CommsMessage receivedMsg;

    int rc = aComms->sendReceive(msg, receivedMsg, 3);
    CHECK(rc != 0);
    CHECK(rc != ETIMEDOUT);

    // check that next send fails as other party is disconnected
    // (and receive thread may still be running depending on timing)
    rc = aComms->send(msg);
    CHECK(rc != 0);
}

void* sendReceiveThread(void* aComms)
{
    CommsEndpoint* comms = reinterpret_cast<CommsEndpoint*>(aComms);
    doSendReceive(comms);
    return 0;
}

class Notifier : public CommsListener
{
public:
    Notifier(Monitor& aMonitor) : mMonitor(aMonitor) {}
    virtual void processMessage(CommsMessage&)
    {
        mMonitor.notify();

    }
private:
    Monitor& mMonitor;
};

struct threadData
{
    CommsEndpoint* comms;
    int clientAddress;
};

void doServer(CommsEndpoint* aComms, int aAddress)
{
    CommsMessage msg;
    msg.setReceiver(aAddress);
    CommsMessage receivedMsg;

    int rc = aComms->sendReceive(msg, receivedMsg, 3);
    CHECK(rc != 0);
    CHECK(rc != ETIMEDOUT);
}

void* serverThread(void* aData)
{
    threadData* data = reinterpret_cast<threadData*>(aData);
    doServer(data->comms, data->clientAddress);
    delete data;
    return 0;
}

class ServerListener : public CommsListener
{
public:
    ServerListener(CommsEndpoint& aComms) : mComms(aComms) {}
    virtual void processMessage(CommsMessage& aMsg)
    {
        threadData* data = new threadData;
        data->comms = &mComms;
        data->clientAddress = aMsg.getSender();
        pthread_t threadId = 0;
        pthread_create(&threadId, 0, serverThread, data);
    }
private:
    CommsEndpoint& mComms;
};

TEST(Connect, sendReceivePending)
{
    std::auto_ptr<Monitor> monitor(Monitor::createMonitor());

    Notifier listener(*monitor);
    CommsClientEndpoint client;

    // 1. disconnect while sendReceive is pending in client
    CHECK(!comms.registerDefaultListener(&listener));
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));

    pthread_t threadId = 0;
    pthread_create(&threadId, 0, sendReceiveThread, &client);

    monitor->wait();
    CHECK(!client.disconnect());

    pthread_join(threadId, 0);
    CHECK(!comms.unregisterDefaultListener(&listener));

    // 2. stop while sendReceive is pending in client
    CommsServerEndpoint server;
    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
    CHECK(!server.registerDefaultListener(&listener));

    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));

    threadId = 0;
    pthread_create(&threadId, 0, sendReceiveThread, &client);

    monitor->wait();
    CHECK(!server.stop());

    pthread_join(threadId, 0);
    CHECK(!client.disconnect());
    CHECK(!server.unregisterDefaultListener(&listener));

    // 3. disconnect while sendReceive is pending in server
    ServerListener serverListener(server);

    CHECK(!server.registerDefaultListener(&serverListener));
    CHECK(!client.registerDefaultListener(&listener));

    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));

    CommsMessage msg;
    CHECK(!client.send(msg));
    monitor->wait();
    CHECK(!client.disconnect());

    CHECK(!server.stop());
    CHECK(!server.unregisterDefaultListener(&serverListener));
    CHECK(!client.unregisterDefaultListener(&listener));

    // 4. stop while sendReceive is pending in server
    CHECK(!server.registerDefaultListener(&serverListener));
    CHECK(!client.registerDefaultListener(&listener));

    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));

    CHECK(!client.send(msg));
    monitor->wait();
    CHECK(!server.stop());

    CHECK(!client.disconnect());
    CHECK(!server.unregisterDefaultListener(&serverListener));
    CHECK(!client.unregisterDefaultListener(&listener));
}