#pragma once

#include <u.h>
#include <libn.h>

#include <wayland-server-core.h>

#define WLR_USE_UNSTABLE
#include <wlr/backend.h>
#include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_data_control_v1.h>
#include <wlr/types/wlr_data_device.h>
#include <wlr/types/wlr_export_dmabuf_v1.h>
#include <wlr/types/wlr_gamma_control_v1.h>
#include <wlr/types/wlr_gtk_primary_selection.h>
#include <wlr/types/wlr_idle.h>
#include <wlr/types/wlr_input_device.h>
#include <wlr/types/wlr_keyboard.h>
#include <wlr/types/wlr_layer_shell_v1.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_damage.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_pointer.h>
#include <wlr/types/wlr_primary_selection.h>
#include <wlr/types/wlr_primary_selection_v1.h>
#include <wlr/types/wlr_screencopy_v1.h>
#include <wlr/types/wlr_seat.h>
#include <wlr/types/wlr_server_decoration.h>
#include <wlr/types/wlr_xcursor_manager.h>
#include <wlr/types/wlr_xdg_decoration_v1.h>
#include <wlr/types/wlr_xdg_shell.h>
#include <wlr/types/wlr_xdg_output_v1.h>
#include <wlr/util/log.h>

#include "xdg-shell.h"
#include "wlr-layer-shell.h"

#include <signal.h>
#include <wait.h>
#include <xkbcommon/xkbcommon.h>
#include <linux/input-event-codes.h>


/* global macros */
#define VISIBLEON(C, M)         ((C)->m == (M) && ((C)->tags & (M)->tagset[(M)->seltags]))
#define CLEANMASK(mask)         (mask & ~WLR_MODIFIER_CAPS)
#define TAGMASK                 ((1 << arrlen(tags)) - 1)

/* main types */

typedef union  Arg      Arg;
typedef struct Button   Button;
typedef struct Mouse    Mouse;
typedef struct Grab     Grab;
typedef struct Key      Key;
typedef struct Keyboard Keyboard;
typedef struct Monitor  Monitor;
typedef struct Layout   Layout;
typedef struct Client   Client;
typedef struct Deco     Deco;
typedef struct Layer    Layer;
typedef struct Payload  Payload;

typedef struct Rule        Rule;
typedef struct MonitorRule MonitorRule;

typedef struct WindowManager WindowManager;

union Arg
{
    int   i;
    uint ui;
    float f;
    const void *v;
};

struct Button
{
    uint mod;
    uint kind;
    void (*func)(const Arg *);
    Arg  arg;
};

enum 
{
    MouseNormal=0, MouseMove, MouseResize,
};

struct Mouse
{
    uint mode;
    struct wlr_xcursor_manager *manager;
    struct wlr_cursor          *cursor;
    struct {
        struct wl_listener axis;
        struct wl_listener frame;
        struct wl_listener button;
        struct wl_listener motion;
        struct wl_listener absmotion;
        struct wl_listener cursor;
        struct wl_listener sel;
        struct wl_listener psel;
    } ev;
};

struct Grab 
{
    Client *c;
    int    x, y;
};

struct Key
{
    uint32       mod;
    xkb_keysym_t sym;
    void (*func)(const Arg *);
    Arg  arg;
};

struct Keyboard
{
    struct wl_list          link;
    struct wlr_input_device *dev;
    struct {
        struct wl_listener modifier;
        struct wl_listener keypress;
    } ev;
};

struct Layer
{
    struct wl_list link;
    struct wlr_layer_surface_v1 *surf;

    struct {
        struct wl_listener map;
        struct wl_listener unmap;
        struct wl_listener free;
        struct wl_listener commit;
        struct wl_listener detach;
        /* struct wl_listener popup; */
    } ev;

    struct wlr_box dim;
	enum zwlr_layer_shell_v1_layer z;
};
struct Monitor {
    struct wl_list    link;
    struct wlr_output *dev;
    struct {
        struct wl_listener draw;
        struct wl_listener free;
    } ev;
    struct {
        struct wl_signal kill;
    } sig;
    struct {
        struct wlr_box all;
        struct wlr_box win;
    } area;

    struct wl_list layers[4];
    struct wlr_output_damage damage;

    const  Layout *lt[2];
    uint   seltags;
    uint   sellt;
    uint   tagset[2];
    double mfact;
    int    nmaster;
};

