#include <algorithm>
#include <sstream>
#include "error.h"
#include "sugar.h"

using namespace std;


const unordered_map<AST::Type,string> typeName={
	{AST::Type::number,"Number"},
	{AST::Type::string,"String"},
	{AST::Type::name,"Name"},
	{AST::Type::index,"Index"},
	{AST::Type::tuple,"Tuple"},
	{AST::Type::lambda,"Lambda"},
	{AST::Type::native,"Native"},
};


ostream& operator<<(ostream &os,AST::Type t){
	return os<<typeName.at(t);
}

template <typename T>
string stringify(const vector<T> &v,const string &join){
	stringstream ss;
	bool first=true;
	for(const T &t : v){
		if(first){
			first=false;
		} else {
			ss<<join;
		}
		ss<<t;
	}
	return ss.str();
}


Hook checkedHook(const Name &name,const vector<AST::Type> &types,const Hook &func){
	return [types,func,name](Environment &env,const AST &arg) -> AST {
		if(types.size()!=0&&find(types.begin(),types.end(),arg.type)==types.end()){
			throw TypeError("Function "+name+" got "+typeName.at(arg.type)+
			                " but accepts "+stringify(types));
		}
		return func(env,arg);
	};
}

Hook checkedHook(const Name &name,
                 const vector<AST::Type> &types1,const vector<AST::Type> &types2,
                 const Hook2 &func){
	return [types1,types2,func,name](Environment &env,const AST &arg1) -> AST {
		return AST::makeNative([types1,types2,func,name,&env,arg1](const AST &arg2) -> AST {
			if(types1.size()!=0&&find(types1.begin(),types1.end(),arg1.type)==types1.end()){
				throw TypeError("Function "+name+" got "+typeName.at(arg1.type)+
				                " as first argument but accepts "+stringify(types1));
			}
			if(types2.size()!=0&&find(types2.begin(),types2.end(),arg2.type)==types2.end()){
				throw TypeError("Function "+name+" got "+typeName.at(arg2.type)+
				                " as second argument but accepts "+stringify(types2));
			}
			return func(env,arg1,arg2);
		});
	};
}

Hook checkedHook(const Name &name,
                 const vector<AST::Type> &types1,const vector<AST::Type> &types2,const vector<AST::Type> &types3,
                 const Hook3 &func){
	return [types1,types2,types3,func,name](Environment &env,const AST &arg1) -> AST {
		return AST::makeNative([types1,types2,types3,func,name,&env,arg1](const AST &arg2) -> AST {
			return AST::makeNative([types1,types2,types3,func,name,&env,arg1,arg2](const AST &arg3) -> AST {
				if(types1.size()!=0&&find(types1.begin(),types1.end(),arg1.type)==types1.end()){
					throw TypeError("Function "+name+" got "+typeName.at(arg1.type)+
					                " as first argument but accepts "+stringify(types1));
				}
				if(types2.size()!=0&&find(types2.begin(),types2.end(),arg2.type)==types2.end()){
					throw TypeError("Function "+name+" got "+typeName.at(arg2.type)+
					                " as second argument but accepts "+stringify(types2));
				}
				if(types3.size()!=0&&find(types3.begin(),types3.end(),arg3.type)==types3.end()){
					throw TypeError("Function "+name+" got "+typeName.at(arg3.type)+
					                " as third argument but accepts "+stringify(types3));
				}
				return func(env,arg1,arg2,arg3);
			});
		});
	};
}