/*
 * TestInputDriver.cpp
 *
 *  Created on: May 31, 2018
 *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert, Rafael Vinci, Dr. Franca Rupprecht
 */

#include "catch.hpp"
#include "fakeit.hpp"
#include "utilities/LoggerFactory.hpp"

// testing purposes
#define private public

#include "input/InputDriver.h"

#include "input/IEventNotifier.h"
#include "input/IDetector.h"


using namespace fakeit;
using namespace Input;

SCENARIO("An InputDriver gets created", "[construction}")
{
  GIVEN("An EventNotifier and a Detector")
  {
    LoggerFactory::CreateInputTestLogger();

    Mock<IDetector> detector_mock;
    Fake(Dtor(detector_mock));

    Mock<IEventNotifier> event_notifier_mock;
    Fake(Dtor(event_notifier_mock));
    Mock<IEventHandler> event_handler_mock;
    Fake(Dtor(event_handler_mock));
    WHEN("The InputDriver gets created")
    {
      std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
      InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()));

      THEN("It saves the EventNotifier and the Detector")
      {
        REQUIRE(input_driver.event_notifier == event_notifier_ptr);
        REQUIRE(&(*input_driver.detector) == &detector_mock.get());
      }
    }
  }
}

SCENARIO("An EventHandler [un]registers at the driver", "[un-register]")
{
  GIVEN("An InputDriver, EventHandler and an EventNotifier")
  {
    LoggerFactory::CreateInputTestLogger();

    Mock<Input::IDetector> detector_mock;
    Fake(Dtor(detector_mock));

    Mock<IEventHandler> event_handler_mock;
    Fake(Method(event_handler_mock, handle));
    Fake(Dtor(event_handler_mock));

    Mock<Input::IEventNotifier> event_notifier_mock;
    Fake(Method(event_notifier_mock, register_event_handler));
    Fake(Method(event_notifier_mock, unregister_event_handler));
    Fake(Dtor(event_notifier_mock));

    std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
    InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()));

    WHEN("The EventHandler registers at the driver")
    {
      input_driver.register_event_handler(&event_handler_mock.get());

      THEN("The register_event_handler at the event_notifier gets called")
      {
        REQUIRE((bool)Verify(Method(event_notifier_mock, register_event_handler).Using(&event_handler_mock.get())));
      }
    }

    WHEN("The EventHandler then unregisters at the driver")
    {
      input_driver.unregister_event_handler(&event_handler_mock.get());

      THEN("The unregister_event_handler at the event_notifier gets called")
      {
        REQUIRE((bool)Verify(Method(event_notifier_mock, unregister_event_handler).Using(&event_handler_mock.get())));
      }
    }
  }
}