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

#include "conversation.h"





namespace
{
    class impl : public conversation_ifc
    {
        public:
           conversation_result initiate (const pam_request &request) {
               return {"user","token"};
           }
    };
}

conversation create_conversation(pam &pam) {
    return conversation(std::shared_ptr<conversation_ifc>(new impl));
}

/*
pam_token_conversation::pam_token_conversation (pam_handle_t *pamh,
        const pam_p pam)
{
    pam_conversation_p pam_conversation;
    int get_conversation_result = pam->get_conversation (pamh,
                                  pam_conversation);

    if (get_conversation_result != 0) {
        return;
    }

    struct pam_message prompt;

    std::string message ("Dual control token: ");

    prompt.msg = const_cast<char *> (message.c_str());

    prompt.msg_style = PAM_PROMPT_ECHO_OFF;

    std::vector<const struct pam_message *> prompts (1);

    prompts[0] = &prompt;

    std::vector<struct pam_response *> answers (1);

    int conversation_result = pam_conversation->conv (prompts, answers);

    if (conversation_result) {
        return;
    }

    if (answers[0]->resp_retcode) {
        return;
    }

    std::string answer (answers[0]->resp);
    std::string::iterator delim = std::find (answer.begin(), answer.end(), ':');

    if (delim == answer.end()) {
        return;
    }

    std::string user_name (answer.begin(), delim);
    std::string token (delim + 1, answer.end());
    user_ = user_name;
    token_ = token;
}

std::string pam_token_conversation::token()
{
    return token_;
}

std::string pam_token_conversation::user_name()
{
    return user_;
}
*/