/+
+            Copyright 2022 – 2024 Aya Partridge
+ Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+           http://www.boost.org/LICENSE_1_0.txt)
+/
module bindbc.common.codegen;

import bindbc.common.versions;

///TODO: split into codegen.fn, codegen.enum_, and codegen.util

/**
Data for function bindings.

Only the locations of the first 3 fields (`retn`, `iden`, and `params`) should be
relied on. Every other field should always be written/read by using its identifier.
Example:
```d
FnBbind one = {q{void}, q{someCppFn}, q{int si, uint ui}, ext: `C++`}; //OK
FnBbind two = {q{void}, q{someCppFn}, q{uint ui, int si}, `C++`}; //`ext` was not specified by identifier; might break in the future!
```

Never place whitespace around strings provided to FnBind, as it may cause incorrect binding generation.
*/
struct FnBind{
	/**
	Return type.
	Passing `const char*` instead of '`const(char)*` to a member function will
	erroneously cause the function to be `const`. You should use `attrib` for this instead.
	Must be void for constructors and destructors.
	Must be non-null, except where it is ignored.
	*/
	string retn;
	
	/**
	The identifier of the function in the library you are binding.
	Use `this` when binding a constructor, `~this` when binding a destructor.
	Must be non-null.
	*/
	string iden;
	
	/**
	Comma-separated named function parameters.
	Constructors can have no parameters. Constructors with all-default parameters will not currently work!
	
	Default: no parameters
	*/
	string params = "";
	
	/**
	Specifies which `extern` linkage to use.
	| Support status    | Input           | Generated code          |
	|-------------------|-----------------|-------------------------|
	| Fully supported   | `C`             | `extern(C)`             |
	| Mostly supported  | `C++`           | `extern(C++)`           |
	| Mostly supported  | `C++. "name"`   | `extern(C++, "name")`   |
	| Mostly supported  | `C++. "a", "b"` | `extern(C++, "a", "b")` |
	| Not yet supported | `Objective-C`   | `extern(Objective-C)`   |
	
	Default: C
	*/
	string ext = `C`;
	
	/**
	Whether or not a member function is static. Should not be `true` for non-member functions.
	*/
	bool isStatic = false;
	
	/**
	Optional: Function attributes. `pure` will be removed from dynamic bindings.
	*/
	string attr;
	
	/**
	Optional: If populated, `iden` will be private, and a public alias with the name `pubIden` will be created.
	*/
	string pubIden;
	
	/**
	Optional: Member function attributes.
	*/
	string memAttr;
	
	/**
	Optional:
	Anything to be placed immediately before the public version of the function, like `deprecated`, etc.
	*/
	string pfix;
	
	/**
	Optional: A list of identifiers to be aliases of the function.
	*/
	string[] aliases;
}

/**
Returns: A mixin string with code for creating function bindings.

Params:
	staticBinding = Whether the functions generate static bindings, or otherwise dynamic ones.
	version = The version of BindBC-Common that your code is written for.
*/
enum makeFnBindFns = (bool staticBinding, Version version_=Version(0,1,1)) nothrow pure @safe{
	if(version_ >= Version(0,1,1) && version_ <= bindBCCommonVersion){
		return
"alias joinFnBinds = bindbc.common.codegen.joinFnBinds!" ~ (staticBinding ? "true" : "false") ~ ";
alias FnBind = bindbc.common.codegen.FnBind;";
	}else assert(0, "Invalid version supplied.");
};

/*
Regex sub:
^[ \t]*([A-Za-z0-9_()*\[\]]+) (\w+) ?\(([A-Za-z0-9_()*, .=\[\]]*)\);
with:
\t\t{q{$1}, q{$2}, q{$3}},
*/
enum joinFnBinds(bool staticBinding) = (FnBind[] fns, string membersWithFns=null) nothrow pure @safe{
	string ret;
	
