/*
 * AlgorithmRegistry.hpp
 *
 *  Created on: 11. 7. 2017
 *	  Author: Jan Travnicek
 */

#ifndef _ALGORITHM_REGISTRY_HPP_
#define _ALGORITHM_REGISTRY_HPP_

#include <functional>
#include <memory>
#include <vector>
#include <string>
#include <foreach>

#include <exception/CommonException.h>
#include <abstraction/OperationAbstraction.hpp>
#include <abstraction/CastRegistry.hpp>

#include <abstraction/common/ParamQualifiers.hpp>

namespace abstraction {

class AlgorithmRegistry {
	class Entry {
		bool m_downcast;
		bool m_normalize;

	public:
		Entry ( bool downcast, bool normalize ) : m_downcast ( downcast ), m_normalize ( normalize ) {
		}

		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;

		bool getDowncast ( ) const {
			return m_downcast;
		}

		bool getNormalize ( ) const {
			return m_normalize;
		}
	};

	template < class Return, class ... Params >
	class EntryImpl : public Entry {
		std::function < Return ( Params ... ) > m_callback;

	public:
		EntryImpl ( std::function < Return ( Params ... ) > callback, bool downcast, bool normalize ) : Entry ( downcast, normalize ), m_callback ( callback ) {
		}

		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
	};

	static ext::map < std::string, ext::vector < std::pair < ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > > > & getEntries ( ) {
		static ext::map < std::string, ext::vector < std::pair < ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > > > algorithmGroups;
		return algorithmGroups;
	};

