/*

 *  Hash.cpp

 *  Ottoman

 *

 *  Created by Jens Alfke on 8/20/09.

 *  Copyright 2009 Jens Alfke. All rights reserved.

 *  BSD-Licensed: See the file "LICENSE.txt" for details.

 */

#include "Hash.h"

#include "Dictionary.h"

#include <algorithm>

namespace Mooseyard {

    class Hash::IndexEntry {

    public:

        IndexEntry (Key key, Hash::Value value =NULL)

            :_key(key), 

             _value(value) 

        { }

        Key key() const                             {return _key;}

        HashCode hash() const                       {return _key.hash;}

        Hash::Value value() const                   {return _key.bytes ?_value :NULL;}

        void setValue (Hash::Value value)           {_value = value;}

        bool isAvailable() const                    {return _value == NULL;}    // false if deleted

        bool hasValue() const                       {return _key.bytes != NULL;}// false if deleted

        bool operator==(const IndexEntry &e) const  {return _key.hash==e._key.hash && _key.equals(e._key);}

        bool operator!=(const IndexEntry &e) const  {return ! (*this==e);}

        void markDeleted()                          {_key.bytes = NULL; _value = (Hash::Value)-1;}

        void markEmpty()                            {_key.bytes = NULL; _value = NULL;}

    private:

        Key _key;                       // bytes will be NULL if empty or deleted

        Hash::Value _value;             // NULL if empty, -1 if deleted

    };

    Hash::Hash (int capacity)

        :_count(0),

         _tableSize( Dictionary::choosePowerOfTwoSize(capacity) ),

         _table( (IndexEntry*) calloc(_tableSize,sizeof(IndexEntry)) )

    { }

    Hash::~Hash() {

        free(_table);

    }

    Hash::IndexEntry& Hash::_find (Key key) const {

        Key k = Key(key);

        IndexEntry newEntry(k);

        int index = newEntry.hash() % _tableSize;

        IndexEntry *found = &_table[index];

        int probe = 0;

        while (!found->isAvailable() && (!found->hasValue() || *found != newEntry)) {

            index = (index + ++probe) % _tableSize;

            found = &_table[index];

        }

        return *found;

    }

    Hash::IndexEntry& Hash::_findForPut (const Hash::IndexEntry &newEntry) {

        int index = newEntry.hash() % _tableSize;

        IndexEntry *found = &_table[index];

        int probe = 0;

        while (found->hasValue() && *found != newEntry) {

            index = (index + ++probe) % _tableSize;

            found = &_table[index];

        }

        return *found;

    }

    Hash::Value Hash::get(Key key) const {

        return _find(key).value();

    }

    void Hash::put(Key key, Hash::Value value) {

        IndexEntry newEntry = IndexEntry(Key(key),value);

        IndexEntry &found = _findForPut(newEntry);

        if (found.hasValue())

            found.setValue(value);

        else {

            found = newEntry;

            _count++;

            if (_count/(float)_tableSize > Dictionary::kMaxLoadFactor)

                _resize(2*_tableSize);

        }

    }

    bool Hash::remove(Key key) {

        IndexEntry &entry = _find(key);

        if (!entry.value())

            return false;

        entry.markDeleted();

        _count--;

        if (_count/(float)_tableSize < Dictionary::kMinLoadFactor)

            _resize(_tableSize/2);

        return true;

    }

    void Hash::removeAll() {

        memset(_table, 0, _tableSize*sizeof(*_table));

        _count = 0;

    }

    void Hash::dump() const {

        for (int index=0; index<_tableSize; index++)

            if (_table[index].hasValue()) {

                Blob key = _table[index].key();

                printf("%3i: %*s -> %p\n", 

                       index, (int)key.length,(const char*)key.bytes, _table[index].value());

            }

    }

    void Hash::_resize(int newSize) {

        newSize = std::max(newSize, Dictionary::kMinSize);

        if (newSize != _tableSize) {

            IndexEntry* oldTable = _table;

            int oldTableSize = _tableSize;

            _tableSize = newSize;

            _table = (IndexEntry*) calloc(_tableSize,sizeof(IndexEntry));

            // Add existing entries to new table:

            for (int index=0; index<oldTableSize; index++) {

                IndexEntry &entry = oldTable[index];

                if (entry.value())

                    _findForPut(entry) = entry;

            }

            free(oldTable);

        }

    }

    Hash::Iterator::Iterator (const Hash *hash)

        :_entry(hash->_table-1), _end(hash->_table+hash->_tableSize)

    {

        next();

    }

    Hash::Iterator::Iterator (const Hash &hash)

        :_entry(hash._table-1), _end(hash._table+hash._tableSize)

    {

        next();

    }

    bool Hash::Iterator::next() {

        while (++_entry < _end) {

            if (_entry->hasValue())

                return true;

        }

        return false;

    }

    Key Hash::Iterator::key() const                 {return _entry->key();}

    Hash::Value Hash::Iterator::value() const       {return _entry->value();}

}