#include <vector>
 #include <algorithm>
 #include <string>

 #include <security/pam_modules.h>
 
 #include "conversation.h"
 #include "test_util.h"

 #include "pam.h"

 class fake_pam_conversation : public pam_conversation {
     private:
         pam_response response_;
         std::string answer_;
     public:
         fake_pam_conversation(const std::string &answer) : answer_(answer) {}
         int conv(const std::vector<const struct pam_message *> &prompts, std::vector<struct pam_response *> &answers) {
             if (prompts.size() != 1) {
                 throw std::string("test only supports one prompt");
             }
             response_.resp_retcode = 0;
             response_.resp = const_cast<char *>(answer_.c_str());
             answers.resize(1);
             answers[0] = &response_;
             return 0;
         }
 };
 

 class fake_failing_conversation: public pam_conversation {
 
     public:
         int conv(const std::vector<const struct pam_message *> &prompts, std::vector<struct pam_response *> &answers) {
             return 1;
         }
 };
 

 class fake_failing_answer_conversation: public pam_conversation {
     private:
         pam_response response_;
         std::string answer_;
     public:
         fake_failing_answer_conversation() : answer_("ok:1") {}
         int conv(const std::vector<const struct pam_message *> &prompts, std::vector<struct pam_response *> &answers) {
             if (prompts.size() != 1) {
                 throw std::string("test only supports one prompt");
             }
             response_.resp_retcode = 13;
             response_.resp = const_cast<char *>(answer_.c_str());
             answers.resize(1);
             answers[0] = &response_;
             return 0;
         }
 };
 

 class match_prompt_text_conversation : public pam_conversation {

     private:
         pam_response response_;
         std::string answer_;
         std::string prompt_;
     public:

         match_prompt_text_conversation(const std::string &prompt) : prompt_(prompt), answer_("ok:123") {}

         int conv(const std::vector<const struct pam_message *> &prompts, std::vector<struct pam_response *> &answers) {
             if (prompt_ != prompts[0]->msg) {
                 throw std::string("prompt does not match");
             }
             response_.resp_retcode = 0;
             response_.resp = const_cast<char *>(answer_.c_str());
             answers.resize(1);
             answers[0] = &response_;
             return 0;
         }
 
 };
 

 class match_prompt_style_conversation : public pam_conversation {
     private:
         pam_response response_;
         std::string answer_;
         int style_;
     public:
         match_prompt_style_conversation(int style) : style_(style), answer_("ok:123") {}
         int conv(const std::vector<const struct pam_message *> &prompts, std::vector<struct pam_response *> &answers) {
             if (style_ != prompts[0]->msg_style) {
                 throw std::string("style does not match");
             }
             response_.resp_retcode = 0;
             response_.resp = const_cast<char *>(answer_.c_str());
             answers.resize(1);
             answers[0] = &response_;
             return 0;
         }
 
 };
 

 class fake_pam : public pam {
     private:

         std::shared_ptr<pam_conversation> conversation_;

     public:

         fake_pam(std::shared_ptr<pam_conversation> conversation) : conversation_(conversation) {}

         fake_pam() {}

         int get_conversation(pam_handle_t *pamh, std::shared_ptr<pam_conversation> &conversation) {

             if (conversation_) {
                conversation = conversation_;
                return 0;
             }
             return 12;

         }
 };
 

 int returns_correct_token() {
     //given
     pam_handle_t *pamh;

     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_pam_conversation("user:code");
     pam_p pam = (pam_p)new fake_pam(fake_conversation);

 
     //when

     pam_token_conversation conversation(pamh, pam);

 
     //then

     check(conversation.token() == "code", "returned incorrect token");

     succeed();
 }
 

 int returns_correct_user_name() {
     //given
     pam_handle_t *pamh;

     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_pam_conversation("sally:token");
     pam_p pam = (pam_p)new fake_pam(fake_conversation);
 

 
     //when

     pam_token_conversation conversation(pamh, pam);

 
     //then

     check(conversation.user_name() == "sally", "returned incorrect user name");

     succeed();
 }
 

 int returns_empty_user_and_token_when_no_colon() {

     //given
     pam_handle_t *pamh;

     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_pam_conversation("sally");
     pam_p pam = (pam_p)new fake_pam(fake_conversation);

 
     //when
     pam_token_conversation conversation(pamh, pam);

     //then
     check(conversation.user_name() == "", "did not return empty user name");
     check(conversation.token() == "", "did not return empty token");
     succeed();
 }

 int returns_empty_user_and_token_when_empty_answer() {
     //given
     pam_handle_t *pamh;

     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_pam_conversation("");
     pam_p pam = (pam_p)new fake_pam(fake_conversation);

 
     //when
     pam_token_conversation conversation(pamh, pam);
 
     //then
     check(conversation.user_name() == "", "did not return empty user name");
     check(conversation.token() == "", "did not return empty token");
     succeed();
 }
 

 int returns_empty_token_when_colon_end() {
     //given
     pam_handle_t *pamh;

     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_pam_conversation("sally:");
     pam_p pam = (pam_p)new fake_pam(fake_conversation);

 
     //when
     pam_token_conversation conversation(pamh, pam);
 
     //then
     check(conversation.user_name() == "sally", "did not return empty user name");
     check(conversation.token() == "", "did not return empty token");
     succeed();
 }
 
 int returns_empty_user_when_colon_begin() {
     //given
     pam_handle_t *pamh;

     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_pam_conversation(":token");
     pam_p pam = (pam_p)new fake_pam(fake_conversation);

 
     //when
     pam_token_conversation conversation(pamh, pam);
 
     //then
     check(conversation.user_name() == "", "did not return empty user name");
     check(conversation.token() == "token", "did not return empty token");
     succeed();
 }
 

 int returns_empty_user_and_token_when_pam_cant_create_conversation() {
     // given
     pam_handle_t *pamh;
     pam_p pam = (pam_p)new fake_pam;
 
     //when
     pam_token_conversation conversation(pamh, pam);
 
     //then
     check(conversation.user_name() == "", "did not return empty user name");
     check(conversation.token() == "", "did not return empty token");
     succeed();
 
 }
 

 int prompts_user_with_correct_text() {
     // given
     pam_handle_t *pamh;

     pam_conversation_p match_conversation = (pam_conversation_p) new match_prompt_text_conversation("Dual control token: ");

     pam_p pam = (pam_p)new fake_pam(match_conversation);
 
 
     // when / then
     try {
       pam_token_conversation conversation(pamh, pam);
       succeed();
     } catch (const std::string &x) {
         fail();
     }
 

 }
 
 int prompts_user_with_correct_style() {
     // given
     pam_handle_t *pamh;
     pam_conversation_p match_conversation = (pam_conversation_p) new match_prompt_style_conversation(PAM_PROMPT_ECHO_OFF);
     pam_p pam = (pam_p)new fake_pam(match_conversation);

     // when / then
     try {
       pam_token_conversation conversation(pamh, pam);
       succeed();
     } catch (const std::string &x) {
         fail();
     }

 }

 int returns_empty_user_and_token_when_conversation_fails() {
     //given
     pam_handle_t *pamh;
     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_failing_conversation;
     pam_p pam = (pam_p) new fake_pam(fake_conversation);
 
     //when
     pam_token_conversation conversation(pamh, pam);

     //then
     check(conversation.user_name() == "", "did not return empty user name");
     check(conversation.token() == "", "did not return empty token");
     succeed();
 }

 int returns_empty_user_and_token_when_conversation_answer_fails() {
     //given
     pam_handle_t *pamh;
     pam_conversation_p fake_conversation = (pam_conversation_p) new fake_failing_answer_conversation;
     pam_p pam = (pam_p) new fake_pam(fake_conversation);
 
     //when
     pam_token_conversation conversation(pamh, pam);
 
     //then
     check(conversation.user_name() == "", "did not return empty user name");
     check(conversation.token() == "", "did not return empty token");
     succeed();
 }

 RESET_VARS_START
 RESET_VARS_END
 
 int run_tests() {
     test(returns_correct_token);

     test(returns_correct_user_name);

     test(returns_empty_user_and_token_when_no_colon);
     test(returns_empty_token_when_colon_end);
     test(returns_empty_user_when_colon_begin);

     test(returns_empty_user_and_token_when_empty_answer);

     test(returns_empty_user_and_token_when_pam_cant_create_conversation);

     test(prompts_user_with_correct_text);

     test(prompts_user_with_correct_style);

     test(returns_empty_user_and_token_when_conversation_fails);

     test(returns_empty_user_and_token_when_conversation_answer_fails);

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