	enum class MatchType {
		EXACT,
		CAST,
		INCOMPATIBLE
	};
public:
	template < class Algo, class ReturnType, class ... ParamTypes >
	static void registerAlgorithm ( ReturnType ( * callback ) ( ParamTypes ... ), bool downcast, bool normalize ) {
		std::string algorithm = ext::to_string < Algo > ( );

		ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > > params;
		( void ) std::initializer_list < int > { ( params.push_back ( std::make_pair ( ext::to_string < typename std::decay < ParamTypes >::type > ( ), abstraction::ParamQualifiers::paramQualifiers < ParamTypes > ( ) ) ), 0 ) ... };

		auto & group = getEntries ( ) [ algorithm ];
		for ( const std::pair < ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > & entry : group )
			if ( entry.first == params )
				throw exception::CommonException ( "Callback for " + algorithm + " already registered." );

		auto entryValue = std::make_pair ( params, std::shared_ptr < Entry > ( new EntryImpl < ReturnType, ParamTypes ... > ( callback, downcast, normalize ) ) );
		group.push_back ( std::move ( entryValue ) );
	}

	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & name, const ext::vector < std::string > & paramTypes, bool & downcast, bool & normalize ) {
		auto group = getEntries ( ).find ( name );
		if ( group == getEntries ( ).end ( ) )
			throw exception::CommonException ( "Entry " + name + " not available" );

		auto incompatibleLambda = [ ] ( const ext::tuple < MatchType, std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > & compatibility ) {
			return std::get < 0 > ( compatibility ) == MatchType::INCOMPATIBLE;
		};

		auto castLambda = [ ] ( const ext::tuple < MatchType, std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > & compatibility ) {
			return std::get < 0 > ( compatibility ) == MatchType::CAST;
		};

		auto exactLambda = [ ] ( const ext::tuple < MatchType, std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > & compatibility ) {
			return std::get < 0 > ( compatibility ) == MatchType::EXACT;
		};

		// determine how one can actually map what we have ( paramTypes ) as params to what is available as overloads ( group->second )
		std::vector < std::pair < ext::vector < ext::tuple < MatchType, std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > > compatibilityData;
		for ( const std::pair < ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > & entry : group->second ) {
			if ( entry.first.size ( ) != paramTypes.size ( ) )
				continue;

			ext::vector < ext::tuple < MatchType, std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > > compatibilityVector;
			for ( unsigned i = 0; i < paramTypes.size ( ); ++ i ) {
				MatchType matchType;
				if ( entry.first [ i ].first == paramTypes [ i ] ) {
					matchType = MatchType::EXACT;
				} else if ( abstraction::CastRegistry::castAvailable ( entry.first [ i ].first, paramTypes [ i ] ) ) {
					matchType = MatchType::CAST;
				} else {
					matchType = MatchType::INCOMPATIBLE;
				}

				compatibilityVector.push_back ( ext::make_tuple ( matchType, entry.first [ i ].first, entry.first [ i ].second ) );
			}

			// clear incompatibilities are fitered out
			if ( std::none_of ( compatibilityVector.begin ( ), compatibilityVector.end ( ), incompatibleLambda ) )
				compatibilityData.push_back ( std::make_pair ( std::move ( compatibilityVector ), entry.second ) );
		}

		// remaining compatible overloads are examined per parameter and the best option is remembered as overload index that achieved it
		ext::vector < ext::set < unsigned > > winnerList;
		for ( unsigned i = 0; i < paramTypes.size ( ); ++ i ) {
			ext::set < unsigned > best;

			unsigned overload = 0;
			for ( const std::pair < ext::vector < ext::tuple < MatchType, std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > & data : compatibilityData ) {
				if ( exactLambda ( data.first [ i ] ) )
					best.insert ( overload );

				++ overload;
			}

			if ( best.size ( ) > 0 ) {
				winnerList.push_back ( std::move ( best ) );
				continue;
			}

			overload = 0;
			for ( const std::pair < ext::vector < ext::tuple < MatchType, std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > & data : compatibilityData ) {
				if ( castLambda ( data.first [ i ] ) )
					best.insert ( overload );

				++ overload;
			}

			winnerList.push_back ( std::move ( best ) );
		}

		// intersection of everything together finds indexes which are better or of the same quality for all params over all overloads
		ext::set < unsigned > winner { ext::sequence < unsigned > ( 0 ).begin ( ), ext::sequence < unsigned > ( compatibilityData.size ( ) ).end ( ) };
		for ( const std::set < unsigned > & best : winnerList ) {
			ext::set < unsigned > filtered;
			std::set_intersection ( winner.begin ( ), winner.end ( ), best.begin ( ), best.end ( ), std::inserter ( filtered, filtered.end ( ) ) );
			winner = std::move ( filtered );
		}

		// if there is a sinle winner, return it
		std::shared_ptr < Entry > best;
		if ( winner.size ( ) == 1 ) {
			best = compatibilityData [ * winner.begin ( ) ].second;
		} else if ( winner.size ( ) > 1 ) {
			std::stringstream ss;
			ss << paramTypes;

			throw exception::CommonException ( "Entry overload " + ss.str ( ) + " ambiguous." );
		} else {
			std::stringstream ss;
			ss << paramTypes;

			throw exception::CommonException ( "Entry overload " + ss.str ( ) + " not available." );
		}

		downcast = best->getDowncast ( );
		normalize = best->getNormalize ( );

		return best->getAbstraction ( );
	}

	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & name, const ext::vector < std::string > & paramTypes ) {
		bool downcast;
		bool normalize;
		return getAbstraction ( name, paramTypes, downcast, normalize );
	}

	static void listGroup ( const std::string & group ) {
		for ( const std::pair < const std::string, ext::vector < std::pair < ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > > > & entry : getEntries ( ) ) {
			if ( entry.first.find ( group ) == 0 ) //found at the begining
				std::cout << entry.first << std::endl;
		}
	}

	static void listOverloads ( const std::string & algorithm ) {
		auto group = getEntries ( ).find ( algorithm );
		if ( group == getEntries ( ).end ( ) )
			throw exception::CommonException ( "Entry " + algorithm + " not available" );

		for ( const std::pair < ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > & overloads : group->second ) {
			for ( const std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > & param : overloads.first ) {
				if ( param.second.count ( abstraction::ParamQualifiers::ParamQualifier::CONST ) )
					std::cout << "const ";

				std::cout << param.first;

				if ( param.second.count ( abstraction::ParamQualifiers::ParamQualifier::LREF ) )
					std::cout << " &";

				if ( param.second.count ( abstraction::ParamQualifiers::ParamQualifier::RREF ) )
					std::cout << " &";

				std::cout << ", ";
			}
			std::cout << std::endl;
		}
	}

	static void list ( ) {
		for ( const std::pair < const std::string, ext::vector < std::pair < ext::vector < std::pair < std::string, ext::set < abstraction::ParamQualifiers::ParamQualifier > > >, std::shared_ptr < Entry > > > > & entry : getEntries ( ) ) {
			std::cout << entry.first << std::endl;
		}
	}
};

} /* namespace abstraction */

#include <abstraction/AlgorithmAbstraction.hpp>

namespace abstraction {

template < class Return, class ... Params >
std::shared_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::EntryImpl < Return, Params ... >::getAbstraction ( ) const {
	return std::make_shared < abstraction::AlgorithmAbstraction < Return, Params ... > > ( m_callback );
}

} /* namespace abstraction */

#endif /* _ALGORITHM_REGISTRY_HPP_ */