/* $Id$
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version
 * 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "support/EtchPlainMailbox.h"
#include "transport/EtchPlainMailboxManager.h"
#include "serialization/EtchDefaultValueFactory.h"

class MockSession : public EtchSessionMessage {
public:

  status_t sessionMessage(capu::SmartPointer<EtchWho> receipent, capu::SmartPointer<EtchMessage> buf) {
    return ETCH_OK;
  }

  status_t sessionQuery(capu::SmartPointer<EtchObject> query, capu::SmartPointer<EtchObject> &result) {
    return ETCH_OK;
  }

  status_t sessionControl(capu::SmartPointer<EtchObject> control, capu::SmartPointer<EtchObject> value) {
    return ETCH_OK;
  }

  status_t sessionNotify(capu::SmartPointer<EtchObject> event) {
    return ETCH_OK;
  }
};

class MockTransport : public EtchTransportMessage {
public:

  status_t transportMessage(capu::SmartPointer<EtchWho> recipient, capu::SmartPointer<EtchMessage> message) {
    return ETCH_OK;
  }

  MOCK_METHOD0(getSession, EtchSessionMessage* ());

  void setSession(EtchSessionMessage* session) {

  }

  status_t transportQuery(capu::SmartPointer<EtchObject> query, capu::SmartPointer<EtchObject> *result) {
    return ETCH_OK;
  }

  status_t transportControl(capu::SmartPointer<EtchObject> control, capu::SmartPointer<EtchObject> value) {
    return ETCH_OK;
  }

  status_t transportNotify(capu::SmartPointer<EtchObject> event) {
    return ETCH_OK;
  }
};

class MockDefaultValueFactory {
public:
  EtchTypeMap types;
  EtchClass2TypeMap class2type;
  EtchDefaultValueFactory * factory;
  /**
   * Constructs the MyValueFactory.
   * @param uri
   */
public:

  MockDefaultValueFactory(EtchRuntime* runtime, EtchString uri) {
    EtchDefaultValueFactory::Init(runtime, &types, &class2type);
    factory = new EtchDefaultValueFactory(uri, &types, &class2type);
  }

  ~MockDefaultValueFactory() {
    delete factory;
    types.clear();
  }
};

class EtchPlainMailboxManagerTest
  : public ::testing::Test {
protected:
  virtual void SetUp() {
    mRuntime = new EtchRuntime();
    mRuntime->start();
  }

  virtual void TearDown() {
    mRuntime->shutdown();
    delete mRuntime;
    mRuntime = NULL;
  }

  EtchRuntime* mRuntime;
};

TEST_F(EtchPlainMailboxManagerTest, constructorTest) {
  MockTransport *transport = new MockTransport();
  MockSession session;
  MockDefaultValueFactory *factory;
  EtchString uri("tcp://127.0.0.1:4001");
  factory = new MockDefaultValueFactory(mRuntime, uri);
  //created value factory
  EtchURL u(uri);
  EtchMailboxManager * manager = NULL;
  manager = new EtchPlainMailboxManager(mRuntime, transport, NULL, NULL);

  EXPECT_TRUE(manager != NULL);
  manager->setSession(&session);

  delete transport;
  delete manager;
  delete factory;
}

TEST_F(EtchPlainMailboxManagerTest, transportMessageTest) {
  EtchString uri("tcp://127.0.0.1:4001");
  MockDefaultValueFactory *factory;
  factory = new MockDefaultValueFactory(mRuntime, uri);
  //initialization
  EtchType * type;
  capu::SmartPointer<EtchValidator> val = NULL;
  EtchValidatorLong::Get(mRuntime, 0, val);

  factory->types.get("add", type);
  type->putValidator(EtchDefaultValueFactory::_mf__messageId(), val);
  capu::SmartPointer<EtchMessage> message = new EtchMessage(type, factory->factory);

  capu::int64_t id;
  EXPECT_TRUE(ETCH_OK != message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));

  MockTransport *transport = new MockTransport();
  MockSession session;

  EtchURL u(uri);
  EtchPlainMailboxManager * manager = NULL;
  manager = new EtchPlainMailboxManager(mRuntime, transport, NULL, NULL);

  manager->setSession(&session);

  EXPECT_TRUE(ETCH_OK == manager->transportMessage(NULL, message));
  EXPECT_EQ(0u, manager->count());
  EXPECT_TRUE(ETCH_OK == message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));

  capu::SmartPointer<EtchMailbox> mail;
  EXPECT_TRUE(ETCH_OK != manager->getMailbox(id, mail));

  message->clear();

  delete transport;
  delete manager;
  delete factory;
}

