//! \addtogroup Containers
//! \{
//! \file pideque.h
//! \brief
//! \~english Declares \a PIMap
//! \~russian Объявление \a PIMap
//! \~\authors
//! \~english
//! Ivan Pelipenko peri4ko@yandex.ru;
//! Andrey Bychkov work.a.b@yandex.ru;
//! \~russian
//! Иван Пелипенко peri4ko@yandex.ru;
//! Андрей Бычков work.a.b@yandex.ru;
//! \~\}
/*
	PIP - Platform Independent Primitives
	Associative array with custom types of key and value
	Ivan Pelipenko peri4ko@yandex.ru

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program 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 Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef PIMAP_H
#define PIMAP_H

#include "pivector.h"
#include "pideque.h"
#include "pipair.h"


template <typename Key, typename T>
class PIMapIterator;

template <typename Key, typename T>
class PIMapReverseIterator;


//! \addtogroup Containers
//! \{
//! \class PIMap
//! \brief
//! \~english Associative array.
//! \~russian Словарь.
//! \~\}
//! \details
//! \~english
//! A collection of key/value pairs, from which you retrieve a value using its associated key.
//! There is a finite number of keys in the map, and each key has exactly one value associated with it.
//! \a value() returns value for key and leave map
//! unchaged in any case. \a operator [] create entry in map if
//! there is no entry for given key. You can retrieve all
//! keys by method \a keys() and all values by methos \a values().
//! To iterate all entries use class PIMapIterator, or methods
//! \a makeIterator() and \a makeReverseIterator().
//! A key in the Map may only occur once.
//! \~russian
//! Словари, в принципе, похожи на обычные, используемые в повседневной жизни.
//! Они хранят элементы одного и того же типа, индексируемые ключевыми значениями.
//! Достоинство словаря в том, что он позволяет быстро получать значение,
//! ассоциированное с заданным ключом.
//! Ключи должны быть уникальными.
//! Элемент
//! В контейнеры этого типа заносятся элементы вместе с ключами,
//! по которым их можно найти, которыми могут выступать значения любого типа.
//! \a operator [] позволяет получить доступ к элементу по ключу,
//! и если такого эелемента небыло, то он будет создан.
template <typename Key, typename T>
class PIMap {
	template <typename Key1, typename T1> friend class PIMapIterator;
	template <typename Key1, typename T1> friend class PIMapReverseIterator;
	template <typename P, typename Key1, typename T1>
	friend PIBinaryStream<P> & operator <<(PIBinaryStream<P> & s, const PIMap<Key1, T1> & v);
	template <typename P, typename Key1, typename T1>
	friend PIBinaryStream<P> & operator >>(PIBinaryStream<P> & s, PIMap<Key1, T1> & v);
public:
	typedef T mapped_type;
	typedef Key key_type;
	typedef PIPair<Key, T> value_type;

	//! \~english Constructs an empty map.
	//! \~russian Создает пустой словарь.
	PIMap() {}

	//! \~english Copy constructor.
	//! \~russian Копирующий конструктор.
	PIMap(const PIMap<Key, T> & other) {*this = other;}

	//! \~english Move constructor.
	//! \~russian Перемещающий конструктор.
	PIMap(PIMap<Key, T> && other) : pim_content(std::move(other.pim_content)), pim_index(std::move(other.pim_index)) {}

	//! \~english Contructs map from
	//! [C++11 initializer list](https://en.cppreference.com/w/cpp/utility/initializer_list).
	//! \~russian Создает словарь из
	//! [списка инициализации C++11](https://ru.cppreference.com/w/cpp/utility/initializer_list).
	//! \~\details
	//! \~\code
	//! PIMap <int, PIString> m{{1, "a"}, {2, "b"}};
	//! piCout << m; // {1, 2, 3}
	//! \endcode
	PIMap(std::initializer_list<std::pair<Key, T>> init_list) {
		for (auto i: init_list) {
			insert(std::get<0>(i), std::get<1>(i));
		}
	}

	//! \~english Assign operator.
	//! \~russian Оператор присваивания.
	PIMap<Key, T> & operator =(const PIMap<Key, T> & other) {
		if (this == &other) return *this;
		clear();
		pim_content = other.pim_content;
		pim_index = other.pim_index;
		return *this;
	}

	//! \~english Assign move operator.
	//! \~russian Оператор перемещающего присваивания.
	PIMap<Key, T> & operator =(PIMap<Key, T> && other) {
		swap(other);
		return *this;
	}
	
	class iterator {
		friend class PIMap<Key, T>;
	private:
		iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
		const PIMap<Key, T> * parent;
		ssize_t pos;
	public:
		iterator(): parent(nullptr), pos(0) {}
		const Key & key() const {return const_cast<PIMap<Key, T> * >(parent)->_key(pos);}
		T & value() {return const_cast<PIMap<Key, T> * >(parent)->_value(pos);}
		inline PIPair<Key, T> operator *() const {
			return PIPair<Key, T>(const_cast<PIMap<Key, T> * >(parent)->_key(pos), const_cast<PIMap<Key, T> * >(parent)->_value(pos));
		}
		void operator ++() {++pos;}
		void operator ++(int) {++pos;}
		void operator --() {--pos;}
		void operator --(int) {--pos;}
		bool operator ==(const iterator & it) const {return (pos == it.pos);}
		bool operator !=(const iterator & it) const {return (pos != it.pos);}
	};
	
	class reverse_iterator {
		friend class PIMap<Key, T>;
	private:
		reverse_iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
		const PIMap<Key, T> * parent;
		ssize_t pos;
	public:
		reverse_iterator(): parent(nullptr), pos(0) {}
		const Key & key() const {return const_cast<PIMap<Key, T> * >(parent)->_key(pos);}
		T & value() const {return const_cast<PIMap<Key, T> * >(parent)->_value(pos);}
		inline PIPair<Key, T> operator *() const {
			return PIPair<Key, T>(const_cast<PIMap<Key, T> * >(parent)->_key(pos), const_cast<PIMap<Key, T> * >(parent)->_value(pos));
		}
		void operator ++() {--pos;}
		void operator ++(int) {--pos;}
		void operator --() {++pos;}
		void operator --(int) {++pos;}
		bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
		bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
	};
	
	class const_iterator {
		friend class PIMap<Key, T>;
	private:
		const_iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
		const PIMap<Key, T> * parent;
		ssize_t pos;
	public:
		const_iterator(): parent(nullptr), pos(0) {}
		const value_type operator *() const {return parent->_pair(pos);}
		const Key & key() const {return const_cast<PIMap<Key, T> * >(parent)->_key(pos);}
		const T & value() const {return const_cast<PIMap<Key, T> * >(parent)->_value(pos);}
		void operator ++() {++pos;}
		void operator ++(int) {++pos;}
		void operator --() {--pos;}
		void operator --(int) {--pos;}
		bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
		bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
	};
	
	class const_reverse_iterator {
		friend class PIMap<Key, T>;
	private:
		const_reverse_iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
		const PIMap<Key, T> * parent;
		ssize_t pos;
	public:
		const_reverse_iterator(): parent(nullptr), pos(0) {}
		const value_type operator *() const {return parent->_pair(pos);}
		void operator ++() {--pos;}
		void operator ++(int) {--pos;}
		void operator --() {++pos;}
		void operator --(int) {++pos;}
		bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
		bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
	};


 	iterator begin() {return iterator(this, 0);}

 	iterator end() {return iterator(this, size());}

	const_iterator begin() const {return const_iterator(this, 0);}

	const_iterator end() const {return const_iterator(this, size());}

	const_iterator constBegin() const {return const_iterator(this, 0);}

	const_iterator constEnd() const {return const_iterator(this, size());}

 	reverse_iterator rbegin() {return reverse_iterator(this, size() - 1);}

 	reverse_iterator rend() {return reverse_iterator(this, -1);}

	const_reverse_iterator rbegin() const {return const_reverse_iterator(this, size() - 1);}

	const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}

	const_reverse_iterator constRbegin() const {return const_reverse_iterator(this, size() - 1);}

	const_reverse_iterator constRend() const {return const_reverse_iterator(this, -1);}

	//! \relatesalso PIMapIterator
	PIMapIterator<Key, T> makeIterator()  const {return PIMapIterator<Key, T>(*this);}

	//! \relatesalso PIMapReverseIterator
	PIMapReverseIterator<Key, T> makeReverseIterator() const {return PIMapReverseIterator<Key, T>(*this);}

	size_t size() const {return pim_content.size();}

	int size_s() const {return pim_content.size_s();}

	size_t length() const {return pim_content.size();}

	bool isEmpty() const {return (pim_content.size() == 0);}

	bool isNotEmpty() const {return (pim_content.size() > 0);}
	
	T & operator [](const Key & key) {
		bool f(false);
		ssize_t i = _find(key, f);
		if (f) return pim_content[pim_index[i].index];
		pim_content.push_back(T());
		pim_index.insert(i, MapIndex(key, pim_content.size() - 1));
		return pim_content.back();
	}
	T at(const Key & key) const {return value(key);}

	T take(const Key & key) const {
		bool f(false);
		ssize_t i = _find(key, f);
		if (!f) return T();
		T ret(pim_content[pim_index[i].index]);
		_remove(i);
		return ret;
	}
	
	PIMap<Key, T> & operator <<(const PIMap<Key, T> & other) {
#ifndef NDEBUG
		if (&other == this) {
			printf("error with PIMap<%s, %s>::<<\n", __PIP_TYPENAME__(Key), __PIP_TYPENAME__(T));
		}
#endif
		assert(&other != this);
		if (other.isEmpty()) return *this;
		if (other.size() == 1) {
			insert(other.pim_index[0].key, other.pim_content[0]);
			return *this;
		}
		if (other.size() == 2) {
			insert(other.pim_index[0].key, other.pim_content[0]);
			insert(other.pim_index[1].key, other.pim_content[1]);
			return *this;
		}
		for (int i = 0; i < other.pim_index.size_s(); ++i) {
			insert(other.pim_index[i].key, other.pim_content[other.pim_index[i].index]);
		}
		return *this;
	}

	bool operator ==(const PIMap<Key, T> & t) const {
		return (pim_content == t.pim_content && pim_index == t.pim_index);
	}
	bool operator !=(const PIMap<Key, T> & t) const {
		return (pim_content != t.pim_content || pim_index != t.pim_index);
	}
	bool contains(const Key & key) const {
		bool f(false); _find(key, f);
		return f;
	}

	bool containsValue(const T & value) const {
		return pim_content.contains(value);
	}

	PIMap<Key, T> & reserve(size_t new_size) {
		pim_content.reserve(new_size);
		pim_index.reserve(new_size);
		return *this;
	}

	PIMap<Key, T> & remove(const Key & key) {
		bool f(false);
		ssize_t i = _find(key, f);
		if (f) _remove(i);
		return *this;
	}


	PIMap<Key, T> & removeWhere(std::function<bool(const Key & key, const T & value)> test) {
		for (int i = 0; i < pim_index.size_s(); ++i) {
			if (pim_index[i].key, pim_content[pim_index[i].index]) {
				_remove(i);
				--i;
			}
		}
	}

	PIMap<Key, T> & erase(const Key & key) {return remove(key);}

	PIMap<Key, T> & clear() {
		pim_content.clear();
		pim_index.clear();
		return *this;
	}
	
	void swap(PIMap<Key, T> & other) {
		pim_content.swap(other.pim_content);
		pim_index.swap(other.pim_index);
	}

	PIMap<Key, T> & insert(const Key & key, const T & value) {
		bool f(false);
		ssize_t i = _find(key, f);
		if (f) {
			pim_content[pim_index[i].index] = value;
		} else {
			pim_content.push_back(value);
			pim_index.insert(i, MapIndex(key, pim_content.size() - 1));
		}
		return *this;
	}
	PIMap<Key, T> & insert(const Key & key, T && value) {
		bool f(false);
		ssize_t i = _find(key, f);
		if (f) {
			pim_content[pim_index[i].index] = std::move(value);
		} else {
			pim_content.push_back(std::move(value));
			pim_index.insert(i, MapIndex(key, pim_content.size() - 1));
		}
		return *this;
	}
	PIMap<Key, T> & insert(const PIPair<Key, T> & pair) {
		bool f(false);
		ssize_t i = _find(pair.first, f);
		if (f) {
			pim_content[pim_index[i].index] = pair.second;
		} else {
			pim_content.push_back(pair.second);
			pim_index.insert(i, MapIndex(pair.first, pim_content.size() - 1));
		}
		return *this;
	}
	PIMap<Key, T> & insert(PIPair<Key, T> && pair) {
		bool f(false);
		Key k(std::move(pair.first));
		ssize_t i = _find(k, f);
		if (f) {
			pim_content[pim_index[i].index] = std::move(pair.second);
		} else {
			pim_content.push_back(std::move(pair.second));
			pim_index.insert(i, MapIndex(k, pim_content.size() - 1));
		}
		return *this;
	}

	T value(const Key & key, const T & default_ = T()) const {
		bool f(false);
		ssize_t i = _find(key, f);
		if (!f) return default_;
		return pim_content[pim_index[i].index];
	}

	PIVector<T> values() const {return pim_content;}

	Key key(const T & value_, const Key & default_ = Key()) const {
		for (int i = 0; i < pim_index.size_s(); ++i) {
			if (pim_content[pim_index[i].index] == value_) {
				return pim_index[i].key;
			}
		}
		return default_;
	}

	PIVector<Key> keys() const {
		PIVector<Key> ret;
		ret.reserve(pim_index.size());
		for (int i = 0; i < pim_index.size_s(); ++i) {
			ret << pim_index[i].key;
		}
		return ret;
	}

	void forEach(std::function<void(const Key & key, const T & value)> f) const {
		for (int i = 0; i < pim_index.size_s(); ++i) {
			f(pim_index[i].key, pim_content[pim_index[i].index]);
		}
	}

	template <typename Key2, typename T2>
	inline PIMap<Key2, T2> map(std::function<PIPair<Key2, T2>(const Key & key, const T & value)> f) const {
		PIMap<Key2, T2> ret; ret.reserve(size());
		for (int i = 0; i < pim_index.size_s(); ++i) {
			ret.insert(f(pim_index[i].key, pim_content[pim_index[i].index]));
		}
		return ret;
	}

	template <typename ST>
	inline PIVector<ST> map(std::function<ST(const Key & key, const T & value)> f) const {
		PIVector<ST> ret; ret.reserve(size());
		for (int i = 0; i < pim_index.size_s(); ++i) {
			ret << f(pim_index[i].key, pim_content[pim_index[i].index]);
		}
		return ret;
	}
	
private:
	struct MapIndex {
		MapIndex(const Key & k = Key(), size_t i = 0): key(k), index(i) {}
		MapIndex(Key && k, size_t i = 0): key(std::move(k)), index(i) {}
		Key key;
		size_t index;
		bool operator ==(const MapIndex & s) const {return key == s.key;}
		bool operator !=(const MapIndex & s) const {return key != s.key;}
		bool operator <(const MapIndex & s) const {return key < s.key;}
		bool operator >(const MapIndex & s) const {return key > s.key;}
	};

	template <typename P, typename Key1, typename T1>
	friend PIBinaryStream<P> & operator >>(PIBinaryStream<P> & s, PIDeque<typename PIMap<Key1, T1>::MapIndex> & v);
	template <typename P, typename Key1, typename T1>
	friend PIBinaryStream<P> & operator <<(PIBinaryStream<P> & s, const PIDeque<typename PIMap<Key1, T1>::MapIndex> & v);

	ssize_t _binarySearch(ssize_t first, ssize_t last, const Key & key, bool & found) const {
		ssize_t mid;
		while (first <= last) {
			mid = (first + last) / 2;
			if (key > pim_index[mid].key) first = mid + 1;
			else if (key < pim_index[mid].key) last = mid - 1;
			else {found = true; return mid;}
		}
		found = false;
		return first;
	}

	ssize_t _find(const Key & k, bool & found) const {
		if (pim_index.isEmpty()) {
			found = false;
			return 0;
		}
		return _binarySearch(0, pim_index.size_s() - 1, k, found);
	}

	void _remove(ssize_t index) {
		size_t ci = pim_index[index].index, bi = pim_index.size() - 1;
		pim_index.remove(index);
		for (size_t i = 0; i < pim_index.size(); ++i) {
			if (pim_index[i].index == bi) {
				pim_index[i].index = ci;
				break;
			}
		}
		piSwap<T>(pim_content[ci], pim_content.back());
		pim_content.resize(pim_index.size());
	}

	const value_type _pair(ssize_t index) const {
		if (index < 0 || index >= pim_index.size_s()) return value_type();
		return value_type(pim_index[index].key, pim_content[pim_index[index].index]);
	}

	Key & _key(ssize_t index) {return pim_index[index].key;}

	const Key & _key(ssize_t index) const {return pim_index[index].key;}

	T & _value(ssize_t index) {return pim_content[pim_index[index].index];}

	const T & _value(ssize_t index) const {return pim_content[pim_index[index].index];}
	

	PIVector<T> pim_content;
	PIDeque<MapIndex> pim_index;
};


//! \addtogroup Containers
//! \{
//! \class PIMapIterator
//! \brief
//! \~english Java-style iterator for \a PIMap.
//! \~russian Итератор Java стиля для \a PIMap.
//! \~\}
//! \details
//! \~english
//! This class used to easy serial access keys and values in PIMap.
//! You can use constructor to create iterator, or use \a PIMap::makeIterator()
//! \~russian
//! Этот класс используется для удобного перебора ключей и значений всего словаря в обратном порядке.
//! Ты можешь использовать конструктор, в который передать словарь, или функцию словаря \a PIMap::makeReverseIterator().
//! \~
//! \code
//! PIMap<int, PIString> m;
//! m[1] = "one";
//! m[2] = "two";
//! m[4] = "four";
//! auto it = m.makeIterator();
//! while (it.next()) {
//!     piCout << it.key() << it.value();
//! // 1 one
//! // 2 two
//! // 4 four
//! \endcode
template <typename Key, typename T>
class PIMapIterator {
	typedef PIMap<Key, T> MapType;
public:
	PIMapIterator(const PIMap<Key, T> & map, bool reverse = false): m(map), pos(-1) {}

	//! \~english Returns current key.
	//! \~russian Возвращает ключ текущего элемента.
	//! \~\sa \a value(), \a valueRef()
	const Key & key() const {
		return m._key(pos);
	}

	//! \~english Returns current value.
	//! \~russian Возвращает значение текущего элемента.
	//! \~\sa \a key(), \a valueRef()
	const T & value() const {
		return m._value(pos);
	}


	//! \~english Returns current value reference.
	//! \~russian Возвращает изменяемую ссылку на значение текущего элемента.
	//! \~\sa \a key(), \a value()
	T & valueRef() {
		return const_cast<MapType & >(m)._value(pos);
	}

	//! \~english Returns true if iterator can jump to next entry
	//! \~russian Возвращает true если итератор может перейти к следующему элементу.
	inline bool hasNext() const {
		return pos < (m.size_s() - 1);
	}

	//! \~english Jump to next entry and return true if new position is valid.
	//! \~russian Переходит к следующему элементу и возвращает true если он существует.
	inline bool next() {
		++pos;
		return pos < m.size_s();
	}

	//! \~english Reset iterator to initial position.
	//! \~russian Переходит на начало.
	inline void reset() {
		pos = -1;
	}
private:
	const MapType & m;
	ssize_t pos;
};


//! \addtogroup Containers
//! \{
//! \class PIMapReverseIterator
//! \brief
//! \~english Java-style reverse iterator for \a PIMap.
//! \~russian Итератор Java стиля для \a PIMap в обратном порядке.
//! \~\}
//! \details
//! \~english
//! This class used to easy serial reverse access keys and values in PIMap.
//! You can use constructor to create iterator, or use \a PIMap::makeReverseIterator().
//! \~russian
//! Этот класс используется для удобного перебора ключей и значений всего словаря в обратном порядке.
//! Ты можешь использовать конструктор, в который передать словарь, или функцию словаря \a PIMap::makeReverseIterator().
//! \~
//! \code
//! PIMap<int, PIString> m;
//! m[1] = "one";
//! m[2] = "two";
//! m[4] = "four";
//! auto it = m.makeReverseIterator();
//! while (it.next()) {
//!     piCout << it.key() << it.value();
//! }
//! // 4 four
//! // 2 two
//! // 1 one
//! \endcode
//! \~english Write access:
//! \~russian Доступ на запись:
//! \~
//! \code
//! while (it.next()) {
//!     it.valueRef().append("_!");
//!     piCout << it.key() << it.value();
//! }
//! // 4 four_!
//! // 2 two_!
//! // 1 one_!
//! \endcode
template <typename Key, typename T>
class PIMapReverseIterator {
	typedef PIMap<Key, T> MapType;
public:
	PIMapReverseIterator(const PIMap<Key, T> & map): m(map), pos(m.size_s()) {}

	//! \~english Returns current key.
	//! \~russian Возвращает ключ текущего элемента.
	//! \~\sa \a value(), \a valueRef()
	const Key & key() const {
		return m._key(pos);
	}

	//! \~english Returns current value.
	//! \~russian Возвращает значение текущего элемента.
	//! \~\sa \a key(), \a valueRef()
	const T & value() const {
		return m._value(pos);
	}


	//! \~english Returns current value reference.
	//! \~russian Возвращает изменяемую ссылку на значение текущего элемента.
	//! \~\sa \a key(), \a value()
	T & valueRef() {
		return const_cast<MapType & >(m)._value(pos);
	}

	//! \~english Returns true if iterator can jump to next entry
	//! \~russian Возвращает true если итератор может перейти к следующему элементу.
	inline bool hasNext() const {
		return pos > 0;
	}

	//! \~english Jump to next entry and return true if new position is valid.
	//! \~russian Переходит к следующему элементу и возвращает true если он существует.
	inline bool next() {
		--pos;
		return pos >= 0;
	}

	//! \~english Reset iterator to initial position.
	//! \~russian Переходит на начало.
	inline void reset() {
		pos = m.size_s();
	}
private:
	const MapType & m;
	ssize_t pos;
};


#ifdef PIP_STD_IOSTREAM
//! \~english Output operator to [std::ostream](https://en.cppreference.com/w/cpp/io/basic_ostream).
//! \~russian Оператор вывода в [std::ostream](https://ru.cppreference.com/w/cpp/io/basic_ostream).
template<typename Key, typename Type>
inline std::ostream & operator <<(std::ostream & s, const PIMap<Key, Type> & v) {
	s << "{";
	bool first = true;
	for (typename PIMap<Key, Type>::const_iterator i = v.begin(); i != v.end(); ++i) {
		if (!first)
			s << ", ";
		first = false;
		s << i.key() << ": " << i.value();
	}
	s << "}";
	return s;
}
#endif


//! \relatesalso PICout
//! \~english Output operator to \a PICout
//! \~russian Оператор вывода в \a PICout
template<typename Key, typename Type>
inline PICout operator <<(PICout s, const PIMap<Key, Type> & v) {
	s.space();
	s.setControl(0, true);
	s << "{";
	bool first = true;
	for (typename PIMap<Key, Type>::const_iterator i = v.begin(); i != v.end(); ++i) {
		if (!first)
			s << ", ";
		first = false;
		s << i.key() << ": " << i.value();
	}
	s << "}";
	s.restoreControl();
	return s;
}

template<typename Key, typename Type>
inline void piSwap(PIMap<Key, Type> & f, PIMap<Key, Type> & s) {f.swap(s);}


#endif // PIMAP_H