#pragma once

#include <algorithm>
#include <cctype>
#include <cstring>
#include <map>
#include <memory_resource>
#include <sstream>
#include <string_view>

#include <alloca.h>
#include <cassert>

#include <security/pam_appl.h>
#include <security/pam_modules.h>
#include <syslog.h>

namespace rublon {

inline void debugLog(const char * message1, const char * message2) {
    auto file_name = "/tmp/rublon.log";
    auto fp = fopen(file_name, "a");
    fprintf(fp, "[%s] %s %s\n", "cmake version", message1, message2);
    fflush(fp);
    fclose(fp);
    
//    openlog("pam_rublon", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);
//    syslog(LOG_NOTICE, "[%s] %s %s", "cmake version", message1, message2);
//    closelog();
}

template < typename T >
class NonOwningPtr {
    T * object;

  public:
    constexpr NonOwningPtr(T * obj) : object{obj} {}

    constexpr T * get() noexcept {
        assert(object != nullptr);
        return object;
    }
    constexpr const T * get() const noexcept {
        assert(object != nullptr);
        return object;
    }
    constexpr operator const T *() const noexcept {
        return get();
    }
    constexpr operator T *() noexcept {
        return get();
    }
    constexpr T * operator->() {
        return get();
    }
    constexpr const T * operator->() const {
        return get();
    }
};

namespace details {

    inline bool to_bool(std::string_view value) {
        auto * buf        = ( char * ) alloca(value.size());
        buf[value.size()] = '\0';
        auto asciitolower = [](char in) { return in - ((in <= 'Z' && in >= 'A') ? ('Z' - 'z') : 0); };

        std::transform(value.cbegin(), value.cend(), buf, asciitolower);
        return strcmp(buf, "true") == 0;
    };

    static inline std::string_view ltrim(std::string_view s) {
        while(s.length() && std::isspace(*s.begin()))
            s.remove_prefix(1);
        return s;
    }

    static inline std::string_view rtrim(std::string_view s) {
        while(s.length() && std::isspace(*s.rbegin()))
            s.remove_suffix(1);
        return s;
    }

    static inline std::string_view trim(std::string_view s) {
        return ltrim(rtrim(s));
    }

    inline std::map< std::string, std::string > headers(std::string_view data) {
        std::map< std::string, std::string > headers{};

        std::string tmp{};
        std::istringstream resp{};
        resp.rdbuf()->pubsetbuf(const_cast< char * >(data.data()), data.size());

        while(std::getline(resp, tmp)) {
            auto line  = std::string_view(tmp);
            auto index = tmp.find(':', 0);
            if(index != std::string::npos) {
                headers.insert({std::string{trim(line.substr(0, index))}, std::string{trim(line.substr(index + 1))}});
            }
        }

        return headers;
    }

    namespace pmr {
        inline std::pmr::map< std::pmr::string, std::pmr::string > headers(std::pmr::memory_resource * mr, std::string_view data) {
            char _buf[1024];
            std::pmr::monotonic_buffer_resource tmr{_buf, sizeof(_buf)};
            std::pmr::map< std::pmr::string, std::pmr::string > headers{mr};

            std::pmr::string tmp{&tmr};
            std::istringstream resp{};
            resp.rdbuf()->pubsetbuf(const_cast< char * >(data.data()), data.size());

            while(std::getline(resp, tmp) && !(trim(tmp).empty())) {
                auto line  = std::string_view(tmp);
                auto index = tmp.find(':', 0);
                if(index != std::string::npos) {
                    headers.insert({std::pmr::string{trim(line.substr(0, index)), mr}, std::pmr::string{trim(line.substr(index + 1)), mr}});
                }
            }

            return headers;
        }
    } // namespace pmr

} // namespace details

} // namespace rublon