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

    tl::expected< Document, Error > request(std::string_view path, const Document & body) {
        static auto mr = std::pmr::get_default_resource();
        static RapidJSONPMRAlloc alloc{mr};
        return CoreHandler< HttpHandlerMock >::request(alloc, path, body);
    }
};

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

    CoreHandlerTestable sut;
    HttpHandlerMock & http;
    rublon::Response _res{std::pmr::get_default_resource()};

    Document doc;
};

using namespace testing;

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

TEST_F(CoreHandlerTests, coreShouldCheckSignatureAndReturnBadSignatureBeforeAnythingElse) {
    EXPECT_CALL(http, request(_, _)).WillOnce(Return(RawHttpResponse{_res}.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{_res}.initMessage().withBrokenBody()));
    EXPECT_THAT(sut.request("", doc), //
      AllOf(Not(HasValue()), Unexpected(CoreHandlerError{CoreHandlerError::BrokenData})));
}

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

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

TEST_F(CoreHandlerTests, onSuccessfullMessageCoreShouldByFine) {
    EXPECT_CALL(http, request(_, _)).WillOnce(Return(RawHttpResponse{_res}.authenticationSuccessfullMessage()));
    EXPECT_THAT(sut.request("/path", doc), AllOf(HasValue()));
}

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

    CoreHandlerTestable sut;
    rublon::Response _res{memory::default_resource()};
    HttpHandlerMock & http;
};

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