#pragma once
// Teaching example for one fixed synchronous pass, not the full benchmark.
// Caller owns a validated 1.5 GiB O_DIRECT file and a 64 MiB aligned buffer.
// Caller handles allocation, file identity, preallocation, phase reopen,
// full final-file validation, ownership, cleanup, and history.
#include <atomic>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <limits>
#include <optional>
#include <sys/time.h>
#include <unistd.h>

namespace memstorage_example {
enum class Status { Completed, Stopped, Failed };
struct PassResult {
    Status status = Status::Failed;
    std::optional<std::int32_t> rateMiBps;
    std::optional<double> elapsedMs;
};
inline bool Wall(double& seconds) {
    timeval t{};
    if (::gettimeofday(&t, nullptr) != 0 || t.tv_sec < 0 ||
        t.tv_usec < 0 || t.tv_usec >= 1000000) return false;
    seconds = double(t.tv_sec) + double(t.tv_usec) / 1000000.0;
    return std::isfinite(seconds);
}
inline PassResult MeasurePass(int fd, void* alignedBuffer, bool writing,
                              unsigned char pattern, const std::atomic<bool>& stop) {
    constexpr std::size_t blockBytes = 64ULL * 1024 * 1024;
    constexpr unsigned blocks = 24;
    PassResult result;
    if (fd < 0 || alignedBuffer == nullptr) return result;
    if (stop.load()) { result.status = Status::Stopped; return result; }
    if (writing) {
        std::memset(alignedBuffer, pattern, blockBytes);
        if (::lseek(fd, 0, SEEK_SET) != 0) return result;
    }
    double begin = 0, end = 0;
    if (!Wall(begin)) return result;
    for (unsigned i = 0; i < blocks; ++i) {
        if (stop.load()) { result.status = Status::Stopped; return result; }
        const off_t offset = static_cast<off_t>(i) * static_cast<off_t>(blockBytes);
        if (::lseek(fd, offset, SEEK_SET) != offset) return result;
        const ssize_t count = writing ? ::write(fd, alignedBuffer, blockBytes)
                                      : ::read(fd, alignedBuffer, blockBytes);
        if (count != static_cast<ssize_t>(blockBytes)) return result;
    }
    if (writing && ::fdatasync(fd) != 0) return result;
    if (!Wall(end)) return result;
    const double seconds = end - begin;
    if (!(seconds > 0.0) || !std::isfinite(seconds)) return result;
    const double raw = double(blockBytes) * blocks / (seconds * 1024.0 * 1024.0);
    if (!std::isfinite(raw) || raw < 0 || raw > std::numeric_limits<std::int32_t>::max()) return result;
    result.status = Status::Completed;
    result.elapsedMs = seconds * 1000.0;
    result.rateMiBps = static_cast<std::int32_t>(raw);
    return result;
}
} // namespace memstorage_example