#include <iostream>

// Allgemein


template <typename Event, int Instance, auto ImplFun_>
class Callback {
	public:
		static constexpr auto implFun = ImplFun_;
};

template <typename... Decls>
class Callbacks : private Decls... {
	private:
		template <typename Event, int Instance, auto ImplFun>
		static Callback<Event, Instance, ImplFun> findImpl (Callback<Event, Instance, ImplFun>*);

		template <typename Event, int Instance>
		using BaseDecl = decltype (findImpl<Event, Instance> (static_cast<Callbacks*> (nullptr)));
	public:
		template <typename Event, int Instance>
		static constexpr auto implFun = BaseDecl<Event, Instance>::implFun;
};

// Button-Spezifisch

class ButtonObserver {
	public:
		inline constexpr ButtonObserver () : next (nullptr) {}
		friend class Button;

		virtual bool onClick (int x) = 0;
		virtual int onDoubleClick (short x, long y) = 0;
	private:
		ButtonObserver* next;
};

class Button {
	public:
		// Dummy marker Types
		struct OnClick;
		struct OnDoubleClick;

		constexpr Button () : firstObserver (nullptr) {}

		void addObserver (ButtonObserver* obs) {
			obs->next = firstObserver;
			firstObserver = obs;
		}
		bool onClick (int x) {
			// Beispiel: Iteriere solange die Observer bis einer "true" zurück gibt
			for (ButtonObserver* o = firstObserver; o; o = o->next) {
				if (o->onClick (x))
					return true;
			}
			return false;
		}
		int onDoubleClick (short x, long y) {
			// Beispiel: Summiere die Rückgabewerte der Observer
			int sum = 0;
			for (ButtonObserver* o = firstObserver; o; o = o->next) {
				sum += o->onDoubleClick (x, y);
			}
			return sum;

		}
	private:
		ButtonObserver* firstObserver;
};

template <int Instance, typename Main>
class ButtonObserverRelay : public ButtonObserver {
	public:
		virtual bool onClick (int x) override {
			return (static_cast<Main&> (*this).*(Main::DeclareCallbacks::template implFun<Button::OnClick, Instance>)) (x);
		}
		virtual int onDoubleClick (short x, long y) override {
			return (static_cast<Main&> (*this).*(Main::DeclareCallbacks::template implFun<Button::OnDoubleClick, Instance>)) (x, y);
		}
};

// Screen-Spezifisch

class Screen : public ButtonObserverRelay<0, Screen>, public ButtonObserverRelay<1, Screen> {
	public:
		Screen () {
			btn0.addObserver (static_cast<ButtonObserverRelay<0, Screen>*> (this));
			btn1.addObserver (static_cast<ButtonObserverRelay<1, Screen>*> (this));
		}
		bool onButton0Click (int x) {
			std::cout << "Button 0 Click(" << x << ")" << std::endl;
			return true;
		}
		int onButton0DoubleClick (short x, long y) {
			std::cout << "Button 0 DoubleClick(" << x << ", " << y << ")" << std::endl;
			return 0;
		}
		bool onButton1Click (int x) {
			std::cout << "Button 1 Click(" << x << ")" << std::endl;
			return true;
		}
		int onButton1DoubleClick (short x, long y) {
			std::cout << "Button 1 DoubleClick(" << x << ", " << y << ")" << std::endl;
			return 0;
		}
		Button btn0, btn1;
		using DeclareCallbacks = Callbacks<
				Callback<Button::OnClick, 0, &Screen::onButton0Click>,
				Callback<Button::OnDoubleClick, 0, &Screen::onButton0DoubleClick>,
				Callback<Button::OnClick, 1, &Screen::onButton1Click>,
				Callback<Button::OnDoubleClick, 1, &Screen::onButton1DoubleClick>
		>;
};

int main () {
	Screen s;
	s.btn0.onClick (42);
	s.btn0.onDoubleClick (12, 3456);

	s.btn1.onClick (1);
	s.btn1.onDoubleClick (2, 3);
}