#include "matador/utils/uuid.hpp"

#include <random>

namespace matador::utils {

uuid uuid::generate() {
    std::random_device rd;
    std::mt19937_64 gen(rd());
    std::uniform_int_distribution<uint64_t> dist;

    uint64_t high = dist(gen);
    uint64_t low = dist(gen);

    // Set version to 4 (UUID v4)
    high &= 0xFFFFFFFFFFFF0FFFULL;
    high |= 0x0000000000004000ULL;

    // Set variant to 10xx (RFC 4122)
    low &= 0x3FFFFFFFFFFFFFFFULL;
    low |= 0x8000000000000000ULL;

    uuid result;
    result._data[0] = static_cast<uint32_t>(high >> 32);
    result._data[1] = static_cast<uint32_t>(high & 0xFFFFFFFF);
    result._data[2] = static_cast<uint32_t>(low >> 32);
    result._data[3] = static_cast<uint32_t>(low & 0xFFFFFFFF);

    return result;
}

std::string uuid::str() const {
    const char* hex = "0123456789abcdef";
    char out[36]; // UUID string format is 36 characters
    int pos = 0;

    auto write_hex = [&](uint32_t value, int digits) {
        for (int i = digits - 1; i >= 0; --i) {
            out[pos + i] = hex[value & 0xF];
            value >>= 4;
        }
        pos += digits;
    };

    write_hex(_data[0] >> 16, 8);
    out[pos++] = '-';
    write_hex(_data[0] & 0xFFFF, 4);
    out[pos++] = '-';
    write_hex(_data[1] >> 16, 4);
    out[pos++] = '-';
    write_hex(_data[1] & 0xFFFF, 4);
    out[pos++] = '-';
    write_hex(_data[2] >> 16, 4);
    write_hex(_data[2] & 0xFFFF, 4);
    write_hex(_data[3], 4);

    return {out, 36};
}

const uuid::uuid_array& uuid::data() const {
    return _data;
}

bool operator==( const uuid& lhs, const uuid& rhs ) {
    return lhs._data == rhs._data;
}

bool operator!=( const uuid& lhs, const uuid& rhs ) {
    return !(lhs == rhs);
}

bool operator<( const uuid& lhs, const uuid& rhs ) {
    return lhs._data < rhs._data;
}
}