//----------------------------------------------------------------------------- 
//     ___                      __ _       _
//    / _ \__ _ _ __ ___  ___  / /(_)_ __ | | __
//   / /_)/ _` | '__/ __|/ _ \/ / | | '_ \| |/ /
//  / ___/ (_| | |  \__ \  __/ /__| | | | |   <
//  \/    \__,_|_|  |___/\___\____/_|_| |_|_|\_\ .
//
//----------------------------------------------------------------------------- 
// Author: Kurt Sassenrath
// Module: Tests
//
// Logging tests.
//
// Copyright (c) 2023 Kurt Sassenrath.
//
// License TBD.
//----------------------------------------------------------------------------- 

#include <logging.h>

#include <boost/ut.hpp>

#include <fmt/core.h>

using namespace parselink::logging;

namespace {

// Simple testing endpoint, writing to a std::string. Colors are not supported.
template <bool Colored>
struct test_endpoint_base : public endpoint {
    void write(message const& msg) override {
        if constexpr (Colored) {
            buffer_.append(fmt::format("{} {} | {}",
                    themed_arg{enum_name_only{msg.lvl}}, msg.name, msg.message));
        } else {
            buffer_.append(fmt::format("{} {} | {}",
                    enum_name_only{msg.lvl}, msg.name, msg.message));
        }
    }

    bool colored() const noexcept override { return Colored; }

    void clear() { buffer_.clear(); }
    std::string_view contents() const { return buffer_; }

    std::string buffer_;
};

template <typename Endpoint>
auto make_test_logger(std::string_view name) {
    auto ep = std::make_shared<Endpoint>();
    return std::tuple{logger{name, ep}, ep};
}

using test_endpoint = test_endpoint_base<false>;
using colored_test_endpoint = test_endpoint_base<true>;

// In order to test themed (colorized) logging, we must be sure that theming
// gets correctly-styled content.
struct static_theme_test { int value; };

// In order to test themed (colorized) logging, we must be sure that theming
// gets correctly-styled content.
struct dynamic_theme_test { int value; };

template <has_theme T>
auto styled(T&& v) {
    if constexpr(has_static_theme<T>) {
        return fmt::styled(v, theme<std::remove_cvref_t<T>>::style);
    } else if constexpr (has_dynamic_theme<T>) {
        return fmt::styled(v, theme<std::remove_cvref_t<T>>::style(v));
    } else {
        static_assert("Could not find theme, likely broken test!");
    }
}

}

template <>
struct fmt::formatter<static_theme_test> : public fmt::formatter<int> {
    template <typename FormatContext>
    auto format(static_theme_test const& v, FormatContext& ctx) const {
        return fmt::formatter<int>::format(v.value, ctx);
    }
};

template <>
struct fmt::formatter<dynamic_theme_test> : public fmt::formatter<int> {
    template <typename FormatContext>
    auto format(dynamic_theme_test const& v, FormatContext& ctx) const {
        return fmt::formatter<int>::format(v.value, ctx);
    }
};

template <>
struct parselink::logging::theme<static_theme_test>
        : static_theme<fmt::color::black> {};

template <>
struct parselink::logging::theme<dynamic_theme_test> {
    static constexpr auto style(auto const& dtt) noexcept {
        return fmt::fg(dtt.value % 2 ? fmt::color::red : fmt::color::green);
    }
};


// Begin tests!

using namespace boost::ut;

