#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <numeric>
#include <set>

#include "gtest_matchers.hpp"
#include "http_mock.hpp"
#include <rublon/core_handler.hpp>

using namespace rublon;
class CoreHandlerTestable : public CoreHandler< HttpHandlerMock > {
  public:
    CoreHandlerTestable(rublon::Configuration _conf = conf) : CoreHandler< HttpHandlerMock >{_conf} {}
    auto & _http() {
        return http;
    }
};

class CoreHandlerTests : public testing::Test {
  public:
    CoreHandlerTests() : http{sut._http()} {
        doc.SetObject();
    }

    CoreHandlerTestable sut;
    HttpHandlerMock & http;

    Document doc;
};

using namespace testing;

TEST_F(CoreHandlerTests, coreShouldSetConnectionErrorOnBrokenConnection) {
    EXPECT_CALL(http, request(_, _)).WillOnce(Return(RawHttpResponse{}.withTimeoutError()));
    EXPECT_THAT(sut.request("", doc), //
      AllOf(Not(HasValue()), Unexpected(HttpError{})));
}

TEST_F(CoreHandlerTests, coreShouldCheckSignatureAndReturnBadSignatureBeforeAnythingElse) {
    EXPECT_CALL(http, request(_, _)).WillOnce(Return(RawHttpResponse{}.initMessage().withBrokenBody().withBrokenSignature()));
    EXPECT_THAT(sut.request("", doc), //
      AllOf(Not(HasValue()), Unexpected(CoreHandlerError{CoreHandlerError::BadSigature})));
}

TEST_F(CoreHandlerTests, coreShouldSetBrokenDataWhenResultIsNotAvailable) {
    EXPECT_CALL(http, request(_, _)).WillOnce(Return(RawHttpResponse{}.initMessage().withBrokenBody()));
    EXPECT_THAT(sut.request("", doc), //
      AllOf(Not(HasValue()), Unexpected(CoreHandlerError{CoreHandlerError::BrokenData})));
}

TEST_F(CoreHandlerTests, coreSignatureIsBeingChecked) {
    EXPECT_CALL(http, request(Eq(conf.parameters.apiServer + "/path"), _)).WillOnce(Return(RawHttpResponse{}.initMessage()));
    EXPECT_THAT(sut.request("/path", doc), //
      AllOf(HasValue(), IsObject(), HasKey("/result/tid")));
}

TEST_F(CoreHandlerTests, onHttpProblemsAccessShouldBeDeniedByDefault) {
    EXPECT_CALL(http, request(_, _)).WillOnce(Return(RawHttpResponse{}.initMessage().withServiceUnavailableError()));
    EXPECT_THAT(sut.request("/path", doc), //
      AllOf(Not(HasValue()), Unexpected(PamDeny{})));
}

class CoreHandlerWithBypassTests : public testing::Test {
  public:
    CoreHandlerWithBypassTests() : sut{confBypass}, http{sut._http()} {
    }

    CoreHandlerTestable sut;
    HttpHandlerMock & http;
};

TEST_F(CoreHandlerWithBypassTests, onHttpProblemsAccessShouldBeBypassedWhenEnabled) {
    EXPECT_CALL(http, request(_, _)).WillOnce(Return(RawHttpResponse{}.initMessage().withServiceUnavailableError()));
    EXPECT_THAT(sut.request("/path", Document{}), //
      AllOf(Not(HasValue()), Unexpected(PamBaypass{})));
}