
#include <iostream>

#include <Wt/WApplication>
#include <Wt/Auth/AuthModel>
#include <Wt/Auth/AuthWidget>
#include <Wt/Auth/PasswordService>
#include <Wt/Auth/PasswordVerifier>
#include <Wt/Auth/HashFunction>
#include <Wt/Auth/Login>
#include <Wt/Auth/Dbo/AuthInfo>
#include <Wt/Auth/Dbo/UserDatabase>
#include <Wt/Dbo/ptr>
#include <Wt/Dbo/backend/Sqlite3>

using namespace Wt;
namespace dbo = Wt::Dbo;

Auth::AuthService auth_service_;
Auth::PasswordService password_service_(auth_service_);

class User;

typedef Auth::AuthModel AuthModel;
typedef Auth::AuthWidget AuthWidget;

typedef Auth::Dbo::AuthInfo<User> AuthInfo;
typedef dbo::ptr<AuthInfo> AuthInfoPtr;
typedef dbo::collection<AuthInfoPtr> AuthInfos;
typedef Auth::Dbo::UserDatabase<AuthInfo> UserDatabase;

class User {
public:
    template<class Action>
    void persist(Action& a) {
        dbo::hasMany(a, auth_infos_, dbo::ManyToOne, "user");
    }

private:
    AuthInfos auth_infos_;
};

class App : public WApplication {
public:
    App(const WEnvironment& env):
        WApplication(env),
        sqlite3_(":memory:"),
        user_database_(session_) {
        session_.setConnection(sqlite3_);
        session_.mapClass<User>("demo_user");
        session_.mapClass<AuthInfo>("auth_info");
        session_.mapClass<AuthInfo::AuthIdentityType>("auth_identity");
        session_.mapClass<AuthInfo::AuthTokenType>("auth_token");
        try {
            session_.createTables();
        } catch (...)
        { }
        //
        AuthModel* model = new AuthModel(auth_service_, user_database_, this);
        model->addPasswordAuth(&password_service_);
        AuthWidget* auth_widget = new AuthWidget(login_, root());
        auth_widget->setModel(model);
        auth_widget->setRegistrationEnabled(true);
        auth_widget->processEnvironment();
        //
        login_.changed().connect(this, &App::login_callback);
    }

private:
    dbo::backend::Sqlite3 sqlite3_;
    dbo::Session session_;
    UserDatabase user_database_;
    Auth::Login login_;

    void login_callback() {
        dbo::Transaction t(session_);
        session_.add(new User);
        std::cerr << "Write something to database" << std::endl;
    }
};

WApplication* createApp(const WEnvironment& env) {
    return new App(env);
}

int main(int argc, char** argv) {
    using namespace Wt::Auth;
    PasswordVerifier* verifier = new PasswordVerifier();
    verifier->addHashFunction(new BCryptHashFunction(7));
    password_service_.setVerifier(verifier);
    return WRun(argc, argv, &createApp);
}