suite logging = [] {
    "log thresholds by default"_test = [] {
        auto [logger, ep] = make_test_logger<test_endpoint>("log level");
        // Must be handled explicitly as the level is a template parameter.
        logger.log<level::critical>("test");
        if (ep->threshold >= level::critical) {
            expect(ep->contents() == "critical log level | test");
        } else {
            expect(ep->contents().empty());
        }
        ep->clear();

        logger.log<level::error>("test");
        if (ep->threshold >= level::error) {
            expect(ep->contents() == "error log level | test");
        } else {
            expect(ep->contents().empty());
        }
        ep->clear();

        logger.log<level::warning>("test");
        if (ep->threshold >= level::warning) {
            expect(ep->contents() == "warning log level | test");
        } else {
            expect(ep->contents().empty());
        }
        ep->clear();

        logger.log<level::info>("test");
        if (ep->threshold >= level::info) {
            expect(ep->contents() == "info log level | test");
        } else {
            expect(ep->contents().empty());
        }
        ep->clear();

        logger.log<level::verbose>("test");
        if (ep->threshold >= level::verbose) {
            expect(ep->contents() == "verbose log level | test");
        } else {
            expect(ep->contents().empty());
        }
        ep->clear();

        logger.log<level::debug>("test");
        if (ep->threshold >= level::debug) {
            expect(ep->contents() == "debug log level | test");
        } else {
            expect(ep->contents().empty());
        }
        ep->clear();

        logger.log<level::trace>("test");
        if (ep->threshold >= level::trace) {
            expect(ep->contents() == "trace log level | test");
        } else {
            expect(ep->contents().empty());
        }
        ep->clear();
    };

    "basic log formatting"_test = [] {
        auto [logger, ep] = make_test_logger<test_endpoint>("formatting");
        logger.log<level::info>("single int: {}", 5);
        expect(ep->contents() == "info formatting | single int: 5");
        ep->clear();

        logger.log<level::info>("two ints: {} {}", 32, 55);
        expect(ep->contents() == "info formatting | two ints: 32 55");
        ep->clear();

        logger.log<level::info>("string: {}", std::string{"foo"});
        expect(ep->contents() == "info formatting | string: foo");
        ep->clear();

        logger.log<level::info>("string_view: {}", std::string_view{"bar"});
        expect(ep->contents() == "info formatting | string_view: bar");
        ep->clear();

        logger.log<level::info>("c-string: {}", "brow");
        expect(ep->contents() == "info formatting | c-string: brow");
        ep->clear();

        char const* cat = "cat";
        logger.log<level::info>("c-string: {}", cat);
        expect(ep->contents() == "info formatting | c-string: cat");
        ep->clear();
    };

    "pointer formatting"_test = [] {
        auto [logger, ep] = make_test_logger<test_endpoint>("formatting");

        // Yeah, this isn't kosher, but test progression is a bit tidier.
        int* ptr = new int(5);
        auto uniq_ptr = std::unique_ptr<int>(ptr);
        auto shr_ptr = std::shared_ptr<int>(new int(10));

        {
            logger.log<level::info>("int pointer: {}", ptr);
            auto expected = fmt::format(
                    "info formatting | int pointer: {}", fmt::ptr(ptr));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            auto& ptrref = ptr;
            logger.log<level::info>("int pointer&: {}", ptrref);
            auto expected = fmt::format(
                    "info formatting | int pointer&: {}", fmt::ptr(ptrref));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            auto const& cptrref = ptr;
            logger.log<level::info>("int const pointer&: {}", cptrref);
            auto expected = fmt::format(
                    "info formatting | int const pointer&: {}",
                    fmt::ptr(cptrref));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            logger.log<level::info>("std::unique_ptr<int>: {}", uniq_ptr);
            auto expected = fmt::format(
                    "info formatting | std::unique_ptr<int>: {}",
                    fmt::ptr(uniq_ptr));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            auto& uniq_ptrref = uniq_ptr;
            logger.log<level::info>("std::unique_ptr<int>&: {}", uniq_ptrref);
            auto expected = fmt::format(
                    "info formatting | std::unique_ptr<int>&: {}",
                    fmt::ptr(uniq_ptrref));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            auto const& cuniq_ptrref = uniq_ptr;
            logger.log<level::info>("std::unique_ptr<int> const&: {}",
                    cuniq_ptrref);
            auto expected = fmt::format(
                    "info formatting | std::unique_ptr<int> const&: {}",
                    fmt::ptr(cuniq_ptrref));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            logger.log<level::info>("std::shared_ptr<int>: {}", shr_ptr);
            auto expected = fmt::format(
                    "info formatting | std::shared_ptr<int>: {}",
                    fmt::ptr(shr_ptr));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            auto& shr_ptrref = shr_ptr;
            logger.log<level::info>("std::shared_ptr<int>&: {}", shr_ptrref);
            auto expected = fmt::format(
                    "info formatting | std::shared_ptr<int>&: {}",
                    fmt::ptr(shr_ptrref));
            expect(ep->contents() == expected);
            ep->clear();
        }

        {
            auto const& cshr_ptrref = shr_ptr;
            logger.log<level::info>("std::shared_ptr<int> const&: {}",
                    cshr_ptrref);
            auto expected = fmt::format(
                    "info formatting | std::shared_ptr<int> const&: {}",
                    fmt::ptr(cshr_ptrref));
            expect(ep->contents() == expected);
            ep->clear();
        }
    };

    "expected<T> formatting"_test = [] {
        auto [logger, ep] = make_test_logger<test_endpoint>("expected");
        {
#if 0
            //TODO(ksassenrath): Enable when expected is added.
            layover::expected<int> x{5};
            logger.log<level::info>("{}", x);
            expect(ep->contents() == "info expected | 5");
            x = std::errc::invalid_argument;
            ep->clear();
            logger.log<level::info>("{}", x);
            expect(ep->contents() == "info expected | Invalid argument");
            ep->clear();
#endif
        }
        {
#if 0
            layover::expected<std::unique_ptr<int>> x{std::make_unique<int>(20)};
            logger.log<level::info>("{} {}", x, *(x.value()));
            auto expected = fmt::format(
                    "info expected | {} 20", fmt::ptr(x.value()));
            expect(ep->contents() == expected);
            x = std::errc::invalid_argument;
            ep->clear();
            logger.log<level::info>("{}", x);
            expect(ep->contents() == "info expected | Invalid argument");
            ep->clear();
#endif
        }
    };

    "log theme"_test = [] {
        static_theme_test stt{42};
        dynamic_theme_test red{21}, green{202};

        auto formatted = fmt::format("{}", styled(stt));
        auto expected = fmt::format("{}",
                fmt::styled(stt.value, fmt::fg(fmt::color::black)));
        expect(formatted == expected);
        formatted = fmt::format("{}", themed_arg{stt});
        expect(formatted == expected);

        formatted = fmt::format("{} {}", styled(red), styled(green));
        expected = fmt::format("{} {}",
                fmt::styled(red.value, fmt::fg(fmt::color::red)),
                fmt::styled(green.value, fmt::fg(fmt::color::green)));
        expect(formatted == expected);
        formatted = fmt::format("{} {}", themed_arg{red}, themed_arg{green});
        expect(formatted == expected);
    };

    "colored logging"_test = [] {
        // This unit test should not break if log colors are changed, but
        // it also relies on functionality
        auto [logger, ep] = make_test_logger<colored_test_endpoint>("colored");

        logger.log<level::info>("");
        auto expected = fmt::format("{} colored | ",
                styled(enum_name_only{level::info}));
        expect(ep->contents() == expected);
        ep->clear();

        logger.log<level::info>("integral {}", 5);
        expected = fmt::format("{} colored | integral {}",
                styled(enum_name_only{level::info}), styled(5));
        expect(ep->contents() == expected);
        ep->clear();

        std::string_view sv = "hello";
        logger.log<level::info>("string_view {}", sv);
        expected = fmt::format("{} colored | string_view {}",
                styled(enum_name_only{level::info}), styled(sv));
        expect(ep->contents() == expected);
        ep->clear();

        std::string str = "hello";
        logger.log<level::info>("string {}", str);
        expected = fmt::format("{} colored | string {}",
                styled(enum_name_only{level::info}), styled(str));
        expect(ep->contents() == expected);
        ep->clear();

        auto c_str = "hello";
        logger.log<level::info>("c-string {}", c_str);
        expected = fmt::format("{} colored | c-string {}",
                styled(enum_name_only{level::info}), styled(c_str));
        expect(ep->contents() == expected);
        ep->clear();

        int int_value = 42;
        auto* int_ptr = &int_value;
        logger.log<level::info>("pointer {} {}", int_ptr, *int_ptr);
        expected = fmt::format("{} colored | pointer {} {}",
                styled(enum_name_only{level::info}),
                themed_arg{int_ptr}, themed_arg{*int_ptr});
        expect(ep->contents() == expected);
        ep->clear();
    };
};

int main(int, char**) {
}