/*

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

 * JITCraft is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * JITCraft. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _INCLUDE_KEIMA_HASHTABLE_H_

#define _INCLUDE_KEIMA_HASHTABLE_H_

#include <new>

#include <limits.h>

#include "Utility.h"

namespace ke {

template <typename T>

class HashTableEntry

{

    uint32 hash_;

    T t_;

  public:

    static const uint32 kFreeHash = 0;

    static const uint32 kRemovedHash = 1;

  public:

    void setHash(uint32 hash) {

        hash_ = hash;

    }

    uint32 hash() const {

        return hash_;

    }

    void setRemoved() {

        hash_ = kRemovedHash;

        t_ = T();

    }

    void construct() {

        hash_ = kFreeHash;

        new (&t_) T();

    }

    void destruct() {

        t_.~T();

    }

    bool removed() const {

        return hash_ == kRemovedHash;

    }

    bool free() const {

        return hash_ == kFreeHash;

    }

    bool isLive() const {

        return hash_ > kRemovedHash;

    }

    T &payload() {

        return t_;

    }

    bool sameHash(uint32 hash) const {

        return hash_ == hash;

    }

};

template <typename HashPolicy, typename AllocPolicy>

class HashTable : public AllocPolicy

{

    friend class iterator;

    typedef typename HashPolicy::Payload Payload;

    typedef HashTableEntry<Payload> Entry;

    uint32 capacity_;

    uint32 nelements_;

    uint32 ndeleted_;

    Entry *table_;

    uint32 minCapacity_;

  private:

    static const uint32 kMinCapacity = 16;

    static const uint32 kMaxCapacity = INT_MAX / sizeof(Entry);

    template <typename Key>

    uint32 computeHash(const Key &key) {

        // Multiply by golden ratio.

        uint32 hash = HashPolicy::hash(key) * 0x9E3779B9;

        if (hash == Entry::kFreeHash || hash == Entry::kRemovedHash)

            hash += 2;

        return hash;

    }

    Entry *createTable(uint32 capacity) {

        assert(capacity <= kMaxCapacity);

        Entry *table = (Entry *)this->malloc(capacity * sizeof(Entry));

        if (!table)

            return NULL;

        for (size_t i = 0; i < capacity; i++)

            table[i].construct();

        return table;

    }

  public:

    class Result

    {

        friend class HashTable;

        Entry *entry_;

        Entry &entry() {

            return *entry_;

        }

      public:

        Result(Entry *entry)

          : entry_(entry)

        { }

        Payload * operator ->() {

            return entry_->payload();

        }

        Payload & operator *() {

            return entry_->payload();

        }

        bool found() const {

            return entry_->isLive();

        }

    };

    class Insert : public Result

    {

        uint32 hash_;

      public:

        Insert(Entry *entry, uint32 hash)

          : Result(entry),

            hash_(hash)

        {

        }

        uint32 hash() const {

            return hash_;

        }

    };

  private:

    class Probulator {

        uint32 hash_;

        uint32 capacity_;

      public:

        Probulator(uint32 hash, uint32 capacity)

          : hash_(hash),

            capacity_(capacity)

        {

            assert(IsPowerOfTwo(capacity_)); 

        }

        uint32 entry() const {

            return hash_ & (capacity_ - 1);

        }

        uint32 next() {

            hash_++;

            return entry();

        }

    };

    bool underloaded() const {

        // Check if the table is underloaded: < 25% entries used.

        return (capacity_ > kMinCapacity) && (nelements_ + ndeleted_ < capacity_ / 4);

    }

    bool overloaded() const {

        // Grow if the table is overloaded: > 75% entries used.

        return (nelements_ + ndeleted_) > ((capacity_ / 2) + (capacity_ / 4));

    }

    bool shrink() {

        if ((capacity_ >> 1) < minCapacity_)

            return true;

        return changeCapacity(capacity_ >> 1);

    }

    bool grow() {

        assert(IsPowerOfTwo(kMaxCapacity));

        if (capacity_ >= kMaxCapacity) {

            this->reportAllocationOverflow();

            return false;

        }

        return changeCapacity(capacity_ << 1);

    }

    bool changeCapacity(uint32 newCapacity) {

        assert(newCapacity <= kMaxCapacity);

        Entry *newTable = createTable(newCapacity);

        if (!newTable)

            return false;

        Entry *oldTable = table_;

        uint32 oldCapacity = capacity_;

        table_ = newTable;

        capacity_ = newCapacity;

        ndeleted_ = 0;

        for (uint32 i = 0; i < oldCapacity; i++) {

            Entry &oldEntry = oldTable[i];

            if (oldEntry.isLive()) {

                Insert p = insertUnique(oldEntry.hash());

                p.entry().setHash(p.hash());

                p.entry().payload() = oldEntry.payload();

            }

            oldEntry.destruct();

        }

        this->free(oldTable);

        return true;

    }

    // For use when the key is known to be unique.

    Insert insertUnique(uint32 hash) {

        Probulator probulator(hash, capacity_);

        Entry *e = &table_[probulator.entry()];

        for (;;) {

            if (e->free() || e->removed())

                break;

            e = &table_[probulator.next()];

        }

        return Insert(e, hash);

    }

    template <typename Key>

    Result lookup(const Key &key) {

        uint32 hash = computeHash(key);

        Probulator probulator(hash, capacity_);

        Entry *e = &table_[probulator.entry()];

        for (;;) {

            if (e->free())

                break;

            if (e->isLive() &&

                e->sameHash(hash) &&

                HashPolicy::matches(key, e->payload()))

            {

                return Result(e);

            }

            e = &table_[probulator.next()];

        }

        return Result(e);

    }

    template <typename Key>

    Insert lookupForAdd(const Key &key) {

        uint32 hash = computeHash(key);

        Probulator probulator(hash, capacity_);

        Entry *e = &table_[probulator.entry()];

        for (;;) {

            if (!e->isLive())

                break;

            if (e->sameHash(hash) && HashPolicy::matches(key, e->payload()))

                break;

            e = &table_[probulator.next()];

        }

        return Insert(e, hash);

    }

    bool add(Insert &i) {

        assert(!i.found());

        // If the entry is deleted, just re-use the slot.

        if (i.entry().removed()) {

            ndeleted_--;

            return true;

        }

        // Otherwise, see if we're at max capacity.

        if (nelements_ == kMaxCapacity) {

            this->reportAllocationOverflow();

            return false;

        }

        // Check if the table is over or underloaded. The table is always at

        // least 25% free, so this check is enough to guarantee one free slot.

        // (Without one free slot, insertion search could infinite loop.)

        uint32 oldCapacity = capacity_;

        if (!checkDensity())

            return false;

        // If the table changed size, we need to find a new insertion point.

        // Note that a removed entry is impossible: either we caught it above,

        // or we just resized and no entries are removed.

        if (capacity_ != oldCapacity)

            i = insertUnique(i.hash());

        i.entry().setHash(i.hash());

        nelements_++;

        return true;

    }

    void remove(Entry &e) {

        assert(e.isLive());

        e.setRemoved();

        ndeleted_++;

        nelements_--;

    }

  public:

    HashTable(AllocPolicy ap)

      : AllocPolicy(ap),

        capacity_(0),

        nelements_(0),

        ndeleted_(0),

        table_(NULL),

        minCapacity_(kMinCapacity)

    {

    }

    ~HashTable()

    {

        for (uint32 i = 0; i < capacity_; i++)

            table_[i].destruct();

        this->free(table_);

    }

    bool init(uint32 capacity = 0) {

        if (capacity < kMinCapacity)

            capacity = kMinCapacity;

        else if (capacity > kMaxCapacity)

            capacity = kMaxCapacity;

        minCapacity_ = capacity;

        assert(IsPowerOfTwo(capacity));

        capacity_ = capacity;

        table_ = createTable(capacity_);

        if (!table_)

            return false;

        return true;

    }

    template <typename Key>

    Result find(const Key &key) {

        return lookup(key);

    }

    template <typename Key>

    Insert findForAdd(const Key &key) {

        return lookupForAdd(key);

    }

    bool add(Insert &i, const Payload &payload) {

        if (!add(i))

            return false;

        *i = payload;

        return true;

    }

    bool checkDensity() {

        if (underloaded())

            return shrink(); 

        if (overloaded())

            return grow();

        return true;

    }

  public:

    class iterator

    {

        HashTable *table_;

        Entry *i_;

        Entry *end_;

      public:

        iterator(HashTable *table)

          : table_(table),

            i_(table->table_),

            end_(table->table_ + table->capacity_)

        {

            while (i_ < end_ && !i_->isLive())

                i_++;

        }

        bool empty() const {

            return i_ == end_;

        }

        void erase() {

            assert(!empty());

            table_->remove(*i_);

        }

        const Payload &operator *() const {

            return i_->payload();

        }

        void next() {

            do {

                i_++;

            } while (i_ < end_ && !i_->isLive());

        }

    };

};

}

#endif // _INCLUDE_KEIMA_HASHTABLE_H_