#include <gmock/gmock.h>

#include "mocks/SessionMock.hpp"
#include "mocks/widgets/AuthPageMock.hpp"
#include "mocks/widgets/MainPageMock.hpp"
#include "utils/UniquePtrMockWrapper.hpp"

#include <Wt/Test/WTestEnvironment>
#include <Wt/WMenuItem>
#include <Wt/WPopupMenu>

#include <eedb/EEDB.hpp>
#include <eedb/Session.hpp>
#include <eedb/db/connection.hpp>
#include <eedb/widgets/HomePage.hpp>
#include <eedb/widgets/Theme.hpp>

class AuthPageFactory {
  public:
    MOCK_METHOD0(impl, std::unique_ptr< eedb::AuthPage >());
    auto operator()() {
        return impl();
    }
};

using namespace testing;

class EedbWidgetHomePageTest : public Test {
  public:
    EedbWidgetHomePageTest() {
        createApp();
        expectCreateHomePage();
        authPage->notifyUserStrongLogin();
    }

    void createApp() {
        expectCreateAuthPage();

        auto session = std::make_unique< eedb::SessionMock >();
        //        EXPECT_CALL(*session, login()).WillOnce(ReturnRef(login));

        homePage = std::make_unique< eedb::Home >(*session);
        sut      = dynamic_cast< eedb::Home * >(homePage.get());

        EXPECT_CALL(*session, enviroment()).WillOnce(ReturnRef(env));
        eedb = new eedb::EEDB(std::move(session),
          [this]() { return authPageFactory(); },
          [&]() -> std::unique_ptr< eedb::HomePage > { return std::move(homePage); });
    }
    void expectCreateAuthPage() {
        EXPECT_CALL(authPageFactory, impl()).WillOnce(Return(ByMove(authPage.getPtr())));

        EXPECT_CALL(*authPage, registerNeedVerification(_)).WillOnce(Invoke(authPage.get(), &eedb::AuthPageMock::regNeedEmailWerification));
        EXPECT_CALL(*authPage, registerOnUserWeakLogin(_)).WillOnce(Invoke(authPage.get(), &eedb::AuthPageMock::regWeakLogin));
        EXPECT_CALL(*authPage, registerOnUserStrongLogin(_)).WillOnce(Invoke(authPage.get(), &eedb::AuthPageMock::regStrongLogin));
        EXPECT_CALL(*authPage, registerOnUserLogout(_)).WillOnce(Invoke(authPage.get(), &eedb::AuthPageMock::regUserLogout));
        EXPECT_CALL(*authPage, setParent(Ne(nullptr)));
        EXPECT_CALL(*authPage, processEnvironment());
    }

    void expectCreateHomePage() {
        EXPECT_CALL(*authPage, detachFrom(Ne(nullptr)));
    }

  protected:
    Wt::Test::WTestEnvironment env;
    Wt::Auth::Login login;
    UniquePtrMockWrapper< eedb::AuthPageMock > authPage;
    AuthPageFactory authPageFactory;

    std::unique_ptr< eedb::HomePage > homePage;

    eedb::EEDB * eedb;

    eedb::Home * sut;
};

TEST_F(EedbWidgetHomePageTest, createApp) {
    auto menu     = dynamic_cast< Wt::WPopupMenu * >(eedb->findWidget("home.navigation.session_menu_popup"));
    auto menuItem = dynamic_cast< Wt::WMenuItem * >(eedb->findWidget("home.navigation.session_menu.logout"));
    menu->triggered().emit(menuItem);
}

// TEST(a, b) {
//    auto session = std::make_unique< eedb::SessionMock >();
//    EXPECT_CALL(*session, enviroment()).WillOnce(ReturnRef(env));

//    sut = new eedb::EEDB(std::move(session), [this]() { return authPageFactory(); }, [this]() { return homePageFactory(); });

//    //    Wt::WPushButton * b = dynamic_cast< Wt::WPushButton * >(app.findWidget("startbutton"));

//    //    Wt::WProgressBar * bar = dynamic_cast< Wt::WProgressBar * >(app.findWidget("progress"));

//    //    b->clicked().emit(Wt::WMouseEvent());

//    //    environment.endRequest();

//    //    for(;;) {
//    //        boost::this_thread::sleep(boost::posix_time::milliseconds(50));
//    //        std::cerr << "Progress: " << bar->value() << std::endl;
//    //        if(b->isEnabled())
//    //            break;
//    //    }

//    //    environment.startRequest();
//}