/* bitSet.cpp */
/**
 * Copyright - See the COPYRIGHT that is included with this distribution.
 * EPICS pvData is distributed subject to a Software License Agreement found
 * in file LICENSE that is included with this distribution.
 */
/**
 *  @author mes
 */
#include <string.h>
#include <stdio.h>
#include <iostream>

#include <stdexcept>

#define epicsExportSharedSymbols
#include <pv/lock.h>
#include <pv/serializeHelper.h>
#include <pv/bitSet.h>

/*
 * BitSets are packed into arrays of "words."  Currently a word is
 * a long, which consists of 64 bits, requiring 6 address bits.
 * The choice of word size is determined purely by performance concerns.
 */
#define ADDRESS_BITS_PER_WORD 6u
#define BITS_PER_WORD  (1u << ADDRESS_BITS_PER_WORD)
#define BYTES_PER_WORD sizeof(uint64)
#define BIT_INDEX_MASK (BITS_PER_WORD - 1u)

/** Used to shift left or right for a partial word mask */
#define WORD_MASK ~((uint64)0)

// index of work containing this bit
#define WORD_INDEX(bitn) ((bitn)>>ADDRESS_BITS_PER_WORD)
// bit offset within word
#define WORD_OFFSET(bitn) ((bitn)&BIT_INDEX_MASK)

// the words vector should be size()d as small as posible,
// so the last word should always have a bit set when the set is not empty
#define CHECK_POST() assert(words.empty() || words.back()!=0)

namespace epics { namespace pvData {
 
    BitSet::shared_pointer BitSet::create(uint32 nbits)
    {
        return BitSet::shared_pointer(new BitSet(nbits));
    }
    
    BitSet::BitSet() {}

    BitSet::BitSet(uint32 nbits)
    {
        words.reserve((nbits == 0) ? 1 : WORD_INDEX(nbits-1) + 1);
    }

    BitSet::~BitSet() {}

    void BitSet::recalculateWordsInUse() {
        // step back from the end to find the first non-zero element
        size_t nsize = words.size();
        for(; nsize; nsize--) {
            if(words[nsize-1])
                break;
        }
        words.resize(nsize);
        CHECK_POST();
    }

    void BitSet::ensureCapacity(uint32 wordsRequired) {
        words.resize(std::max(words.size(), (size_t)wordsRequired), 0);
    }

    void BitSet::expandTo(uint32 wordIndex) {
        ensureCapacity(wordIndex+1);
    }

    void BitSet::flip(uint32 bitIndex) {

        uint32 wordIdx = WORD_INDEX(bitIndex);
        expandTo(wordIdx);

        words[wordIdx] ^= (((uint64)1) << WORD_OFFSET(bitIndex));

        recalculateWordsInUse();
    }

    void BitSet::set(uint32 bitIndex) {

        uint32 wordIdx = WORD_INDEX(bitIndex);
        expandTo(wordIdx);

        words[wordIdx] |= (((uint64)1) << WORD_OFFSET(bitIndex));
    }

    void BitSet::clear(uint32 bitIndex) {

        uint32 wordIdx = WORD_INDEX(bitIndex);
        if (wordIdx >= words.size())
            return;

        words[wordIdx] &= ~(((uint64)1) << WORD_OFFSET(bitIndex));

        recalculateWordsInUse();
    }

    void BitSet::set(uint32 bitIndex, bool value) {
        if (value)
            set(bitIndex);
        else
            clear(bitIndex);
    }

    bool BitSet::get(uint32 bitIndex) const {
        uint32 wordIdx = WORD_INDEX(bitIndex);
        return ((wordIdx < words.size())
            && ((words[wordIdx] & (((uint64)1) << WORD_OFFSET(bitIndex))) != 0));
    }

    void BitSet::clear() {
        words.clear();
    }

    uint32 BitSet::numberOfTrailingZeros(uint64 i) {
        // HD, Figure 5-14
        uint32 x, y;
        if (i == 0) return 64;
        uint32 n = 63;
        y = (uint32)i; if (y != 0) { n = n -32; x = y; } else x = (uint32)(i>>32);
        y = x <<16; if (y != 0) { n = n -16; x = y; }
        y = x << 8; if (y != 0) { n = n - 8; x = y; }
        y = x << 4; if (y != 0) { n = n - 4; x = y; }
        y = x << 2; if (y != 0) { n = n - 2; x = y; }
        return n - ((x << 1) >> 31);
    }

    uint32 BitSet::bitCount(uint64 i) {
        // HD, Figure 5-14
        i = i - ((i >> 1) & 0x5555555555555555LL);
        i = (i & 0x3333333333333333LL) + ((i >> 2) & 0x3333333333333333LL);
        i = (i + (i >> 4)) & 0x0f0f0f0f0f0f0f0fLL;
        i = i + (i >> 8);
        i = i + (i >> 16);
        i = i + (i >> 32);
        return (uint32)(i & 0x7f);
     }

    int32 BitSet::nextSetBit(uint32 fromIndex) const {

        uint32 u = WORD_INDEX(fromIndex);
        if (u >= words.size())
            return -1;

        uint64 word = words[u] & (WORD_MASK << (fromIndex % BITS_PER_WORD));

        while (true) {
            if (word != 0)
                return (u * BITS_PER_WORD) + numberOfTrailingZeros(word);
            if (++u == words.size())
                return -1;
            word = words[u];
        }
    }

