// somebar - dwl barbar
// See LICENSE file for copyright and license details.

#include <wayland-client-protocol.h>
#include <pango/pangocairo.h>
#include "bar.hpp"
#include "cairo.h"
#include "config.hpp"
#include "pango/pango-font.h"
#include "pango/pango-fontmap.h"
#include "pango/pango-layout.h"

const zwlr_layer_surface_v1_listener Bar::_layerSurfaceListener = {
    [](void *owner, zwlr_layer_surface_v1*, uint32_t serial, uint32_t width, uint32_t height)
    {
        static_cast<Bar*>(owner)->layerSurfaceConfigure(serial, width, height);
    }
};
const wl_callback_listener Bar::_frameListener = {
    [](void *owner, wl_callback *cb, uint32_t)
    {
        static_cast<Bar*>(owner)->render();
        wl_callback_destroy(cb);
    }
};

struct Font {
    PangoFontDescription *description;
    int height {0};
};
static Font getFont()
{
    auto fontMap = pango_cairo_font_map_get_default();
    if (!fontMap) die("pango_cairo_font_map_get_default");
    auto fontDesc = pango_font_description_from_string(font);
    if (!fontDesc) die("pango_font_description_from_string");
    auto tempContext = pango_font_map_create_context(fontMap);
    if (!tempContext) die("pango_font_map_create_context");
    auto font = pango_font_map_load_font(fontMap, tempContext, fontDesc);
    if (!font) die("pango_font_map_load_font");
    auto metrics = pango_font_get_metrics(font, pango_language_get_default());
    if (!metrics) die("pango_font_get_metrics");

    auto res = Font {};
    res.description = fontDesc;
    res.height = PANGO_PIXELS(pango_font_metrics_get_height(metrics));

    pango_font_metrics_unref(metrics);
    g_object_unref(font);
    g_object_unref(tempContext);
    return res;
}
static Font barfont = getFont();

BarComponent::BarComponent() { }
BarComponent::BarComponent(wl_unique_ptr<PangoLayout> layout) : pangoLayout {std::move(layout)} {}
int BarComponent::width() const
{
    int w, h;
    pango_layout_get_size(pangoLayout.get(), &w, &h);
    return PANGO_PIXELS(w);
}
void BarComponent::setText(const std::string &text)
{
    auto chars = new char[text.size()];
    text.copy(chars, text.size());
    _text.reset(chars);
    pango_layout_set_text(pangoLayout.get(), chars, text.size());
}

Bar::Bar(Monitor *mon)
{
    _mon = mon;
    _pangoContext.reset(pango_font_map_create_context(pango_cairo_font_map_get_default()));
    if (!_pangoContext) die("pango_font_map_create_context");
    for (auto i=0u; i<tagNames.size(); i++) {
        _tags.push_back({ ZNET_TAPESOFTWARE_DWL_WM_MONITOR_V1_TAG_STATE_NONE, 0, 0, createComponent(tagNames[i]) });
    }
    _layoutCmp = createComponent();
    _titleCmp = createComponent();
    _statusCmp = createComponent();
}

const wl_surface* Bar::surface() const { return _surface.get(); }
bool Bar::visible() const { return _surface.get(); }

void Bar::show(wl_output *output)
{
    if (visible()) return;
    _surface.reset(wl_compositor_create_surface(compositor));
    _layerSurface.reset(zwlr_layer_shell_v1_get_layer_surface(wlrLayerShell,
        _surface.get(), nullptr, ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM, "net.tapesoftware.Somebar"));
    zwlr_layer_surface_v1_add_listener(_layerSurface.get(), &_layerSurfaceListener, this);
    auto anchor = topbar ? ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP : ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
    zwlr_layer_surface_v1_set_anchor(_layerSurface.get(),
        anchor | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT);

    auto barSize = barfont.height + paddingY * 2;
    zwlr_layer_surface_v1_set_size(_layerSurface.get(), 0, barSize);
    zwlr_layer_surface_v1_set_exclusive_zone(_layerSurface.get(), barSize);
    wl_surface_commit(_surface.get());
}

void Bar::hide()
{
    if (!visible()) return;
    _layerSurface.reset();
    _surface.reset();
    _bufs.reset();
}

void Bar::setTag(int tag, znet_tapesoftware_dwl_wm_monitor_v1_tag_state state, int numClients, int focusedClient)
{
    auto& t = _tags[tag];
    t.state = state;
    t.numClients = numClients;
    t.focusedClient = focusedClient;
}
void Bar::setSelected(bool selected) { _selected = selected; }
void Bar::setLayout(int layout) { _layoutCmp.setText(layoutNames[layout]); }
void Bar::setTitle(const std::string &title) { _titleCmp.setText(title); }
void Bar::setStatus(const std::string &status) { _statusCmp.setText(status); }

void Bar::invalidate()
{
    if (_invalid || !visible()) return;
    _invalid = true;
    auto frame = wl_surface_frame(_surface.get());
    wl_callback_add_listener(frame, &_frameListener, this);
    wl_surface_commit(_surface.get());
}

