#pragma once
#ifndef _NB_CORE_TYPES
#define _NB_CORE_TYPES

#include <iostream>
#include <string>
#include <type_traits>

#include "TypeTraits.hpp"

namespace nb {

#ifdef _NB_TARGET_WINDOWS
    const std::string NEWLINE = "\n";
    const std::wstring WNEWLINE = L"\n";
#endif // _NB_TARGET_WINDOWS
#ifdef _NB_TARGET_LINUX
    const std::string NEWLINE = "\n";
    const std::wstring WNEWLINE = L"\n";
#endif // _NB_TARGET_LINUX

template <typename... T>
using StringConvertible = ValidConversion<std::string, T...>;

template <typename... T>
using WStringConvertible = ValidConversion<std::wstring, T...>;

template <typename... T>
constexpr bool StringConvertible_v = StringConvertible<T...>::value;

template <typename... T>
constexpr bool WStringConvertible_v = WStringConvertible<T...>::value;

template <typename... T>
using StringConvertible_to = typename StringConvertible<T...>::to;

template <typename... T>
using WStringConvertible_to = typename WStringConvertible<T...>::to;

template <typename... T>
using StringConvertible_from = typename StringConvertible<T...>::from;

template <typename... T>
using WStringConvertible_from = typename WStringConvertible<T...>::from;

template<typename T>
std::enable_if_t<StringConvertible_v<T>, std::wstring> str_to_wstr(T in) {
    std::string str(in);
    std::wstring ret(str.begin(), str.end());
    return ret;
}

template<typename T>
std::enable_if_t<WStringConvertible_v<T>, std::string> wstr_to_str(T in) {
    std::wstring wstr(in);
    std::size_t wstrlen = wstr.length();
    char* c_str= new char[wstrlen];
    std::wcstombs(c_str, wstr.c_str(), wstrlen);
    std::string ret(c_str, wstrlen);
    delete[] c_str;
    return ret;
}

template <typename Stream, typename... Args>
void stream(Stream& s, Args&&... args);

template <typename Stream, typename... Args>
void stream(Stream& s, Args&&... args) {
    (s << ... << args);
}

template<typename... Args>
void term(Args&&... args) { stream(std::cout, args..., nb::NEWLINE); }

template<typename... Args>
void wterm(Args&&... args) { stream(std::wcout, args..., nb::WNEWLINE); }

template <typename T = std::string, typename A, typename B, typename C>
ValidConversion_to<T, A, B, C> find_and_replace(
    A original,
    B find,
    C replace
) {
    const T& find_t = T(find);
    const T& replace_t = T(replace); 

    T ret(original);

    std::size_t find_len = find_t.length();
    std::size_t replace_len = replace_t.length();
    std::size_t currpos = 0;
    while(true) {
        currpos = ret.find(find_t, currpos);
        if (currpos == T::npos) {
            break;
        }
        ret = ret.erase(currpos, find_len);
        ret = ret.insert(currpos, replace_t);
        currpos += replace_len;
    }
    return ret;
}

template <typename A, typename B, typename C>
StringConvertible_to<A, B, C> indent_strblock(
    A block,
    B prepend,
    C topIndent
) {
    return std::string(topIndent) + find_and_replace<std::string>(
        std::string(block),
        nb::NEWLINE,
        nb::NEWLINE + std::string(prepend)
    );
}

template <typename A, typename B>
StringConvertible_to<A, B> indent_strblock(
    A block,
    B prepend
) {
    return indent_strblock<A, B, B>(block, prepend, prepend);
}

/* template<typename T>
T swap_endian(const T& val) {
    T ret;
    const int size = sizeof(T);
    auto retLoc = static_cast<void*>(&ret);
    auto valLoc = static_cast<const void*>(&val);

    for (int i = 0; i < size; ++i) {
        memcpy(retLoc+i, valLoc+(size-i-1), 1);
    }
    return ret;
} */


// using ByteVector = std::vector<uint8_t>;

} // namespace nb
#endif // _NB_CORE_TYPES