settings.h

#pragma once
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace hegel {
    enum class Verbosity {
        Quiet,   
        Normal,  
        Verbose, 
        Debug    
    };

    inline const char* verbosity_to_string(Verbosity v) {
        switch (v) {
        case Verbosity::Quiet:
            return "quiet";
        case Verbosity::Verbose:
            return "verbose";
        case Verbosity::Debug:
            return "debug";
        case Verbosity::Normal:
        default:
            return "normal";
        }
    }

    enum class HealthCheck {
        FilterTooMuch,        
        TooSlow,              
        TestCasesTooLarge,    
        LargeInitialTestCase, 
    };

    inline const char* health_check_to_string(HealthCheck c) {
        switch (c) {
        case HealthCheck::FilterTooMuch:
            return "filter_too_much";
        case HealthCheck::TooSlow:
            return "too_slow";
        case HealthCheck::TestCasesTooLarge:
            return "test_cases_too_large";
        case HealthCheck::LargeInitialTestCase:
            return "large_initial_test_case";
        }
        return "";
    }

    inline std::vector<HealthCheck> all_health_checks() {
        return {HealthCheck::FilterTooMuch, HealthCheck::TooSlow,
                HealthCheck::TestCasesTooLarge,
                HealthCheck::LargeInitialTestCase};
    }

    class Database {
      public:
        enum class Kind {
            Unset, 
            Disabled, 
            Path,     
        };

        static Database unset() { return {Kind::Unset, {}}; }

        static Database disabled() { return {Kind::Disabled, {}}; }

        static Database from_path(std::string path) {
            return {Kind::Path, std::move(path)};
        }

        Kind kind() const { return kind_; }
        const std::string& path() const { return path_; }
 
      private:
        Database(Kind k, std::string p) : kind_(k), path_(std::move(p)) {}
        Kind kind_;
        std::string path_;
    };

    struct Settings {
        std::optional<uint64_t> test_cases;

        Verbosity verbosity = Verbosity::Normal;

        std::optional<uint64_t> seed;

        bool derandomize = false;

        Database database = Database::unset();

        std::vector<HealthCheck> suppress_health_check;
    };
} // namespace hegel