void Bar::click(int x, int, int btn)
{
    Arg arg = {0};
    Arg *argp = nullptr;
    int control = ClkNone;
    if (x > _statusCmp.x) {
        control = ClkStatusText;
    } else if (x > _titleCmp.x) {
        control = ClkWinTitle;
    } else if (x > _layoutCmp.x) {
        control = ClkLayoutSymbol;
    } else for (auto tag = _tags.size()-1; tag >= 0; tag--) {
        if (x > _tags[tag].component.x) {
            control = ClkTagBar;
            arg.ui = 1<<tag;
            argp = &arg;
            break;
        }
    }
    for (auto i = 0u; i < sizeof(buttons)/sizeof(buttons[0]); i++) {
        const auto& button = buttons[i];
        if (button.control == control && button.btn == btn) {
            button.func(*_mon, *(argp ? argp : &button.arg));
            return;
        }
    }
}

void Bar::layerSurfaceConfigure(uint32_t serial, uint32_t width, uint32_t height)
{
    zwlr_layer_surface_v1_ack_configure(_layerSurface.get(), serial);
    _bufs.emplace(width, height, WL_SHM_FORMAT_XRGB8888);
    render();
}

void Bar::render()
{
    if (!visible()) return;
    auto img = wl_unique_ptr<cairo_surface_t> {cairo_image_surface_create_for_data(
        _bufs->data(),
        CAIRO_FORMAT_ARGB32,
        _bufs->width,
        _bufs->height,
        _bufs->stride
    )};
    auto painter = wl_unique_ptr<cairo_t> {cairo_create(img.get())};
    _painter = painter.get();
    pango_cairo_update_context(_painter, _pangoContext.get());
    _x = 0;

    renderTags();
    setColorScheme(_selected ? colorActive : colorInactive);
    renderComponent(_layoutCmp);
    renderComponent(_titleCmp);
    renderStatus();
    
    _painter = nullptr;
    wl_surface_attach(_surface.get(), _bufs->buffer(), 0, 0);
    wl_surface_damage(_surface.get(), 0, 0, INT_MAX, INT_MAX);
    wl_surface_commit(_surface.get());
    _bufs->flip();
    _invalid = false;
}

void Bar::renderTags()
{
    for (auto &tag : _tags) {
        setColorScheme(
            tag.state & ZNET_TAPESOFTWARE_DWL_WM_MONITOR_V1_TAG_STATE_ACTIVE ? colorActive : colorInactive,
            tag.state & ZNET_TAPESOFTWARE_DWL_WM_MONITOR_V1_TAG_STATE_URGENT);
        renderComponent(tag.component);
        auto indicators = std::min(tag.numClients, _bufs->height/2);
        for (auto ind = 0; ind < indicators; ind++) {
            auto w = ind == tag.focusedClient ? 7 : 1;
            cairo_move_to(_painter, tag.component.x, ind*2+0.5);
            cairo_rel_line_to(_painter, w, 0);
            cairo_close_path(_painter);
            cairo_set_line_width(_painter, 1);
            cairo_stroke(_painter);
        }
    }
}

void Bar::renderStatus()
{
    pango_cairo_update_layout(_painter, _statusCmp.pangoLayout.get());
    beginBg();
    auto start = _bufs->width - _statusCmp.width() - paddingX*2;
    cairo_rectangle(_painter, _x, 0, _bufs->width-_x+start, _bufs->height);
    cairo_fill(_painter);

    _x = start;
    renderComponent(_statusCmp);
}

void Bar::setColorScheme(const ColorScheme &scheme, bool invert)
{
    _colorScheme = invert
        ? ColorScheme {scheme.bg, scheme.fg}
        : ColorScheme {scheme.fg, scheme.bg};
}
static void setColor(cairo_t *painter, const Color &color) { cairo_set_source_rgba(painter, color.r/255.0, color.g/255.0, color.b/255.0, color.a/255.0); }
void Bar::beginFg() { setColor(_painter, _colorScheme.fg); }
void Bar::beginBg() { setColor(_painter, _colorScheme.bg); }

void Bar::renderComponent(BarComponent &component)
{
    pango_cairo_update_layout(_painter, component.pangoLayout.get());
    auto size = component.width() + paddingX*2;
    component.x = _x;

    beginBg();
    cairo_rectangle(_painter, _x, 0, size, _bufs->height);
    cairo_fill(_painter);
    cairo_move_to(_painter, _x+paddingX, paddingY);

    beginFg();
    pango_cairo_show_layout(_painter, component.pangoLayout.get());
    _x += size;
}

BarComponent Bar::createComponent(const std::string &initial)
{
    auto layout = pango_layout_new(_pangoContext.get());
    pango_layout_set_font_description(layout, barfont.description);
    auto res = BarComponent {wl_unique_ptr<PangoLayout> {layout}};
    res.setText(initial);
    return res;
}