#pragma once

#include <list>
#include <map>
#include <iostream>
#include <sstream>
#include <utility>

using namespace std;

template <typename K, typename V>
class MultiMap
{
private:
	map<K, list<V> > mapOfLists;

public:
	MultiMap();
	~MultiMap();

	void Put(const K& key_, const V& value_);
	void Put(const K& key_, list<V>& listPassedByClient_);
	
	void DisplayAllKeys() const; 
	void DisplayAllValues() const;
	void DisplayAllValuesForAKey(const K& key_) const;
	
	void RemoveAllValues(const K& key_);
	void RemoveAValueForAKey(const K& key_, const V& value_);
	void RemoveKeyAndValues(const K& key_);

	pair<K,V> MakePair(const K& key_, const V& value_); 
	void Put(const pair<K,V>& pair_);

	void DisplayMap() const;
};


template <typename K, typename V>
MultiMap<K,V>::MultiMap()
{
}


template <typename K, typename V>
MultiMap<K,V>::~MultiMap()
{
}


template <typename K, typename V>
void MultiMap<K,V>::Put(const K& key_, const V& value_)
{
	mapOfLists[key_].push_back(value_);  // If it's empty it will add a new one, if not it will push it back on the list
}


template <typename K, typename V>
void MultiMap<K,V>::Put(const K& key_, list<V>& listPassedByClient_)
{
	typename map<K, list<V> >::iterator iter;
	iter = mapOfLists.find(key_);

	if (iter == mapOfLists.end())	
	{
		mapOfLists[key_] = listPassedByClient_;	
	}
	else							
	{
		typename list<V>::iterator iter2; 
		for (iter2 = listPassedByClient_.begin(); iter2 != listPassedByClient_.end(); iter2++)
		{
			mapOfLists[key_].push_back(*iter2); 
		}
	}
}


template <typename K, typename V>
void MultiMap<K,V>::DisplayAllKeys() const
{
	typename map<K, list<V> >::const_iterator iter;
	for (iter = mapOfLists.begin(); iter != mapOfLists.end(); iter++)
	{
		cout << iter->first <<endl;
	}
}


template <typename K, typename V>
void MultiMap<K,V>::DisplayAllValues() const
{
	typename map<K, list<V> >::const_iterator iter;
	for (iter = mapOfLists.begin(); iter != mapOfLists.end(); iter++)
	{
		typename list<V>::const_iterator iter2;
		for (iter2 = iter->second.begin(); iter2 != iter->second.end(); iter2++)
		{
			cout << *iter2 <<endl;
		}
	}
}


template <typename K, typename V>
void MultiMap<K,V>::DisplayMap() const
{
	typename map<K, list<V> >::const_iterator iter;
	for (iter = mapOfLists.begin(); iter != mapOfLists.end(); iter++)
	{
		cout << iter->first <<endl;
		
		typename list<V>::const_iterator iter2;
		for (iter2 = iter->second.begin(); iter2 != iter->second.end(); iter2++)
		{
			cout << *iter2 <<endl;
		}	
	}
}


template <typename K, typename V>
void MultiMap<K,V>::DisplayAllValuesForAKey(const K& key_) const
{
	typename map<K, list<V> >::const_iterator iter;

	iter = mapOfLists.find(key_);

	if (iter == mapOfLists.end())
	{
		cout << "Key doesn't exist" <<endl;
	}
	else
	{
		cout << "Value for key: " << key_ <<endl;
		typename list<V>::const_iterator iter2;
		for (iter2 = iter->second.begin(); iter2 != iter->second.end(); iter2++)
		{
			cout << *iter2 <<endl;  
		}
	}
}


template <typename K, typename V>
void MultiMap<K,V>::RemoveAllValues(const K& key_)
{
	typename map<K, list<V> >::iterator iter;
	iter = mapOfLists.find(key_);

	if (iter == mapOfLists.end())
	{
		cout << "Key doesn't exist" <<endl;
	}
	else							
	{
		cout << "Removing all values for key: " << key_ <<endl;
		mapOfLists[key_].clear();
	}
}

template <typename K, typename V>
void MultiMap<K,V>::RemoveAValueForAKey(const K& key_, const V& value_)
{
	typename map<K, list<V> >::iterator iter;
	iter = mapOfLists.find(key_);
	

	if (iter == mapOfLists.end())
	{
		cout << "Key doesn't exist" <<endl;
	}
	else
	{
		bool valueFound = false;
		typename list<V>::iterator iter2;
		for (iter2 = iter->second.begin(); iter2 != iter->second.end(); iter2++)
		{
			if (*iter2 == value_)
			{
				valueFound = true;
				cout << "Removing value " << value_ << " for key: " << key_ <<endl;
				iter->second.erase(iter2); 
				break;
			}
		}
		if (!valueFound)
		{
			cout << "Value not found in key: " << key_ << endl;
		}
	}
}


template <typename K, typename V>
void MultiMap<K,V>::RemoveKeyAndValues(const K& key_)
{
	typename map<K, list<V> >::iterator iter;
	iter = mapOfLists.find(key_);

	if (iter == mapOfLists.end())
	{
		cout << "Key not found..." <<endl;
	}
	else						
	{
		mapOfLists.erase(key_);
	}
}


template <typename K, typename V>
pair<K,V> MultiMap<K,V>::MakePair(const K& key_, const V& value_)
{
	pair<K,V> p = make_pair(key_, value_);
	return p;
}


template <typename K, typename V>
void MultiMap<K,V>::Put(const pair<K,V>& pair_)
{
	mapOfLists[pair_.first].push_back(pair_.second);
}