//#define DOCTEST_CONFIG_NO_RVALUE_REFERENCES
#include "parts/doctest_fwd.h"

#include <vector>
#include <utility>
#include <iostream>
#include <iomanip>
#include <string>

#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wmissing-declarations"
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
#endif

#ifndef DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK
#define DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK 5
#endif // DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK

namespace doctest {
namespace detail {
    struct ICapture {
        virtual String toString() const = 0;
    };

    std::vector<const ICapture*> captures;

    void addToCaptures(const ICapture* ptr) { captures.push_back(ptr); }
    void popFromCaptures() { captures.pop_back(); }

    struct InfoBuilder {
        template<typename T>
        struct Capture : ICapture {
            const T* capture;

            Capture(const T* in)
                : capture(in)
            {}
            virtual String toString() const { // override
                return doctest::toString(*capture);
            }
        };

        struct Chunk {
            char buf[sizeof(Capture<char>)]; // place to construct a Capture<T>
        };

        struct Node {
            Chunk chunk;
            Node* next;
        };

        Chunk stackChunks[DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK];
        int numCaptures;
        Node* head;

        InfoBuilder()
            : numCaptures(0)
            , head(0)
        {}

        // copy the bytes for the whole object - including the vtable
        // cannot construct the object in the buffer using placement new - need the <new> header...
        template<typename T>
        static Capture<T>* copyChunk(Chunk& dest, Capture<T>& src) {
            for(unsigned i = 0; i < sizeof(Capture<char>); ++i)
                dest.buf[i] = reinterpret_cast<char*>(&src)[i];
            return reinterpret_cast<Capture<T>*>(dest.buf);
        }

        template<typename T>
        InfoBuilder& operator<<(const T& in) {
            Capture<T> temp(&in);

            if(numCaptures < DOCTEST_CONFIG_NUM_CAPTURES_ON_STACK) {
                addToCaptures(copyChunk(stackChunks[numCaptures], temp));
            } else {
                Node* curr = new Node;
                curr->next = head;
                head = curr;
                addToCaptures(copyChunk(head->chunk, temp));
            }
            ++numCaptures;
            return *this;
        }

#undef DOCTEST_COPY_CHUNK

        ~InfoBuilder() {
            // pop all captures regardless of their location - stack or heap
            for(int i = 0; i < numCaptures; ++i)
                popFromCaptures();
            // free the linked list
            Node* curr = head;
            while(curr) {
                head = curr->next;
                delete curr;
                curr = head;
            }
        }

#ifdef DOCTEST_CONFIG_WITH_RVALUE_REFERENCES
    private:
        template<typename T>
        InfoBuilder& operator<<(const T&&);
#endif // DOCTEST_CONFIG_WITH_RVALUE_REFERENCES
    };
} // namespace detail
} // namespace doctest

// TODO: varargs


#ifdef DOCTEST_CONFIG_WITH_VARIADIC_MACROS
#define DOCTEST_INFO_IMPL(name, ...) doctest::detail::InfoBuilder name; name << __VA_ARGS__
#define DOCTEST_INFO(...) DOCTEST_INFO_IMPL(DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_), __VA_ARGS__)
#else // DOCTEST_CONFIG_WITH_VARIADIC_MACROS
#define DOCTEST_INFO_IMPL(name, x) doctest::detail::InfoBuilder name; name << x
#define DOCTEST_INFO(x) DOCTEST_INFO_IMPL(DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_), x)
#endif // DOCTEST_CONFIG_WITH_VARIADIC_MACROS

#define INFO DOCTEST_INFO

//static std::string f(const char* str) { return str; }

TEST_CASE("stuff") {
    int var = 42;
    int var2 = 43;
    int var3 = 45;
    int var4 = 46;
    int var5 = 47;
    float var6 = 48.f;

    //INFO(std::pair<int, int>(5));

    //doctest::detail::InfoBuilder name;
    //name << {1, 2};
    //name << (std::pair<int, int>(5));

    INFO(var << var2 << var3 <<
        //std::pair<int, int>(5) <<
        "OMGOMGOMGOMGOMGGG" << var4 << var5 << var6 << "deymn!");
    //INFO(var);
    //INFO("omgomgomg");
    //INFO(f("std::string!"));
    //auto res = f("std::string!");
    //INFO(res);
    //auto res2 = &res;
    //INFO(res2);

    for(size_t i = 0; i < doctest::detail::captures.size(); ++i) {
        doctest::String str = doctest::detail::captures[i]->toString();
        std::cout << str.c_str() << std::endl;
    }

    CHECK(1 == 2);
}