	static if(staticBinding){
		ret ~= "nothrow @nogc{\n";
		foreach(fn; fns){
			string pfix = (fn.pfix.length ? fn.pfix~" " : "") ~ (fn.pubIden.length ? "package " : "") ~ "extern("~fn.ext~") ";
			if(fn.isStatic){
				pfix ~= "static ";
			}
			string attr = (fn.attr.length ? " "~fn.attr : "");
			string memAttr = (fn.memAttr.length ? " "~fn.memAttr : "");
			
			if(fn.iden == "this"){
				if(fn.params.length){
					ret ~= "\t" ~ pfix ~ "this("~fn.params~")" ~ memAttr ~ attr ~ ";\n";
				}else{
					ret ~= "\t\timport bindbc.common.codegen: mangleofCppDefaultCtor;\n";
					ret ~= "\t" ~ pfix ~ "pragma(mangle, [__traits(getCppNamespaces, typeof(this)), __traits(identifier, typeof(this))].mangleofCppDefaultCtor()) this(int _)" ~ (fn.memAttr.length ? " "~fn.memAttr : "") ~ ";\n";
				}
			}else{
				ret ~= "\t" ~ pfix ~ fn.retn ~ " " ~ fn.iden ~ "("~fn.params~")" ~ memAttr ~ attr ~ ";\n";
			}
			
			if(fn.pubIden.length){
				ret ~= "\talias " ~ fn.pubIden ~ " = " ~ fn.iden ~ ";\n";
			}
			foreach(alias_; fn.aliases){
				ret ~= "\talias " ~ alias_ ~ " = " ~ fn.iden ~ ";\n";
			}
		}
		ret ~= "}";
	}else{
		string types = "private nothrow @nogc{\n";
		string ptrs = "__gshared nothrow @nogc{\n";
		string dyn =
`import bindbc.loader: SharedLib, bindSymbol;
static void bindModuleSymbols(SharedLib lib) nothrow @nogc{
	alias here = ` ~ makeOuterScope() ~ `;`;
		
		//Helps us see if functions have overloads.
		uint[string] usedIdens;
		foreach(fn; fns){
			if(fn.ext != "C"){ //Could this function have overloads?
				if(auto num = fn.iden in usedIdens){
					(*num) = 1;
				}else{
					usedIdens[fn.iden] = 0;
				}
			}
		}
		
		foreach(fn; fns){
			//Are there overloads of this function?
			uint overload = 0;
			if(fn.ext != "C"){
				if(auto num = fn.iden in usedIdens){
					overload = *num;
					(*num)++;
				}
			}
			
			string ext = "extern("~fn.ext~") ";
			string pfix = (fn.pfix.length ? fn.pfix~" " : "") ~ (fn.pubIden.length ? "package " : "") ~ ext;
			if(fn.isStatic){
				pfix ~= "static ";
			}
			
			string memAttr = (fn.memAttr.length ? " "~fn.memAttr : "");
			string attr = (fn.attr.length ? " "~fn.attr : "");
			//remove `pure` for function wrapper
			string wrapAttr = attr;
			if(fn.attr.length >= 4){
				foreach(ind; 0..fn.attr.length-3){
					if(fn.attr[ind..ind+4] == q{pure}){
						wrapAttr = " "~fn.attr[0..ind] ~ fn.attr[ind+4..$];
						break;
					}
				}
			}
			
			//Is this a variadic function?
			bool variadic = fn.params.length > 3 && fn.params[$-3..$] == "...";
			//Is this a member function?
			bool memberFn = membersWithFns is null && fn.ext != "C";
			
			//`iden` is either the identifier for this function, or an internal name if the function identifier is special (e.g. `this`)
			string iden = (){
				switch(fn.iden){
					case "this": return "__ctor";
					case "~this": return "__dtor";
					default: return fn.iden;
				}
			}();
			//Whether a special identifier (`__ctor`/`__dtor`) is in-use.
			//bool specialIden = iden != fn.iden;
			
			//The function pointer's parameters, and how to call it from the public function.
			string ptrParams = fn.params;
			string ptrCall = "__traits(parameters)";
			if(memberFn && !fn.isStatic){
				if(fn.params.length){
					ptrParams = "ref inout(typeof(this)) this_, " ~ ptrParams;
					ptrCall = "this, " ~ ptrCall;
				}else{
					ptrParams = "ref inout(typeof(this)) this_";
					ptrCall = "this";
				}
				ptrParams = (fn.memAttr.length ? fn.memAttr~" " : "") ~ ptrParams;
			}
			
			string ptrIden = "_"~iden;
			string typeIden = "_p"~iden;
			string typeExt = "extern("~((fn.ext.length > 3 && fn.ext[0..3] == "C++") ? "C++" : fn.ext)~") ";
			
			if(overload){
				string overloadStr = overload.toStrCT();
				ptrIden ~= overloadStr;
				typeIden ~= overloadStr;
				//if(!specialIden){
					//iden ~= "_"~overloadStr;
					//pfix = "package " ~ pfix;
				//}
			}else if(variadic){
				types ~= "\talias " ~ typeIden ~ " = " ~ typeExt ~ fn.retn ~ " function(" ~ ptrParams ~ ")" ~ attr ~ ";\n";
				ptrs ~= "\t" ~ typeIden ~ " " ~ iden ~ ";\n";
			}
			
			ptrCall = ptrIden ~ "("~ptrCall~");";
			
			if(overload){
				dyn ~= `
	{
		alias FnCmp = void(`~fn.params~`);
		static if(is(FnCmp ArgsCmp == function)){
			static foreach(Fn; __traits(getOverloads, here, "` ~ iden ~ `")){{
				static if(is(typeof(Fn) Args == function)){
					static if(is(Args == ArgsCmp)){
						lib.bindSymbol(cast(void**)&` ~ ptrIden ~ `, Fn.mangleof);
					}
				}else static assert(0);
			}}
		}else static assert(0);
	}`;
			}else if(variadic){
				if((fn.ext.length >= 3 && fn.ext[0..3] == "C++") || fn.ext == "Objective-C"){
					//Variadic functions always act like they're overloaded and return no mangled parameters. :(
					dyn ~= `
	{
		alias FnCmp = void(`~fn.params~`);
		static if(is(FnCmp ArgsCmp == function)){
			static foreach(Fn; __traits(getOverloads, here, "` ~ iden ~ `")){{
				static if(is(typeof(Fn) Args == function)){
					static if(is(Args == ArgsCmp)){
						lib.bindSymbol(cast(void**)&` ~ iden ~ `, Fn.mangleof);
					}
				}else static assert(0);
			}}
		}else static assert(0);
	}`;
				}else{
					dyn ~= `
	lib.bindSymbol(cast(void**)&` ~ iden ~ `, "` ~ iden ~ `");`;
				}
				continue;
				
			}else{
				dyn ~= `
	lib.bindSymbol(cast(void**)&` ~ ptrIden ~ `, here.` ~ iden ~ `.mangleof);`;
				
			}
			
			//We separate the type so that the compiler doesn't extern our function pointer; only makes the function pointer type extern.
			types ~= "\talias " ~ typeIden ~ " = " ~ typeExt ~ fn.retn ~ " function(" ~ ptrParams ~ ")" ~ attr ~ ";\n";
			//Private function pointer declaration.
			ptrs ~= "\tpackage " ~ typeIden ~ " " ~ ptrIden ~ ";\n";
			
			//Function wrapper delcaration.
			string fnParams = fn.params;
			if(variadic && overload){
				fnParams = "T...)("~fnParams[0..$-3]~"T _variadics";
			}
			if(fn.iden == "this"){ //Constructor.
				if(fn.params.length){
					//TODO: Check if the parameters are all defaults here :(
					ptrs ~= "\t" ~ pfix ~ "this("~fnParams~")" ~ memAttr ~ wrapAttr ~ "{ " ~ ptrCall ~ " }\n";
				}else if(fn.ext.length >= 3 && fn.ext[0..3] == "C++"){ //Default constructor; must have no parameters.
					ptrs ~= "\timport bindbc.common.codegen: mangleofCppDefaultCtor;\n";
					ptrs ~= "\t" ~ pfix ~ "pragma(mangle, [__traits(getCppNamespaces, typeof(this)), __traits(identifier, typeof(this))].mangleofCppDefaultCtor()) this(int _)" ~ memAttr ~ attr ~ "{ " ~ ptrCall ~ " }\n";
				}else assert(0, "Default constructor mangling for extern("~fn.ext~") is unknown.");
			}else if(fn.iden == "~this"){ //Destructor.
				ptrs ~= "\t" ~ pfix ~ "~this("~fnParams~")" ~ memAttr ~ wrapAttr ~ "{ " ~ ptrCall ~ " }\n";
			}else{
				if(fn.retn != "void"){
					ptrCall = "return " ~ ptrCall;
				}
				ptrs ~= "\t" ~ pfix ~ fn.retn ~ " " ~ fn.iden ~ "("~fnParams~")" ~ memAttr ~ wrapAttr ~ "{ " ~ ptrCall ~ " }\n";
			}
			
			if(fn.pubIden.length){
				ptrs ~= "\talias " ~ fn.pubIden ~ " = " ~ iden ~ ";\n";
			}
			foreach(aliasIden; fn.aliases){
				ptrs ~= "\talias " ~ aliasIden ~ " = " ~ iden ~ ";"; 
			}
		}
		
		if(membersWithFns.length){
			//This method is easier to rewrite to use __traits(allMembers) later
			dyn ~= `
	alias AliasSeq(T...) = T;
	static foreach(item; AliasSeq!(` ~ membersWithFns ~ `)){ 
		static assert((is(item == struct) || is(item == class)) && (__traits(getLinkage, item) == "C++" || __traits(getLinkage, item) == "Objective-C") && __traits(hasMember, item, "bindModuleSymbols"));
		mixin(__traits(fullyQualifiedName, item),".bindModuleSymbols(lib);");
	}`;
		}
		
		ret = types ~ "}\n" ~ ptrs ~ "}\n\n" ~ dyn ~ "\n}";
	}
	return ret;
};