    int32 BitSet::nextClearBit(uint32 fromIndex) const {
        // Neither spec nor implementation handle bitsets of maximal length.

        uint32 u = WORD_INDEX(fromIndex);
        if (u >= words.size())
            return fromIndex;

        uint64 word = ~words[u] & (WORD_MASK << (fromIndex % BITS_PER_WORD));

        while (true) {
            if (word != 0)
                return (u * BITS_PER_WORD) + numberOfTrailingZeros(word);
            if (++u == words.size())
                return words.size() * BITS_PER_WORD;
            word = ~words[u];
        }
    }

    bool BitSet::isEmpty() const {
        return words.empty();
    }

    uint32 BitSet::cardinality() const {
        uint32 sum = 0;
        for (uint32 i = 0; i < words.size(); i++)
            sum += bitCount(words[i]);
        return sum;
    }

    uint32 BitSet::size() const {
        return words.size() * BITS_PER_WORD;
    }

    BitSet& BitSet::operator&=(const BitSet& set) {
        // Check for self-assignment!
        if (this == &set) return *this;

        // the result length will be <= the shorter of the two inputs
        words.resize(std::min(words.size(), set.words.size()), 0);

        for(size_t i=0, e=words.size(); i<e; i++)
            words[i] &= set.words[i];

        recalculateWordsInUse();
        return *this;
    }

    BitSet& BitSet::operator|=(const BitSet& set) {
        // Check for self-assignment!
        if (this == &set) return *this;

        // result length will be the same as the longer of the two inputs
        words.resize(std::max(words.size(), set.words.size()), 0);

        // since we expand w/ zeros, then iterate using the size of the other vector
        for(size_t i=0, e=set.words.size(); i<e; i++)
            words[i] |= set.words[i];

        CHECK_POST();
        return *this;
    }

    BitSet& BitSet::operator^=(const BitSet& set) {
        // result length will <= the longer of the two inputs
        words.resize(std::max(words.size(), set.words.size()), 0);

        for(size_t i=0, e=set.words.size(); i<e; i++)
            words[i] ^= set.words[i];

        recalculateWordsInUse();
        return *this;
    }


    BitSet& BitSet::operator=(const BitSet &set) {
        // Check for self-assignment!
        if (this != &set) {
            words = set.words;
        }
        return *this;
    }

    void BitSet::swap(BitSet& set)
    {
        words.swap(set.words);
    }

    void BitSet::or_and(const BitSet& set1, const BitSet& set2) {

        const size_t andlen = std::min(set1.words.size(), set2.words.size());
        words.resize(std::max(words.size(), andlen), 0);

        // Perform logical AND on words in common
        for (uint32 i = 0; i < andlen; i++)
            words[i] |= (set1.words[i] & set2.words[i]);

        recalculateWordsInUse();
    }

    bool BitSet::operator==(const BitSet &set) const
    {
        if (this == &set)
            return true;

        if (words.size() != set.words.size())
            return false;

        // Check words in use by both BitSets
        for (uint32 i = 0; i < words.size(); i++)
            if (words[i] != set.words[i])
                return false;

        return true;
    }

    bool BitSet::operator!=(const BitSet &set) const
    {
        return !(*this == set);
    }

    void BitSet::serialize(ByteBuffer* buffer, SerializableControl* flusher) const {

        uint32 n = words.size();
        if (n == 0) {
            SerializeHelper::writeSize(0, buffer, flusher);
            return;
        }
        uint32 len = BYTES_PER_WORD * (n-1); // length excluding bits in the last word
        // count non-zero bytes in the last word
        for (uint64 x = words[n - 1]; x != 0; x >>= 8)
            len++;

        SerializeHelper::writeSize(len, buffer, flusher);
        flusher->ensureBuffer(len);

        n = len / 8; 
        for (uint32 i = 0; i < n; i++)
            buffer->putLong(words[i]);

        if (n < words.size())
            for (uint64 x = words[words.size() - 1]; x != 0; x >>= 8)
                buffer->putByte((int8) (x & 0xff));
    }

    void BitSet::deserialize(ByteBuffer* buffer, DeserializableControl* control) {

        uint32 bytes = static_cast<uint32>(SerializeHelper::readSize(buffer, control));	// in bytes

        size_t wordsInUse = (bytes + 7) / BYTES_PER_WORD;
        words.resize(wordsInUse);

        if (wordsInUse == 0)
            return;

        control->ensureData(bytes);

        uint32 i = 0;
        uint32 longs = bytes / 8;
        while (i < longs)
            words[i++] = buffer->getLong();

        for (uint32 j = i; j < wordsInUse; j++)
            words[j] = 0;

        for (uint32 remaining = (bytes - longs * 8), j = 0; j < remaining; j++)
            words[i] |= (buffer->getByte() & 0xffLL) << (8 * j);

        recalculateWordsInUse(); // Sender shouldn't add extra zero bytes, but don't fail it it does
    }

    epicsShareExtern std::ostream& operator<<(std::ostream& o, const BitSet& b)
    {
        o << '{';
        int32 i = b.nextSetBit(0);
        if (i != -1) {
            o << i;
            for (i = b.nextSetBit(i+1); i >= 0; i = b.nextSetBit(i+1)) {
                int32 endOfRun = b.nextClearBit(i);
                do { o << ", " << i; } while (++i < endOfRun);
            }
        }
        o << '}';
        return o;
    }

}};