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

 #include <algorithm>
 #include <memory>
 #include <cstring>

 #include <security/pam_modules.h>
 

 #include <iostream>
 
 #include "request.h"

 #include "conversation.h"
 #include "test_util.h"

 #include "pam.h"

 struct conversation_data {
     std::vector<pam_message> expected_prompts;
     std::vector<pam_response> responses;
     int return_value;

 };
 

 bool same_prompts (const std::vector<pam_message> &expected,
                    int num_prompts, const pam_message **actual)

 {

     if (expected.size() != num_prompts) {
         return false;

     }

     for (int i=0; i< num_prompts; ++i) {
         if (expected[i].msg_style != actual[i]->msg_style) {
             return false;

         }

         if (std::strcmp (expected[i].msg, actual[i]->msg)) {
             return false;

         }

     }

     return true;
 }

 template<class T>
 T *address_of (T &t)

 {

     return &t;
 }
 
 int fake_conv (int num_msg, const struct pam_message **msg,
                struct pam_response **resp, void *appdata_ptr)
 {
     conversation_data *data = reinterpret_cast<conversation_data *>
                               (appdata_ptr);

     if (data->return_value != PAM_SUCCESS) {
         return data->return_value;

     }

     if (!same_prompts (data->expected_prompts, num_msg, msg)) {
         throw std::string ("unexpected prompts");
     }
 
     std::vector<pam_response> &responses = data->responses;
     std::transform (responses.begin(), responses.end(), resp,
                     address_of<pam_response>);
     return data->return_value;
 }

 class fake_pam : public pam_ifc

 {
 private:

     pam_handle *expected_handle_;
     conversation_data conversation_data_;
     pam_conv conv_;

 public:

     fake_pam(pam_handle* expected_handle, const conversation_data &conversation_data)
         : expected_handle_(expected_handle),
           conversation_data_(conversation_data)
     {}
     int get_conv (pam_handle *handle, const pam_conv **out)

     {

         if (expected_handle_ != handle) {
             throw std::string("unexpected handle");

         }

         conv_.appdata_ptr = reinterpret_cast<void *>(&conversation_data_);
         conv_.conv = fake_conv;
         *out = &conv_;
         return PAM_SUCCESS;

     }

 };

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

 }
 

 bool uses_pam_correctly()

 {

     // given
     pam_handle *handle = reinterpret_cast<pam_handle *> (29039);
     std::string user ("user");
     std::string token ("token");
     pam_message prompt;
     prompt.msg_style = PAM_PROMPT_ECHO_OFF;
     prompt.msg = const_cast<char *>("Dual control token: ");
     pam_response response;
     response.resp_retcode = 0;
     std::string response_text(user + ":" + token);
     response.resp = const_cast<char *>(response_text.c_str());
     conversation_data conversation_data = {
         std::vector<pam_message>(&prompt, &prompt + 1),
         std::vector<pam_response>(&response, &response + 1),
         PAM_SUCCESS
     };
     pam pam (share (new fake_pam (handle, conversation_data)));
     pam_request request (handle, 0, 0, 0);
 
     conversation conversation (create_conversation (pam));
 
     // when
     conversation_result actual = conversation.initiate (request);
 
     // then
     check(actual.user_name == user, "user name does not match");
     check(actual.token == token, "token does not match");

 
     succeed();
 }
 

 RESET_VARS_START
 RESET_VARS_END

 int run_tests()

 {

     test (uses_pam_correctly);

     succeed();
 }
 

 int main (int argc, char **argv)

 {

     return !run_tests();

 }
 

 /*
  * int returns_correct_token()
 int returns_correct_user_name()
 int returns_empty_user_and_token_when_no_colon()
 int returns_empty_user_and_token_when_empty_answer()
 int returns_empty_token_when_colon_end()

 int returns_empty_user_when_colon_begin()
 int returns_empty_user_and_token_when_pam_cant_create_conversation()
 int prompts_user_with_correct_text()
 int prompts_user_with_correct_style()
 int returns_empty_user_and_token_when_conversation_fails()
 int returns_empty_user_and_token_when_conversation_answer_fails()

 */