#include "turns/adw/application.hpp"

#include "turns/adw/wrap_init.hpp"

#include <glibmm/class.h>
#include <glibmm/object.h>
#include <glibmm/objectbase.h>
#include <glibmm/refptr.h>
#include <glibmm/ustring.h>
#include <glibmm/utility.h>

#include <giomm/application.h>

#include <gtkmm/application.h>
#include <gtkmm/init.h>
#include <gtkmm/private/application_p.h>

#include <adwaita.h>
#include <gio/gio.h>
#include <glib-object.h>

namespace turns::adw
{
  struct Application_Class : Glib::Class
  {
    auto init() -> Glib::Class const &;
    auto static class_init_function(void * gclass, void * data) -> void;
    auto static wrap_new(GObject * object) -> Glib::ObjectBase *;
  };

  auto Application_Class::init() -> Glib::Class const &
  {
    if (!gtype_)
    {
      class_init_func_ = &Application_Class::class_init_function;
      register_derived_type(adw_application_get_type());
    }
    return *this;
  }

  auto Application_Class::class_init_function(void * gclass, void * data) -> void
  {
    auto const klass = static_cast<AdwApplicationClass *>(gclass);
    Gtk::Application_Class::class_init_function(klass, data);
  }

  auto Application_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
  {
    return new Application(ADW_APPLICATION(object));
  }

  Application_Class Application::s_class{};

  auto Application::get_type() -> GType
  {
    return s_class.init().get_type();
  }

  auto Application::get_base_type() -> GType
  {
    return adw_application_get_type();
  }

  auto Application::gobj_copy() -> AdwApplication *
  {
    reference();
    return gobj();
  }

  auto Application::create(Glib::ustring const & id, Gio::Application::Flags flags) -> Glib::RefPtr<Application>
  {
    auto static did_init = false;

    if (!did_init)
    {
      Gtk::init_gtkmm_internals();
      turns::adw::wrap_init();
      did_init = true;
    }

    return Glib::RefPtr<Application>(new Application(id, flags));
  }

  Application::Application(Glib::ConstructParams const & params)
      : Gtk::Application{params}
  {
  }

  Application::Application(AdwApplication * gobj)
      : Glib::ObjectBase{nullptr}
      , Gtk::Application((GtkApplication *)gobj)
  {
  }

  Application::Application(Glib::ustring const & id, Gio::Application::Flags flags)
      : Glib::ObjectBase{nullptr}
      , Gtk::Application{Glib::ConstructParams{s_class.init(), "application_id", Glib::c_str_or_nullptr(id), "flags", static_cast<GApplicationFlags>(flags), nullptr}}
  {
  }

}  // namespace turns::adw

namespace Glib
{
  auto wrap(AdwApplication * object, bool copy) -> Glib::RefPtr<turns::adw::Application>
  {
    return Glib::make_refptr_for_instance<turns::adw::Application>(
        dynamic_cast<turns::adw::Application *>(Glib::wrap_auto(G_OBJECT(object), copy)));
  }
}  // namespace Glib