#include "slime_solver_core.hpp"

#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <string>
#include <thread>
#include <vector>

namespace sr = slime_research;

namespace {

struct Args {
    int32_t x = 51069;
    int32_t z = 419124;
    int32_t size = 5;
    uint64_t start = 0;
    uint64_t count = 1ULL << 30;
    int threads = std::max(1U, std::thread::hardware_concurrency());
};

const char* value(int argc, char** argv, int& i) {
    if (++i >= argc) std::exit(2);
    return argv[i];
}

Args parseArgs(int argc, char** argv) {
    Args args;
    for (int i = 1; i < argc; ++i) {
        const std::string arg = argv[i];
        if (arg == "--x") args.x = std::stoi(value(argc, argv, i));
        else if (arg == "--z") args.z = std::stoi(value(argc, argv, i));
        else if (arg == "-n") args.size = std::stoi(value(argc, argv, i));
        else if (arg == "--start") args.start = std::stoull(value(argc, argv, i));
        else if (arg == "--count") args.count = std::stoull(value(argc, argv, i));
        else if (arg == "-p" || arg == "--threads") args.threads = std::stoi(value(argc, argv, i));
        else std::exit(2);
    }
    if (args.size <= 0 || int64_t(args.size) * args.size > sr::kMaxPatternCells ||
        args.count == 0 || args.threads <= 0) std::exit(2);
    return args;
}

}  // namespace

int main(int argc, char** argv) {
    const Args args = parseArgs(argc, argv);
    std::vector<sr::CellTerm> terms;
    for (int32_t dz = 0; dz < args.size; ++dz) {
        for (int32_t dx = 0; dx < args.size; ++dx) {
            terms.push_back({sr::coordinateTerm(args.x + dx, args.z + dz), sr::kSlime});
        }
    }

    constexpr uint64_t batch = 4096;
    std::atomic<uint64_t> next{0};
    std::atomic<uint64_t> matches{0};
    const auto begin = std::chrono::steady_clock::now();
    auto worker = [&] {
        uint64_t localMatches = 0;
        for (;;) {
            const uint64_t first = next.fetch_add(batch, std::memory_order_relaxed);
            if (first >= args.count) break;
            const uint64_t last = std::min(first + batch, args.count);
            for (uint64_t offset = first; offset < last; ++offset) {
                if (sr::verifyPattern(
                        (args.start + offset) & sr::kMask48,
                        terms.data(), int(terms.size()))) {
                    ++localMatches;
                }
            }
        }
        matches.fetch_add(localMatches, std::memory_order_relaxed);
    };

    std::vector<std::thread> workers;
    for (int i = 0; i < args.threads; ++i) workers.emplace_back(worker);
    for (std::thread& workerThread : workers) workerThread.join();
    const std::chrono::duration<double> elapsed = std::chrono::steady_clock::now() - begin;
    const double seedsPerSecond = double(args.count) / elapsed.count();
    const double fullSeconds = double(1ULL << 48) / seedsPerSecond;
    std::cout << "count=" << args.count << " matches=" << matches.load()
              << " seconds=" << elapsed.count() << " seeds_per_second=" << seedsPerSecond
              << " projected_full48_seconds=" << fullSeconds << '\n';
}