#include <security/pam_modules.h>
#include <string>

#include "request.h"
#include "dual_control.h"
#include "validator.h"
#include "conversation.h"
#include "logger.h"
#include "test_util.h"

template<class T>
std::shared_ptr<T> share (T *t)
{
    return std::shared_ptr<T> (t);
}

void use_validator (dual_control_configuration &config,
                    validator_ifc *value)
{
    config.validator = validator (share (value));
}

void use_conversation (dual_control_configuration &config,
                       conversation_ifc *value)
{
    config.conversation = conversation (share (value));
}

void use_logger (dual_control_configuration &config, logger_ifc *value)
{
    config.logger = logger (share (value));
}

class mock_logger : public logger_ifc
{
private:
    int result_;
    std::string user_name_;
    std::string token_;
public:
    void log (int result, const std::string &user_name,
              const std::string &token)
    {
        result_ = result;
        user_name_ = user_name;
        token_ = token;
    }
    int logged_result()
    {
        return result_;
    }
    std::string logged_user_name()
    {
        return user_name_;
    }
    std::string logged_token()
    {
        return token_;
    }
};

class fake_conversation : public conversation_ifc
{
private:
    std::string user_name_;
    std::string token_;
public:
    fake_conversation (const std::string &user_name,
                       const std::string &token) : user_name_ (user_name), token_ (token) {}
    conversation_result initiate (const pam_request &request)
    {
        return {user_name_, token_};
    }
};

class fake_validator : public validator_ifc
{
private:
    std::string user_;
    std::string token_;
public:
    fake_validator (const std::string &user,
                    const std::string &token): user_ (user), token_ (token) {}
    bool validate (const std::string &user, const std::string &token)
    {
        return user_ == user && token_ == token;
    }
};

pam_request req()
{
    return pam_request (0, 0, 0, 0);
}

int setcred_returns_success()
{
    //given
    dual_control_configuration configuration;
    dual_control dc (create_dual_control (configuration));

    //when
    int result = dc.setcred (req());

    //then
    checkint (PAM_SUCCESS, result, "function return");
    succeed();

}

int authenticate_validates_with_received_token()
{
    // given
    dual_control_configuration configuration;
    std::string user ("user");
    std::string token ("token");
    use_validator (configuration, new fake_validator (user, token));
    use_conversation (configuration, new fake_conversation (user, token));
    dual_control dc (create_dual_control (configuration));
    pam_handle_t *handle (0);
    std::vector<const std::string> arguments;

    // when
    int actual = dc.authenticate (req());

    // then
    check (actual == PAM_SUCCESS, "should be success");
    succeed();
}

int authenticate_fails_with_wrong_user()
{
    // given
    dual_control_configuration configuration;
    std::string token ("token");
    use_validator (configuration, new fake_validator ("user", token));
    use_conversation (configuration, new fake_conversation ("wrong user",
                      token));
    dual_control dc (create_dual_control (configuration));

    // when
    int actual = dc.authenticate (req());

    // then
    check (actual == PAM_AUTH_ERR, "should be auth err");
    succeed();
}

int authenticate_fails_with_wrong_token()
{
    // given
    dual_control_configuration configuration;
    std::string user ("user");
    use_validator (configuration, new fake_validator (user, "token"));
    use_conversation (configuration, new fake_conversation (user,
                      "wrong token"));
    dual_control dc (create_dual_control (configuration));

    // when
    int actual = dc.authenticate (req());

    // then
    check (actual == PAM_AUTH_ERR, "should be auth err");
    succeed();
}

int logs_authentication()
{
    //given
    dual_control_configuration configuration;
    std::string user ("user");
    std::string token ("token");
    use_validator (configuration, new fake_validator (user, token));
    use_conversation (configuration, new fake_conversation (user, token));
    mock_logger *test_logger;
    use_logger (configuration, test_logger = new mock_logger);
    dual_control dc (create_dual_control (configuration));

    //when
    dc.authenticate (req());

    //then
    check (test_logger->logged_result() == PAM_SUCCESS,
           "logged result should be success");
    check (test_logger->logged_user_name() == user,
           "logged user name should be user");
    check (test_logger->logged_token() == token,
           "logged token should be token");
    succeed();
}

int logs_authentication_failure()
{
    //given
    dual_control_configuration configuration;
    std::string user ("user");
    std::string token ("token");
    use_validator (configuration, new fake_validator (user,
                   "not the received token"));
    use_conversation (configuration, new fake_conversation (user, token));
    mock_logger *test_logger;
    use_logger (configuration, test_logger = new mock_logger);
    dual_control dc (create_dual_control (configuration));

    //when
    dc.authenticate (req());

    //then
    check (test_logger->logged_result() == PAM_AUTH_ERR,
           "logged result should be success");
    check (test_logger->logged_user_name() == user,
           "logged user name should be user");
    check (test_logger->logged_token() == token,
           "logged token should be token");
    succeed();
}

RESET_VARS_START
RESET_VARS_END

int runtests()
{
    test (setcred_returns_success);
    test (authenticate_validates_with_received_token);
    test (authenticate_fails_with_wrong_user);
    test (authenticate_fails_with_wrong_token);
    test (logs_authentication);
    test (logs_authentication_failure);
    succeed();
}

int main (int argc, char *argv[])
{
    return !runtests();
}