TEST_F(EtchPlainMailboxManagerTest, transportResultMessageTest) {
  EtchString uri("tcp://127.0.0.1:4001");
  MockDefaultValueFactory *factory;
  factory = new MockDefaultValueFactory(mRuntime, uri);
  //initialization
  EtchType * type;
  capu::SmartPointer<EtchValidator> val = NULL;
  EtchValidatorLong::Get(mRuntime, 0, val);

  factory->types.get("add_result", type);
  type->putValidator(EtchDefaultValueFactory::_mf__messageId(), val);
  type->putValidator(EtchDefaultValueFactory::_mf__inReplyTo(), val);
  capu::SmartPointer<EtchMessage> message = new EtchMessage(type, factory->factory);

  capu::int64_t id;
  EXPECT_TRUE(ETCH_OK != message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));

  message->setInReplyToMessageId(1L);

  MockTransport *transport = new MockTransport();
  MockSession session;

  EtchURL u(uri);
  EtchPlainMailboxManager * manager = NULL;
  manager = new EtchPlainMailboxManager(mRuntime, transport, NULL, NULL);

  manager->setSession(&session);

  EXPECT_TRUE(ETCH_OK == manager->transportMessage(NULL, message));
  EXPECT_EQ(0u, manager->count());
  EXPECT_TRUE(ETCH_OK == message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK == message->getInReplyToMessageId(id));
  EXPECT_TRUE(id == 1L);
  capu::SmartPointer<EtchMailbox> mail;
  EXPECT_TRUE(ETCH_OK != manager->getMailbox(id, mail));

  message->clear();

  delete transport;
  delete manager;
  delete factory;
}

TEST_F(EtchPlainMailboxManagerTest, transportCallTest) {
  EtchString uri("tcp://127.0.0.1:4001");
  MockDefaultValueFactory *factory;
  factory = new MockDefaultValueFactory(mRuntime, uri);
  //initialization
  EtchType * type;
  capu::SmartPointer<EtchValidator> val = NULL;
  EtchValidatorLong::Get(mRuntime, 0, val);

  factory->types.get("add", type);
  type->putValidator(EtchDefaultValueFactory::_mf__messageId(), val);
  capu::SmartPointer<EtchMessage> message = new EtchMessage(type, factory->factory);

  capu::int64_t id;
  EXPECT_TRUE(ETCH_OK != message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));

  MockTransport *transport = new MockTransport();
  MockSession session;

  EtchURL u(uri);
  EtchPlainMailboxManager * manager = NULL;
  manager = new EtchPlainMailboxManager(mRuntime, transport, NULL, NULL);

  manager->setSession(&session);
  //in order to notify upper layers that the connection is open
  manager->sessionNotify(new EtchString(EtchSession::UP()));

  capu::SmartPointer<EtchMailbox> mail;
  EXPECT_TRUE(ETCH_OK == manager->transportCall(NULL, message, mail));
  EXPECT_EQ(1u, manager->count());
  EXPECT_TRUE(ETCH_OK == message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));

  capu::SmartPointer<EtchMailbox> out;
  EXPECT_TRUE(ETCH_OK == manager->getMailbox(id, out));

  message->clear();

  delete transport;
  delete manager;
  delete factory;
}