struct Layout
{
    char  *sym;
    void (*arrange)(Monitor *);
};

struct MonitorRule {
	char *name;
	float mfact;
	int   nmaster;
	float scale;
	const Layout *lt;
	enum wl_output_transform rr;
};

struct Rule {
	char *id;
	char *title;
	uint tags;
	int  floating;
	int  monitor;
};

struct Client
{
    struct wlr_xdg_surface *surf;
    struct wlr_box          dim;
    struct {
        struct wl_list tiles;
        struct wl_list stack;
        struct wl_list focus;
    } link;
    struct {
        struct wl_listener map;
        struct wl_listener unmap;
        struct wl_listener free;
    } ev;
    int   bw;
    uint  tags;
    int   floating;
    Monitor *m;
};

struct Deco
{
	struct wl_list link;
	struct wlr_server_decoration *wlr;

    struct {
        struct wl_listener free;
        struct wl_listener mode;
    } ev;
};

struct Payload
{
    struct wlr_output *dev;
    struct timespec   *now;
    int x, y;
};

struct WindowManager 
{
    struct wl_display         *display;
    struct wlr_backend        *backend;
    struct wlr_renderer       *draw;
    struct wlr_compositor     *compositor;
    struct wlr_xdg_shell      *xdgsh;
    struct wlr_layer_shell_v1 *laysh;
    struct wlr_output_layout  *layout;
    struct wlr_idle           *idle;
    struct wlr_seat           *seat;

    struct {
        struct wlr_server_decoration_manager *deco;
        struct wlr_xdg_decoration_manager    *xdeco;
    } mngr;

    struct {
        struct wl_event_loop *loop;
        /* i/o devices */
        struct wl_listener input;
        struct wl_listener output;
        struct wl_listener client;
        /* shells */
        struct wl_listener layer;
        struct wl_listener deco;
    } ev; 

    struct {
        struct wl_list odevs;
        struct wl_list idevs;
        struct wl_list tiles; /* order of tiles */
        struct wl_list stack; /* order w/in stack */
        struct wl_list focus; /* order of focus */
        struct wl_list keyboards;
        struct wl_list decos;
    };

    /* geometry of union of output devices */
    struct wlr_box dim;
};

/* funcs.c */
void chvt(const Arg *arg);
void incmaster(const Arg *arg);
void focusmonitor(const Arg *arg);
void focusstack(const Arg *arg);
void moveresize(const Arg *arg);
void quit(const Arg *arg);
void setlayout(const Arg *arg);
void setmfact(const Arg *arg);
void spawn(const Arg *arg);
void tag(const Arg *arg);
void tagmonitor(const Arg *arg);
void togglefloating(const Arg *arg);
void toggletag(const Arg *arg);
void toggleview(const Arg *arg);
void view(const Arg *arg);

/* layouts */
void tile(Monitor *m);

#include "config.h"

// -----------------------------------------------------------------------
// global variables

extern Mouse         mouse;
extern Grab          grab;
extern Monitor      *monitor; /* currently focused */
extern WindowManager dwm;

// -----------------------------------------------------------------------
// global functions

/* util.c */
void     fatal(byte *fmt, ...);
void     scale(struct wlr_box *box, float by);

/* input.c */
void     ev·newinput(struct wl_listener *ev, void *arg);

/* client.c */
void     ev·newclient(struct wl_listener *ev, void *arg);

void     applybounds(Client *c, struct wlr_box *bbox);
void     applyrules(Client *c);
Client  *clientat(double x, double y);
Client  *getclient(void);
Client  *lastfocus(void);
void     resize(Client *c, int x, int y, int w, int h, int interact);
void     setfocus(Client *c, struct wlr_surface *surf, int lift);
void     setfloating(Client *c, int f);
void     pointerfocus(Client *c, struct wlr_surface *surf, double sx, double sy, uint32 time);

/* output.c */
void     ev·newmonitor(struct wl_listener *ev, void *arg);

void     arrange(Monitor *m);
void     setmonitor(Client *c, Monitor *m, uint newtags);
Monitor *getmonitor(int dir);
Monitor *monitorat(double x, double y);

/* layer.c */
void     ev·newlayershell(struct wl_listener *ev, void *arg);
void     arrangelayers(Monitor *m);

/* decoration.c */
void     ev·newdecoration(struct wl_listener *ev, void *arg);