/*//TODO: some time after __traits(allMembers) is fixed, remove "membersWithFns" and check over each type it returns automatically! :)
enum joinFnBinds = (string[][] list, string membersWithFns="") nothrow pure @safe{;
	static if(staticBinding){
		string joined = "{";
	}else{ 
	string joined = "\n@nogc nothrow __gshared{";;
	}
	foreach(item; list){
		joined ~= item[0];
	}
	joined ~= "\n}";;
	
	static if(!staticBinding){
	joined ~= "\n\nimport bindbc.loader: SharedLib, bindSymbol;\nstatic void bindModuleSymbols(SharedLib lib) @nogc nothrow{";
	foreach(item; list){
		if(item[2] == "this") item[2] = "__ctor";
		if(item[3].length > 0){
			joined ~= "
	static if("~((item[3].length > 3 && item[3][$-3..$] == "...") ? "true" : "false")~" || __traits(getOverloads, "~outerScope~", \""~item[2]~"\").length > 0){
		static foreach(Fn; __traits(getOverloads, "~outerScope~", \""~item[2]~"\")){
			{
				void Fn2("~item[3]~"){}
				static if(is(typeof(Fn) Args1 == __parameters) && is(typeof(Fn2) Args2 == __parameters)){
					static if(is(Args1 == Args2)){
						lib.bindSymbol(cast(void**)&"~item[1]~", Fn.mangleof);
					}
				}else static assert(0);
			}
		}
	}else{
		lib.bindSymbol(cast(void**)&"~item[1]~", "~outerScope~"."~item[2]~".mangleof);
	}";
		}else{
			joined ~= "\n\tlib.bindSymbol(cast(void**)&"~item[1]~", "~outerScope~"."~item[2]~".mangleof);";
		}
	}
	if(membersWithFns.length > 0){
		joined ~= q{
		alias AliasSeq(T...) = T;
		static foreach(member; AliasSeq!(}~membersWithFns~q{)){
			static if( (is(member == struct) || is(member == class) || is(member == struct)) && (__traits(getLinkage, member) == "C++" || __traits(getLinkage, member) == "Objective-C") ){
				mixin(member,".bindModuleSymbols(lib);");
			}
		}
		};
	}
	joined ~= "\n}";;
	}
	
	return joined;
};*/