TEST_F(EtchPlainMailboxManagerTest, replicatedTransportCallTest) {
  EtchString uri("tcp://127.0.0.1:4001");
  MockDefaultValueFactory *factory;
  factory = new MockDefaultValueFactory(mRuntime, uri);
  //initialization
  EtchType * type;
  capu::SmartPointer<EtchValidator> val = NULL;
  EtchValidatorLong::Get(mRuntime, 0, val);

  factory->types.get("add", type);
  type->putValidator(EtchDefaultValueFactory::_mf__messageId(), val);
  capu::SmartPointer<EtchMessage> message = new EtchMessage(type, factory->factory);

  capu::int64_t id;
  EXPECT_TRUE(ETCH_OK != message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));

  MockTransport *transport = new MockTransport();
  MockSession session;

  // test sending a call message that has already been sent (has a message id)
  message->setMessageId(2);

  EtchURL u(uri);
  EtchPlainMailboxManager * manager = NULL;
  manager = new EtchPlainMailboxManager(mRuntime, transport, NULL, NULL);

  manager->setSession(&session);
  //in order to notify upper layers that the connection is open
  manager->sessionNotify(new EtchString(EtchSession::UP()));

  capu::SmartPointer<EtchMailbox> mail;
  EXPECT_TRUE(ETCH_ERROR == manager->transportCall(NULL, message, mail));
  //should not create a mailbox
  EXPECT_EQ(ETCH_OK, message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));
  //there should be no mailbox
  EXPECT_TRUE(ETCH_OK != manager->getMailbox(id, mail));

  message->clear();

  delete transport;
  delete manager;
  delete factory;
}

TEST_F(EtchPlainMailboxManagerTest, sessionMessageTest) {
  EtchString uri("tcp://127.0.0.1:4001");
  MockDefaultValueFactory *factory;
  factory = new MockDefaultValueFactory(mRuntime, uri);
  //initialization
  EtchType * type;
  EtchType * replyType;
  capu::SmartPointer<EtchValidator> val = NULL;
  EtchValidatorLong::Get(mRuntime, 0, val);

  factory->types.get("add_result", replyType);
  factory->types.get("add", type);
  type->putValidator(EtchDefaultValueFactory::_mf__messageId(), val);
  replyType->putValidator(EtchDefaultValueFactory::_mf__inReplyTo(), val);
  replyType->putValidator(EtchDefaultValueFactory::_mf__messageId(), val);
  capu::SmartPointer<EtchMessage> message = new EtchMessage(type, factory->factory);

  capu::int64_t id;
  EXPECT_TRUE(ETCH_OK != message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));

  MockTransport *transport = new MockTransport();
  MockSession session;

  EtchURL u(uri);
  EtchPlainMailboxManager * manager = NULL;
  manager = new EtchPlainMailboxManager(mRuntime, transport, NULL, NULL);

  manager->setSession(&session);
  //in order to notify upper layers that the connection is open
  manager->sessionNotify(new EtchString(EtchSession::UP()));

  //perform the call
  capu::SmartPointer<EtchMailbox> mail;
  EXPECT_TRUE(ETCH_OK == manager->transportCall(NULL, message, mail));
  EXPECT_EQ(1u, manager->count());
  EXPECT_TRUE(ETCH_OK == message->getMessageId(id));
  EXPECT_TRUE(ETCH_OK != message->getInReplyToMessageId(id));
  //get the created mailbox
  EXPECT_TRUE(ETCH_OK == manager->getMailbox(id, mail));

  capu::SmartPointer<EtchMessage> replymessage;
  //create a reply message
  message->createReplyMessage(replyType, replymessage);
  EXPECT_TRUE(ETCH_OK == replymessage->getInReplyToMessageId(id));
  capu::SmartPointer<EtchMessage> replymess = replymessage;

  //test the notification mechanism of mailbox manager
  EXPECT_TRUE(ETCH_OK == manager->sessionMessage(NULL, replymess));
  EtchMailbox::EtchElement* x;
  //check if the reply message is delivered to the correct mailbox
  EXPECT_TRUE(ETCH_OK == mail->read(x));
  EXPECT_TRUE(NULL == x->mSender.get());
  EXPECT_TRUE(replymessage.get() == x->mMsg.get());

  //deallocations
  delete x;
  delete transport;
  delete manager;
  delete factory;
}