#include <base/component.h>
#include <base/log.h>
#include <base/heap.h>
#include <root/component.h>
#include <signals_session/signals_session.h>

namespace Signals {
  struct Session_component;
  class Root_component;
  struct Main;
}

struct Signals::Session_component : Genode::Rpc_object<Session> {
  Genode::Signal_context_capability _sig_con;
  Genode::Signal_context_capability get_sig_con() override {
    return _sig_con;
  }

  Session_component(Genode::Signal_context_capability &sig_con) : _sig_con(sig_con) { }
};

class Signals::Root_component : public Genode::Root_component<Session_component> {
private:
  Genode::Signal_context_capability _sig_con;
protected:
  Session_component *_create_session(const char *) override {
    return new (md_alloc()) Session_component(_sig_con);
  }

public:
  Root_component(Genode::Entrypoint &ep, Genode::Allocator &alloc, Genode::Signal_context_capability sig_con) : Genode::Root_component<Session_component>(ep, alloc), _sig_con(sig_con) { }
};

struct Signals::Main {
  Genode::Env &_env;

  Genode::Signal_handler<Main> _sig_handler = { _env.ep(), *this, &Main::_handle_signal };

  Genode::Sliced_heap sliced_heap { _env.ram(), _env.rm() };

  Signals::Root_component root { _env.ep(), sliced_heap, _sig_handler };

  Main(Genode::Env &env) : _env(env) {
    env.parent().announce(env.ep().manage(root));
  }

  void _handle_signal() {
    Genode::log("Signal received!");
  }
};

void Component::construct(Genode::Env &env) {
  static Signals::Main main(env);
}