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