#ifndef _HASH_CC
#define _HASH_CC

#include <iostream>

#include "Hash.h"
#include "AssocList.cc"

#include "test_utilities.h"

// destructor
template <class KEY, class VALUE>
HashTable<KEY,VALUE>::~HashTable() {}

// constructor without default value

template <class KEY, class VALUE>
HashTable<KEY,VALUE>::HashTable() :
  starting_modulus(7),
  n_keys(0),  
  hash_modulus(starting_modulus), 
  use_default(0) 
{
}

// constructor with default value

template <class KEY, class VALUE>
HashTable<KEY,VALUE>::HashTable(VALUE const &def) 
  : starting_modulus(7),
    n_keys(0),  
    hash_modulus(starting_modulus), 
    use_default(1), 
    default_init(def)
{
}

// copy constructor
template <class KEY, class VALUE>
HashTable<KEY,VALUE>::HashTable(const HashTable& a) 
  : starting_modulus(a.starting_modulus),
    n_keys(a.n_keys), 
    hash_modulus(a.hash_modulus), 
    buckets(a.buckets)		// calls copy constructor for Array<AssocList<KEY,VALUE> >
{ 
}

// operator=

template <class KEY, class VALUE>
// deep copy
HashTable<KEY,VALUE>& HashTable<KEY,VALUE>::operator=(const HashTable& a) {
  n_keys = a.n_keys;
  hash_modulus = a.hash_modulus;
  buckets = a.buckets;	// deep copy, okay if &a == this
  return *this;
}

// clear

template <class KEY, class VALUE>
void 
HashTable<KEY,VALUE>::clear() { 
  n_keys = 0;  
  hash_modulus = starting_modulus; 
  buckets.clear(); 
}

// hash

template <class KEY, class VALUE>
int 
HashTable<KEY,VALUE>::hash(KEY const & k) const { 
  return Hash(k) % hash_modulus; 
}

// grow

template <class KEY, class VALUE>
void HashTable<KEY,VALUE>::grow() {

  const int new_modulus = hash_modulus * 3;
  const Array<KEY> _keys = keys();
  const HashTable<KEY,VALUE> copy(*this); // only works if copy constructor cannot call grow

  clear();

  hash_modulus = new_modulus;

  for (int i = 0;  i < _keys.size();  ++i) 
    (*this)[_keys[i]] = copy[_keys[i]];
}

// exists

template <class KEY, class VALUE>
int 
HashTable<KEY,VALUE>::exists(KEY const & k) const { 
  return hash(k) < buckets.size() && buckets[hash(k)].exists(k); 
}

// remove

template <class KEY, class VALUE>
void 
HashTable<KEY,VALUE>::remove(KEY const & k) { 
  if (exists(k)) --n_keys;  
  buckets[hash(k)].remove(k); 
}

// operator[] and const operator[]

template <class KEY, class VALUE>
VALUE & HashTable<KEY,VALUE>::operator[](KEY const & k) { 

  if (n_keys >= hash_modulus) grow();

  if (! exists(k)) {
    ++n_keys;
    if (use_default) 
      buckets[hash(k)][k] = default_init;
  }
  return buckets[hash(k)][k];
}

template <class KEY, class VALUE>
VALUE HashTable<KEY,VALUE>::operator[](KEY const & k) const { 
  if (exists(k)) return buckets[hash(k)][k];

  die("HashTable index out of range");
}
    
// keys() and values()

template <class KEY, class VALUE>
Array<KEY> HashTable<KEY,VALUE>::keys() const {
  Array<KEY> keys;

  for (int i = 0;  i < buckets.size();  ++i) {
    Array<KEY> bucket_keys = buckets[i].keys();
    for (int j = 0;  j < bucket_keys.size();  ++j)
      keys[keys.size()] = bucket_keys[j];
  }
  return keys;
}

template <class KEY, class VALUE>
Array<VALUE> 
HashTable<KEY,VALUE>::values() const {
  Array<VALUE> values;

  for (int i = 0;  i < buckets.size();  ++i) {
    Array<VALUE> bucket_values = buckets[i].values();
    for (int j = 0;  j < bucket_values.size();  ++j)
      values[values.size()] = bucket_values[j];
  }
  return values;
}


// operator<<

template <class KEY, class VALUE>
std::ostream & 
operator<<(std::ostream & out, const HashTable<KEY,VALUE> & a) {

  out << "n_keys = " << a.n_keys << ", hash_modulus = " << a.hash_modulus << "\nbuckets = {" << std::endl;

  for (int i = 0;  i < a.buckets.size();  ++i) {
    if (i != 0) out << "," << std::endl;
    out << " bucket[" << i << "] = " << a.buckets[i];
  }
  out << "\n}" << std::endl;

  return out;
}

#endif