///For internal use only.
enum makeIsMember = () nothrow pure @safe{
	return "__traits(compiles, typeof(this))";
};
unittest{
	static assert(mixin(makeIsMember()) == false);
	struct XXX{
		static assert(mixin(makeIsMember()) == true);
	}
}

///For internal use only.
package enum makeOuterScope = () nothrow pure @safe{
	return
"mixin((string mod=__MODULE__){
	static if(__traits(compiles, typeof(this))) return __traits(identifier, typeof(this));
	else return mod;
}())";
};
unittest{
	static assert(__traits(isSame, mixin(makeOuterScope()), bindbc.common.codegen));
	struct XXX{
		static assert(is(mixin(makeOuterScope()) == XXX));
	}
}

///For internal use only.
enum mangleofCppDefaultCtor = (string[] syms) nothrow pure @safe{
	static if((){
		version(CppRuntime_Clang)    return true;
		else version(CppRuntime_Gcc) return true;
		else version(Android)        return true;
		else version(WebAssembly)    return true;
		else return false;
	}()){
		string ret = "_ZN";
		foreach(sym; syms){
			ret ~= toStrCT(sym.length) ~ sym;
		}
		return  ret ~ "C1Ev";
	}else static if((){
		version(CppRuntime_Microsoft)        return true;
		else version(CppRuntime_DigitalMars) return true;
		else return false;
	}()){
		string ret = "??0";
		foreach(sym; syms){
			ret ~= sym ~ "@";
		}
		version(D_X32){
			return ret ~ "@QAE@XZ";
		}else{
			return ret ~ "@QEAA@XZ";
		}
	}else static assert(0, "Unknown runtime, not sure what mangling to use. Please check how your compiler mangles C++ struct constructors and add a case for it to `bindbc.common.codegen.mangleofCppDefaultCtor`.");
};
unittest{
	static if((){
		version(CppRuntime_Clang)    return true;
		else version(CppRuntime_Gcc) return true;
		else return false;
	}()){
		static assert(["ImGuiListClipper"].mangleofCppDefaultCtor() == "_ZN16ImGuiListClipperC1Ev");
		static assert(["bgfx", "Init"].mangleofCppDefaultCtor() == "_ZN4bgfx4InitC1Ev");
	}else static if((){
		version(CppRuntime_Microsoft)        return true;
		else version(CppRuntime_DigitalMars) return true;
		else return false;
	}()){
		version(D_X32){
			static assert(["ImGuiListClipper"].mangleofCppDefaultCtor() == "??0ImGuiListClipper@@QAE@XZ");
			static assert(["bgfx", "Init"].mangleofCppDefaultCtor() == "??0Init@bgfx@@QAE@XZ");
		}else{
			static assert(["ImGuiListClipper"].mangleofCppDefaultCtor() == "??0ImGuiListClipper@@QEAA@XZ");
			static assert(["bgfx", "Init"].mangleofCppDefaultCtor() == "??0Init@bgfx@@QEAA@XZ");
		}
	}else static assert(0);
}

