#pragma once

#include <X11/X.h>
#include <X11/Xlib-xcb.h>
#include <xcb/xcb.h>
#include <boost/optional.hpp>
#include <iomanip>
#include <xpp/xpp.hpp>

#include "common.hpp"
#include "x11/types.hpp"

#if ENABLE_DAMAGE_EXT
#include "x11/damage.hpp"
#endif
#if ENABLE_RENDER_EXT
#include "x11/render.hpp"
#endif
#if ENABLE_RANDR_EXT
#include "x11/randr.hpp"
#endif
#if ENABLE_SYNC_EXT
#include "x11/sync.hpp"
#endif
#if ENABLE_COMPOSITE_EXT
#include "x11/composite.hpp"
#endif

POLYBAR_NS

using xpp_connection = xpp::connection<
#if ENABLE_DAMAGE_EXT
    xpp::damage::extension
#endif
#if ENABLE_RANDR_EXT
#if ENABLE_DAMAGE_EXT
    ,
#endif
    xpp::randr::extension
#endif
#if ENABLE_RENDER_EXT
#if (ENABLE_RANDR_EXT || ENABLE_DAMAGE_EXT)
    ,
#endif
    xpp::render::extension
#endif
#if ENABLE_SYNC_EXT
#if (ENABLE_RANDR_EXT || ENABLE_DAMAGE_EXT || ENABLE_RENDER_EXT)
    ,
#endif
    xpp::sync::extension
#endif
#if ENABLE_COMPOSITE_EXT
#if (ENABLE_RANDR_EXT || ENABLE_DAMAGE_EXT || ENABLE_RENDER_EXT || ENABLE_SYNC_EXT)
    ,
#endif
    xpp::composite::extension
#endif
    >;

class connection : public xpp_connection {
 public:
  explicit connection() {}
  explicit connection(xcb_connection_t* conn) : xpp_connection(conn) {}

  connection& operator=(const connection&) {
    return *this;
  }

  virtual ~connection() {}

  template <typename Event, uint32_t ResponseType>
  void wait_for_response(function<bool(const Event&)> check_event) {
    auto fd = get_file_descriptor();
    fd_set fds;
    FD_ZERO(&fds);
    FD_SET(fd, &fds);

    while (true) {
      if (select(fd + 1, &fds, nullptr, nullptr, nullptr) > 0) {
        shared_ptr<xcb_generic_event_t> evt;

        if ((evt = poll_for_event()) && evt->response_type == ResponseType) {
          if (check_event(reinterpret_cast<const xcb_map_notify_event_t&>(*(evt.get())))) {
            break;
          }
        }
      }

      if (connection_has_error()) {
        break;
      }
    }
  }

  void preload_atoms();

  void query_extensions();

  string id(xcb_window_t w) const;

  xcb_screen_t* screen();

  void ensure_event_mask(xcb_window_t win, uint32_t event);
  void clear_event_mask(xcb_window_t win);

  shared_ptr<xcb_client_message_event_t> make_client_message(xcb_atom_t type, xcb_window_t target) const;

  void send_client_message(const shared_ptr<xcb_client_message_event_t>& message, xcb_window_t target,
      uint32_t event_mask = 0xFFFFFF, bool propagate = false) const;

  void send_dummy_event(xcb_window_t target, uint32_t event = XCB_EVENT_MASK_STRUCTURE_NOTIFY) const;

  boost::optional<xcb_visualtype_t*> visual_type(xcb_screen_t* screen, int match_depth = 32);

  static string error_str(int error_code);

  void dispatch_event(const shared_ptr<xcb_generic_event_t>& evt) const;

  /**
   * Attach sink to the registry */
  template <typename Sink>
  void attach_sink(Sink&& sink, registry::priority prio = 0) {
    m_registry.attach(prio, forward<Sink>(sink));
  }

  /**
   * Detach sink from the registry
   */
  template <typename Sink>
  void detach_sink(Sink&& sink, registry::priority prio = 0) {
    m_registry.detach(prio, forward<Sink>(sink));
  }

 protected:
  registry m_registry{*this};
  xcb_screen_t* m_screen = nullptr;
};

di::injector<connection&> configure_connection();

POLYBAR_NS_END