#ifndef CHESS_ENGINE_BITBOARD_HPP
#define CHESS_ENGINE_BITBOARD_HPP

#include <cstdint>
#include <ostream>

class BitBoard final {
public:
    using U64 = uint64_t;

    BitBoard(uint64_t v = 0);

    explicit constexpr operator bool() const {
        return mBoard != 0;
    }

    explicit constexpr operator unsigned long long() const {
        return mBoard;
    }

    operator void *() const {
        return (void *) mBoard;
    }

    // Relational operators
    constexpr bool operator==(const BitBoard &rhs) const {
        return mBoard == rhs.mBoard;
    }
    constexpr bool operator!=(const BitBoard &rhs) const {
        return !(rhs == *this);
    }
    constexpr bool operator<(const BitBoard &rhs) const {
        return mBoard < rhs.mBoard;
    }
    constexpr bool operator>(const BitBoard &rhs) const {
        return rhs < *this;
    }
    constexpr bool operator<=(const BitBoard &rhs) const {
        return !(rhs < *this);
    }
    constexpr bool operator>=(const BitBoard &rhs) const {
        return !(*this < rhs);
    }

    // Logical operators
    constexpr bool operator!() const {
        return !mBoard;
    }
    constexpr bool operator&&(const BitBoard &rhs) const {
        return mBoard && rhs.mBoard;
    }
    constexpr bool operator||(const BitBoard &rhs) const {
        return mBoard || rhs.mBoard;
    }

    // Compound Bitwise assignment operators
    constexpr BitBoard &operator&=(const BitBoard &rhs) {
        mBoard &= rhs.mBoard;
        return *this;
    }
    constexpr BitBoard &operator|=(const BitBoard &rhs) {
        mBoard |= rhs.mBoard;
        return *this;
    }
    constexpr BitBoard &operator^=(const BitBoard &rhs) {
        mBoard ^= rhs.mBoard;
        return *this;
    }
    constexpr BitBoard &operator<<=(const BitBoard &rhs) {
        mBoard <<= rhs.mBoard;
        return *this;
    }
    constexpr BitBoard &operator>>=(const BitBoard &rhs) {
        mBoard >>= rhs.mBoard;
        return *this;
    }
    BitBoard operator~() {
        BitBoard result(*this);
        result.mBoard = ~mBoard;
        return result;
    }

    // Compound Arithmetic assignment operators
    constexpr BitBoard &operator+=(const BitBoard &rhs) {
        mBoard += rhs.mBoard;
        return *this;
    }
    constexpr BitBoard &operator-=(const BitBoard &rhs) {
        mBoard -= rhs.mBoard;
        return *this;
    }
    constexpr BitBoard &operator%=(const BitBoard &rhs) {
        mBoard %= rhs.mBoard;
        return *this;
    }

    // Stream operator
    friend std::ostream &operator<<(std::ostream &os, const BitBoard &board);

private:
    U64 mBoard = {};

};

// Bitwise operators
inline BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result ^= rhs;
    return result;
}
inline BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result |= rhs;
    return result;
}
inline BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result &= rhs;
    return result;
}
inline BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result <<= rhs;
    return result;
}
inline BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result >>= rhs;
    return result;
}

// Arithmetic operators
inline BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result += rhs;
    return result;
}
inline BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result -= rhs;
    return result;
}
inline BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result %= rhs;
    return result;
}

#endif //CHESS_ENGINE_BITBOARD_HPP