///For internal use only.
size_t badHash(string s) nothrow pure @safe{
	size_t ret = 0;
	for(size_t i = 0; i < s.length; i += 2){
		ret += s[i]; //yes, this is a *really* bad hashing algorithm!
	}
	return ret * s.length;
}
unittest{
	static assert(badHash("const(void)* ptr") != badHash("char alpha"));
	static assert(badHash("const(void)* ptr") != badHash("const(void)* chr"));
	static assert(badHash("ubyte id, size_t ind, char* buf") != badHash("wchar utf16, char* utf8"));
	static assert(badHash("dchar utf16, char* utf8, bool er") != badHash("wchar utf16, char* utf8, bool er"));
}

///For internal use only.
enum toStrCT = (size_t val) nothrow pure @safe{
	enum base = 10;
	
	if(!val) return "0";

	string ret;
	while(val > 0){
		ret = cast(char)('0' + (val % base)) ~ ret;
		val /= base;
	}
	return ret;
};
unittest{
	static assert(0.toStrCT() == "0");
	static assert(4.toStrCT() == "4");
	static assert(120.toStrCT() == "120");
	static assert(589_000.toStrCT() == "589000");
	static assert(9_396_460_865_079_328.toStrCT() == "9396460865079328");
	static assert(1_046_259_925_731_862_221.toStrCT() == "1046259925731862221");
}

