#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();
 }