#include <functional>
 #include <memory>
 #include <string>
 #include <vector>
 

 #include "installer.h"

 #include "user.h"
 #include "token.h"
 #include "test_util.h"
 
 class mock_tokens : public tokens_ifc {
     public:
         mutable std::string captured_token;
         void save (const user &user, const std::string &token) const override {
             captured_token = token;
         }
 };
 
 class fake_unistd : public unistd_ifc {
     private:
         std::string user_name_;
     public:
         fake_unistd(const std::string &user_name) : user_name_(user_name) {}
         const char *getlogin() const override {
             return user_name_.c_str();
         }
 };

 class fail_unistd : public unistd_ifc {
     public:
         const char *getlogin() const override {
             return nullptr;
         }
 };
 

 class fake_directory : public directory_ifc {
     private:
         std::string expected_user_name_;
     public:
         fake_directory(const std::string &expected_user_name) : expected_user_name_(expected_user_name) {
         }
         std::vector<user> find_user (const std::string &user_name) const override {
             std::vector<user> rval;
             if (user_name == expected_user_name_) {
                 rval.push_back(user());
             }
             return rval;
         }
 
 };
 
 int installs_token() {

     //given

     std::string user_name("user");
     std::string token("token");
     auto  test_tokens = std::make_shared<mock_tokens>();
     tokens tokens{test_tokens};
     unistd unistd(std::make_shared<fake_unistd>(user_name));
     directory directory(std::make_shared<fake_directory>(user_name));
     installer_ifc::generator generator = [&] { return token; };
 
     installer installer = installer::create (tokens, unistd, directory, generator);

 
     //when

     std::string result = installer.install_token();

 
     //then

     check(test_tokens->captured_token == token, "installed wrong token");

     check(result == token, "installer returned wrong token");

     succeed();

 }
 

 int unistd_does_not_find_user_name() {
     //given
     std::string user_name("user");
     std::string token("token");
     auto  test_tokens = std::make_shared<mock_tokens>();
     tokens tokens{test_tokens};
     unistd unistd(std::make_shared<fail_unistd>());
     directory directory(std::make_shared<fake_directory>(user_name));
     installer_ifc::generator generator = [&] { return token; };
 
     installer installer = installer::create (tokens, unistd, directory, generator);
 
 
     //when
     installer.install_token();

     //then
     check(test_tokens->captured_token == "", "should not have installed a token");
     succeed();
 }

 int directory_finds_no_user_info() {
     std::string user_name("user");
     std::string token("token");
     auto  test_tokens = std::make_shared<mock_tokens>();
     tokens tokens{test_tokens};
     unistd unistd(std::make_shared<fake_unistd>(user_name));
     directory directory(std::make_shared<fake_directory>("not the user"));
     installer_ifc::generator generator = [&] { return token; };
 
     installer installer = installer::create (tokens, unistd, directory, generator);
 
     //when
     installer.install_token();
 
     //then
     check(test_tokens->captured_token == "", "installed wrong token");
     succeed();
 }
 

 int run_tests() {
     test(installs_token);

     test(unistd_does_not_find_user_name);

     test(directory_finds_no_user_info);

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