#include "fesa/assembly/parallel_for.hpp"

#include <gtest/gtest.h>

#include <array>
#include <cstddef>
#include <functional>
#include <stdexcept>
#include <string>
#include <vector>

namespace fesa {
namespace {

class ParallelForBodyError final : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};

std::array<std::reference_wrapper<const ParallelFor>, 2> parallelForBackends(
    const SerialParallelFor& serial,
    const TbbParallelFor& tbb) {
    return {std::cref(serial), std::cref(tbb)};
}

TEST(ParallelFor, ZeroOneManyExecuteExactlyOnce) {
    const SerialParallelFor serial;
    const TbbParallelFor tbb;

    for (const ParallelFor& parallelFor : parallelForBackends(serial, tbb)) {
        bool zeroBodyCalled = false;
        parallelFor.execute(0U, [&zeroBodyCalled](std::size_t) {
            zeroBodyCalled = true;
        });
        EXPECT_FALSE(zeroBodyCalled);

        for (const std::size_t count : {1U, 257U}) {
            std::vector<int> visits(count, 0);
            parallelFor.execute(count, [&visits](std::size_t index) {
                ++visits[index];
            });
            EXPECT_EQ(visits, std::vector<int>(count, 1));
        }
    }
}

TEST(ParallelFor, SerialAndTbbProduceStableIndexedOutput) {
    constexpr std::size_t count = 1024U;
    std::vector<std::size_t> serialOutput(count, 0U);
    std::vector<std::size_t> tbbOutput(count, 0U);
    const auto valueForIndex = [](std::size_t index) {
        return (index + 17U) * (index + 3U);
    };

    const SerialParallelFor serial;
    serial.execute(count, [&serialOutput, &valueForIndex](std::size_t index) {
        serialOutput[index] = valueForIndex(index);
    });

    const TbbParallelFor tbb;
    tbb.execute(count, [&tbbOutput, &valueForIndex](std::size_t index) {
        tbbOutput[index] = valueForIndex(index);
    });

    EXPECT_EQ(tbbOutput, serialOutput);
    for (std::size_t index = 0; index < count; ++index) {
        EXPECT_EQ(tbbOutput[index], valueForIndex(index));
    }
}

TEST(ParallelFor, PropagatesBodyExceptionByContract) {
    const SerialParallelFor serial;
    const TbbParallelFor tbb;

    for (const ParallelFor& parallelFor : parallelForBackends(serial, tbb)) {
        try {
            // Every iteration throws the same value so the assertion is independent
            // of which oneTBB task reports the cancellation-triggering exception.
            parallelFor.execute(64U, [](std::size_t) {
                throw ParallelForBodyError{"parallel-for-body-failure"};
            });
            ADD_FAILURE() << "ParallelFor swallowed the body exception.";
        } catch (const ParallelForBodyError& error) {
            EXPECT_EQ(std::string{error.what()}, "parallel-for-body-failure");
        } catch (...) {
            ADD_FAILURE() << "ParallelFor changed the body exception type.";
        }
    }
}

} // namespace
} // namespace fesa