// -*- c++ -*-

#ifndef ARRAY_MAP_FACTORY_H

#define ARRAY_MAP_FACTORY_H

#include <memory>

#include <hugo/extended_pair.h>

namespace hugo {

  template <typename MapRegistry> class ArrayMapFactory {

  public:

    typedef typename MapRegistry::Graph Graph;

    typedef typename MapRegistry::Key Key;

    typedef typename MapRegistry::KeyIt KeyIt;

    typedef typename MapRegistry::MapBase MapBase;

    template <typename V, typename A = std::allocator<V> > 

    class Map : public MapBase {

      public:

      typedef V Value;

      typedef A Allocator;

      Map() : values(0), capacity(0) {}

      Map(const Graph& g, MapRegistry& r) : MapBase(g, r) {

	allocate_memory();

	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	  int id = MapBase::getGraph()->id(it);

	  allocator.construct(&(values[id]), Value());

	}								

      }

      Map(const Graph& g, MapRegistry& r, const Value& v) : MapBase(g, r) {

	allocate_memory();

	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	  int id = MapBase::getGraph()->id(it);

	  allocator.construct(&(values[id]), v);

	}								

      }

      Map(const Map& copy) : MapBase(*copy.graph, *copy.registry) {

	capacity = copy.capacity;

	if (capacity == 0) return;

	values = allocator.allocate(capacity);

	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	  int id = MapBase::getGraph()->id(it);

	  allocator.construct(&(values[id]), copy.values[id]);

	}

      }

      template <typename CMap> Map(const CMap& copy) 

	: capacity(0), values(0), MapBase(copy) {

	if (MapBase::getGraph()) {

	  allocate_memory();

	  for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	    set(it, copy[it]);

	  }

	}

      }

      Map& operator=(const Map& copy) {

	if (&copy == this) return *this;

	if (capacity != 0) {

	  MapBase::destroy();

	  allocator.deallocate(values, capacity);

	}

	capacity = copy.capacity;

	if (capacity == 0) return *this;

	values = allocator.allocate(capacity);

	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	  int id = MapBase::getGraph()->id(it);

	  allocator.construct(&(values[id]), copy.values[id]);

	}

	return *this;

      }

      template <typename CMap> Map& operator=(const CMap& copy) {

	if (MapBase::getGraph()) {

	  MapBase::destroy();

	} 

	MapBase::operator=(copy);

	if (MapBase::getGraph()) {

	  allocate_memory();

	  for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	    set(it, copy[it]);

	  }

	}

	return *this;

      }

      virtual ~Map() {

	if (capacity != 0) {

	  MapBase::destroy();

	  allocator.deallocate(values, capacity);

	}

      }

      Value& operator[](const Key& key) {

	int id = MapBase::getGraph()->id(key);

	return values[id];

      } 

      const Value& operator[](const Key& key) const {

	int id = MapBase::getGraph()->id(key);

	return values[id];

      }

      const Value& get(const Key& key) const {

	int id = MapBase::getGraph()->id(key);

	return values[id];

      } 

      void set(const Key& key, const Value& val) {

	int id = MapBase::getGraph()->id(key);

	values[id] = val;

      }

      void add(const Key& key) {

	int id = MapBase::getGraph()->id(key);

	if (id >= capacity) {

	  int new_capacity = (capacity == 0 ? 1 : capacity);

	  while (new_capacity <= id) {

	    new_capacity <<= 1;

	  }

	  Value* new_values = allocator.allocate(new_capacity);;

	  for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	    int jd = MapBase::getGraph()->id(it);

	    if (id != jd) {

	      allocator.construct(&(new_values[jd]), values[jd]);

	      allocator.destroy(&(values[jd]));

	    }

	  }

	  if (capacity != 0) allocator.deallocate(values, capacity);

	  values = new_values;

	  capacity = new_capacity;

	}

	allocator.construct(&(values[id]), Value());

      }

      void erase(const Key& key) {

	int id = MapBase::getGraph()->id(key);

	allocator.destroy(&(values[id]));

      }

      void clear() {	

	if (capacity != 0) {

	  MapBase::destroy();

	  allocator.deallocate(values, capacity);

	  capacity = 0;

	}

      }

      class iterator {

	friend class Map;

	friend class const_iterator;

      private:

	/** Private constructor to initalize the the iterators returned

	 *  by the begin() and end().

	 */

	iterator (Map& pmap, const KeyIt& pit) : map(&pmap), it(pit) {}

      public:

	/** Default constructor. 

	 */

	iterator() {}

	typedef extended_pair<const Key&, const Key&, 

			      Value&, Value&> Reference;

	/** Dereference operator for map.

	 */	 

	Reference operator*() {

	  return Reference(it, (*map)[it]);

	}

	class Pointer {

	  friend class iterator;

	private:

	  Reference data;

	  Pointer(const Key& key, Value& val) : data(key, val) {}

	public:

	  Reference* operator->() {return &data;}

	};

	/** Arrow operator for map.

	 */	 

	Pointer operator->() {

	  return Pointer(it, ((*map)[it])); 

	}

	/** The pre increment operator of the map.

	 */

	iterator& operator++() { 

	  ++it; 

	  return *this; 

	}

	/** The post increment operator of the map.

	 */

	iterator operator++(int) { 

	  iterator tmp(it); 

	  ++it; 

	  return tmp; 

	}

	/** The equality operator of the map.

	 */

	bool operator==(const_iterator p_it) {

	  return p_it.it == it;

	}

	/** The not-equality operator of the map.

	 */

	bool operator!=(const_iterator p_it) {

	  return !(*this == p_it);

	}

      private:

	Map* map;

	KeyIt it;

      };

      /** Returns the begin iterator of the map.

       */

      iterator begin() {

	return iterator(*this, KeyIt(*MapBase::getGraph()));

      }

      /** Returns the end iterator of the map.

       */

      iterator end() {

	return iterator(*this, INVALID);

      }

      class const_iterator {

	friend class Map;

	friend class iterator;

      private:

	/** Private constructor to initalize the the iterators returned

	 *  by the begin() and end().

	 */

	const_iterator (const Map& pmap, const KeyIt& pit) 

	  : map(&pmap), it(pit) {}

      public:

	/** Default constructor. 

	 */

	const_iterator() {}

	/** Constructor to convert iterator to const_iterator.

	 */

	const_iterator(iterator p_it) : map(p_it.map), it(p_it.it) {}

	typedef extended_pair<const Key&, const Key&, 

	  const Value&, const Value&> Reference;

	/** Dereference operator for map.

	 */	 

	Reference operator*() {

	  return Reference(it, (*map)[it]);

	}

	class Pointer {

	  friend class const_iterator;

	private:

	  Reference data;

	  Pointer(const Key& key, const Value& val) : data(key, val) {}

	public:

	  Reference* operator->() {return &data;}

	};

	/** Arrow operator for map.

	 */	 

	Pointer operator->() {

	  return Pointer(it, ((*map)[it])); 

	}

	/** The pre increment operator of the map.

	 */

	const_iterator& operator++() { 

	  ++it; 

	  return *this; 

	}

	/** The post increment operator of the map.

	 */

	const_iterator operator++(int) { 

	  const_iterator tmp(it); 

	  ++it; 

	  return tmp; 

	}

	/** The equality operator of the map.

	 */

	bool operator==(const_iterator p_it) {

	  return p_it.it == it;

	}

	/** The not-equality operator of the map.

	 */

	bool operator!=(const_iterator p_it) {

	  return !(*this == p_it);

	}

      private:

	const Map* map;

	KeyIt it;

      };

      /** Returns the begin const_iterator of the map.

       */

      const_iterator begin() const {

	return const_iterator(*this, KeyIt(*MapBase::getGraph()));

      }

      /** Returns the end const_iterator of the map.

       */

      const_iterator end() const {

	return const_iterator(*this, INVALID);

      }

    private:

      void allocate_memory() {

	int max_id = -1;

	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {

	  int id = MapBase::getGraph()->id(it);

	  if (id > max_id) {

	    max_id = id;

	  }			

	}

	if (max_id == -1) {

	  capacity = 0;

	  values = 0;

	  return;

	}

	capacity = 1;

	while (capacity <= max_id) {

	  capacity <<= 1;

	}

	values = allocator.allocate(capacity);	

      }      

      int capacity;

      Value* values;

      Allocator allocator;

    };		

  };

}

#endif