struct X
{
    int value;
    bool included;
};

struct X2
{
    int value;
    bool included;
    X2* next;
};

static const auto v = sys::Random::Value<int>();

__declspec(noinline) void consumeValue(int x)
{
    if (!v) [[unlikely]]
        core::Log::OutInfoFmt("{}", x);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    constexpr auto NUM = 200;
    constexpr auto ITERATIONS = 5000;
    constexpr auto SEED = 10000;
    constexpr auto CHANCE = 0.001f;

    const auto generateValue = [&]
    {
        return sys::Random::Max<int>(100000);
    };

    // vector
    {
        core::Timer timer;

        sys::Vector<X, sys::CompactSizeT> vTest(NUM, sys::ReserveHint);

        sys::Random::InitSeed(SEED);

        for (const auto i : sys::iterateTo(NUM))
        {
            vTest.EmplaceBackReserved(generateValue(), sys::Random::Chance(CHANCE));
        }

        core::Log::OutInfoFmt("Vector-creation took {}s", timer.Duration());

        {
            timer.Reset();
            for (const auto i : sys::iterateTo(ITERATIONS))
            {
                for (auto& in : vTest)
                {
                    if (in.included)
                    {
                        consumeValue(in.value);
                        in.included = false;
                        break;
                    }
                }
            }

            const auto duration = timer.Duration();
            core::Log::OutInfoFmt("Vector-search took {}s", duration);
        }
    }

    // list
    {
        core::Timer timer;

        std::list<X> vTest;

        sys::Random::InitSeed(SEED);

        for (const auto i : sys::iterateTo(NUM))
        {
            vTest.emplace_back(generateValue(), sys::Random::Chance(CHANCE));
        }

        core::Log::OutInfoFmt("List-creation took {}s", timer.Duration());

        {
            timer.Reset();
            for (const auto i : sys::iterateTo(ITERATIONS))
            {
                for (auto& in : vTest)
                {
                    if (in.included)
                    {
                        consumeValue(in.value);
                        in.included = false;
                        break;
                    }
                }
            }

            const auto duration = timer.Duration();
            core::Log::OutInfoFmt("List-search took {}s", duration);
        }
    }

    // implicit list - separately stored
    {
        sys::Vector<sys::Pointer<X2>> vTest(NUM, sys::ReserveHint);

        for (const auto i : sys::iterateTo(NUM))
        {
            vTest.EmplaceBack(sys::makePointer<X2>(generateValue(), sys::Random::Chance(CHANCE)));
        }

        // being 'fair' here => creation of the list, if the elements already exists, does not include the time it takes to create the elements
        core::Timer timer;

        sys::Random::InitSeed(SEED);

        X2* pLast = nullptr;
        for (X2* pX : vTest)
        {
            if (pLast)
                pLast->next = pX;
            pLast = pX;
        }

        core::Log::OutInfoFmt("Implicit list-creation took {}s", timer.Duration());

        {
            timer.Reset();
            for (const auto i : sys::iterateTo(ITERATIONS))
            {
                X2* pX = vTest.Front();
                while (true)
                {
                    if (pX->included)
                    {
                        consumeValue(pX->value);
                        pX->included = false;
                        break;
                    }

                    pX = pX->next;
                    if (!pX)
                        break;
                };
            }

            const auto duration = timer.Duration();
            core::Log::OutInfoFmt("Implicit list-search took {}s", duration);
        }
    }

    // implicit list - inline stored
    {
        sys::Vector<X2> vTest(NUM, sys::ReserveHint);

        for (const auto i : sys::iterateTo(NUM))
        {
            vTest.EmplaceBack(generateValue(), sys::Random::Chance(CHANCE));
        }

        // being 'fair' here => creation of the list, if the elements already exists, does not include the time it takes to create the elements
        core::Timer timer;

        sys::Random::InitSeed(SEED);

        X2* pLast = nullptr;
        for (X2& x : vTest)
        {
            if (pLast)
                pLast->next = &x;
            pLast = &x;
        }

        core::Log::OutInfoFmt("Implicit inline list-creation took {}s", timer.Duration());

        {
            timer.Reset();
            for (const auto i : sys::iterateTo(ITERATIONS))
            {
                X2* pX = &vTest.Front();
                while (true)
                {
                    if (pX->included)
                    {
                        consumeValue(pX->value);
                        pX->included = false;
                        break;
                    }

                    pX = pX->next;
                    if (!pX)
                        break;
                };
            }

            const auto duration = timer.Duration();
            core::Log::OutInfoFmt("Implicit inline list-search took {}s", duration);
        }
    }

    return 0;
}