/++
	mvd stands for Multiple Virtual Dispatch. It lets you
	write functions that take any number of arguments of
	objects and match based on the dynamic type of each
	of them.

	---
	void foo(Object a, Object b) {} // 1
	void foo(MyClass b, Object b) {} // 2
	void foo(DerivedClass a, MyClass b) {} // 3

	Object a = new MyClass();
	Object b = new Object();

	mvd!foo(a, b); // will call overload #2
	---

	The return values must be compatible; [mvd] will return
	the least specialized static type of the return values
	(most likely the shared base class type of all return types,
	or `void` if there isn't one).

	All non-class/interface types should be compatible among overloads.
	Otherwise you are liable to get compile errors. (Or it might work,
	that's up to the compiler's discretion.)

	History:
		As of January 1, 2026, it will statically reject overloads that
		are impossible to match with the arguments, instead of only throwing
		at runtime. It may still throw at runtime if objects, in theory, could
		match but none actually do.
+/
module arsd.mvd;

import std.traits;

/// This exists just to make the documentation of [mvd] nicer looking.
template CommonReturnOfOverloads(alias fn) {
	alias overloads = __traits(getOverloads, __traits(parent, fn), __traits(identifier, fn));
	static if (overloads.length == 1) {
		alias CommonReturnOfOverloads = ReturnType!(overloads[0]);
	}
	else {
		alias CommonReturnOfOverloads = CommonType!(staticMap!(ReturnType, overloads));
	}
}

/// See details on the [arsd.mvd] page.
CommonReturnOfOverloads!fn mvd(alias fn, T...)(T args) {
	return mvdObj!fn(null, args);
}

private bool isSameOrBaseOf(LookingFor, LookingAt)() {
	static if(is(LookingFor == LookingAt))
		return true;
	else static if(is(LookingAt Bases == super)) {
		foreach(base; Bases)
			if(isSameOrBaseOf!(LookingFor, base))
				return true;
	}
	return false;
}

private bool canMaybeEverCastTo(PassedArg, CastingTo)() {
	// same type is fine, implicit cast to parent is fine
	if(isSameOrBaseOf!(PassedArg, CastingTo))
		return true;
	// or if a dynamic cast might succeed, that's also ok
	if(isSameOrBaseOf!(CastingTo, PassedArg))
		return false;

	// otherwise the cast operator won't work
	return false;
}

CommonReturnOfOverloads!fn mvdObj(alias fn, This, T...)(This this_, T args) {
	typeof(return) delegate() bestMatch;
	int bestScore;

	string argsStr() {
		string s;
		foreach(arg; args) {
			if(s.length)
				s ~= ", ";
			static if (is(typeof(arg) == class)) {
				if (arg is null) {
					s ~= "null " ~ typeof(arg).stringof;
				} else {
					s ~= typeid(arg).name;
				}
			} else {
				s ~= typeof(arg).stringof;
			}
		}
		return s;
	}

	ov: foreach(overload; __traits(getOverloads, __traits(parent, fn), __traits(identifier, fn))) {
		Parameters!overload pargs;
		int score = 0;
		foreach(idx, parg; pargs) {
			alias t = typeof(parg);

			static assert(canMaybeEverCastTo!(T[idx], t), "No common base class between types needed " ~ t.stringof ~ " and passed " ~ T[idx].stringof ~ "; no overload could possibly match.");

			static if(is(t == interface) || is(t == class)) {
				t value = cast(t) args[idx];
				// HACK: cast to Object* so we can set the value even if it's an immutable class
				*cast(Object*) &pargs[idx] = cast(Object) value;
				if(args[idx] !is null && pargs[idx] is null)
					continue ov; // failed cast, forget it
				else
					score += BaseClassesTuple!t.length + 1;
			} else
				pargs[idx] = args[idx];
		}
		if(score == bestScore)
			throw new Exception("ambiguous overload selection with args (" ~ argsStr ~ ")");
		if(score > bestScore) {
			bestMatch = () {
				static if(is(typeof(return) == void))
					__traits(child, this_, overload)(pargs);
				else
					return __traits(child, this_, overload)(pargs);
			};
			bestScore = score;
		}
	}

	if(bestMatch is null)
		throw new Exception("no match existed with args (" ~ argsStr ~ ")");

	return bestMatch();
}

///
unittest {

	class MyClass {}
	class DerivedClass : MyClass {}
	class OtherClass {}

	static struct Wrapper {
		static: // this is just a namespace cuz D doesn't allow overloading inside unittest
		int foo(Object a, Object b) { return 1; }
		int foo(MyClass a, Object b) { return 2; }
		int foo(DerivedClass a, MyClass b) { return 3; }

		int bar(MyClass a) { return 4; }
	}

	with(Wrapper) {
		assert(mvd!foo(new Object, new Object) == 1);
		assert(mvd!foo(new MyClass, new DerivedClass) == 2);
		assert(mvd!foo(new DerivedClass, new DerivedClass) == 3);
		assert(mvd!foo(new OtherClass, new OtherClass) == 1);
		assert(mvd!foo(new OtherClass, new MyClass) == 1);
		assert(mvd!foo(new DerivedClass, new DerivedClass) == 3);
		assert(mvd!foo(new OtherClass, new MyClass) == 1);

		//mvd!bar(new OtherClass);
	}
}

///
unittest {

	class MyClass {}
	class DerivedClass : MyClass {}
	class OtherClass {}

	class Wrapper {
		int x;

		int foo(Object a, Object b) { return x + 1; }
		int foo(MyClass a, Object b) { return x + 2; }
		int foo(DerivedClass a, MyClass b) { return x + 3; }

		int bar(MyClass a) { return x + 4; }
	}

	Wrapper wrapper = new Wrapper;
	wrapper.x = 20;
	assert(wrapper.mvdObj!(wrapper.foo)(new Object, new Object) == 21);
	assert(wrapper.mvdObj!(wrapper.foo)(new MyClass, new DerivedClass) == 22);
	assert(wrapper.mvdObj!(wrapper.foo)(new DerivedClass, new DerivedClass) == 23);
	assert(wrapper.mvdObj!(wrapper.foo)(new OtherClass, new OtherClass) == 21);
	assert(wrapper.mvdObj!(wrapper.foo)(new OtherClass, new MyClass) == 21);
	assert(wrapper.mvdObj!(wrapper.foo)(new DerivedClass, new DerivedClass) == 23);
	assert(wrapper.mvdObj!(wrapper.foo)(new OtherClass, new MyClass) == 21);

	//mvd!bar(new OtherClass);
}

///
unittest {
	class MyClass {}

	static bool success = false;

	static struct Wrapper {
		static:
		void foo(MyClass a) { success = true; }
	}

	with(Wrapper) {
		mvd!foo(new MyClass);
		assert(success);
	}
}

///
unittest {
	immutable class Foo {}

	immutable class Bar : Foo {
		int x;

		this(int x) {
			this.x = x;
		}
	}

	immutable class Baz : Foo {
		int x, y;

		this(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	static struct Wrapper {
		static:

		int foo(Bar b) { return b.x; }
		int foo(Baz b) { return b.x + b.y; }
	}

	with(Wrapper) {
		Foo x = new Bar(3);
		Foo y = new Baz(5, 7);
		assert(mvd!foo(x) == 3);
		assert(mvd!foo(y) == 12);
	}
}