/**
Data for a member of an enum binding.

Only the locations of the first 2 fields (`iden`, and `val`) should be
relied on. Every other field should always be written/read by using its identifier.
*/
struct EnumMember{
	EnumIden iden;
	
	/**
	Optional: The value of both versions of the enum member.
	*/
	string val;
	
	/**
	Optional: A list of identifiers to be aliases of the member.
	*/
	EnumIden[] aliases;
}

struct EnumIden{
	/**
	The identifier for a D-style version of this enum member.
	For example: `mouseButtonDown` for an enum named `SDLEvent`
	Must be non-null, except in `aliases`.
	*/
	string d;
	
	/**
	The identifier for a C-style version of this enum member.
	For example: `SDL_EVENT_MOUSE_BUTTON_DOWN`
	Must be non-null, except in `aliases`.
	*/
	string c;
}

/**
Returns: A mixin string with code for creating enum bindings.

Params:
	cStyle = Whether or not to generate C-style 
	version = The version of BindBC-Common that your code is written for.
*/
enum makeEnumBindFns = (bool cStyle, bool dStyle) nothrow pure @safe{
	return
"alias makeEnumBind = bindbc.common.codegen.makeEnumBind!(" ~
	(cStyle ? "true" : "false") ~ ", " ~
	(dStyle ? "true" : "false") ~
");
alias EnumMember = bindbc.common.codegen.EnumMember;
alias EnumIden = bindbc.common.codegen.EnumIden;";
};

/**
Create an enum with optional D-style and C-style versions.

Only the first two parameters (`dIden`, and `baseType`) should be
supplied sequentially. The rest should be called using named parameters.

Params:
	dIden = An identifer for the D-style version of this enum. (i.e. `enum TypeIdentifier{`)
	baseType = (Optional) A base type for both versions of the enum. (i.e. `enum MyEnum: BaseType{`)
	aliases = (Optional) Aliases to the D-style version of this enum.
	members = Each member of the enum.
*/
enum makeEnumBind(bool cStyle, bool dStyle) = (string dIden, string baseType=null, string[] aliases=null, EnumMember[] members, string fullModule=__MODULE__) nothrow pure @safe{
	string dRet;
	static if(!dStyle)
		dRet ~= "package ";
	dRet ~= "enum " ~ dIden;
	if(baseType)
		dRet ~= ": " ~ baseType;
	dRet ~= "{\n";
	
	string cRet;
	static if(cStyle){
		cRet ~= "enum: " ~ fullModule~"."~dIden ~ "{\n";
	}
	
	foreach(member; members){
		dRet ~= "\t" ~ member.iden.d;
		if(member.val)
			dRet ~= " = " ~ member.val;
		dRet ~= ",\n";
		
		static if(cStyle){
			if(member.iden.c){
				cRet ~= "\t" ~ member.iden.c ~ " = " ~ fullModule~"."~dIden~"."~member.iden.d;
				cRet ~= ",\n";
			}
		}
		
		foreach(aliasIden; member.aliases){
			if(aliasIden.d)
				dRet ~= "\t" ~ aliasIden.d ~ " = " ~ member.iden.d ~ ",\n";
			
			static if(cStyle){
				if(aliasIden.c)
					cRet ~= "\t" ~ aliasIden.c ~ " = " ~ member.iden.c ~ ",\n";
			}
		}
	}
	
	dRet ~= "}\n";
	foreach(dAlias; aliases){
		static if(!dStyle)
			dRet ~= "package ";
		dRet ~= "alias "~dAlias~" = "~fullModule~"."~dIden~";\n";
	}
	
	return dRet ~ cRet ~ "}";
};

/**
A workaround that BindBC used to use for C-style enums.
It is included here mostly for preservation.
*/
enum makeExpandedEnum(Enum) = () nothrow pure @safe{
	string ret;
	foreach(member; __traits(allMembers, Enum)){
		ret ~= "\nenum "~member~" = "~Enum.stringof~"."~member~";";
	}
	return ret;
}();