/*
 * Copyright (c) 2010 Mike Qin <mikeandmore@gmail.com>
 *
 * The contents of this file are subject to the terms of either the GNU Lesser
 * General Public License Version 2.1 only ("LGPL") or the Common Development and
 * Distribution License ("CDDL")(collectively, the "License"). You may not use this
 * file except in compliance with the License. You can obtain a copy of the CDDL at
 * http://www.opensource.org/licenses/cddl1.php and a copy of the LGPLv2.1 at
 * http://www.opensource.org/licenses/lgpl-license.php. See the License for the
 * specific language governing permissions and limitations under the License. When
 * distributing the software, include this License Header Notice in each file and
 * include the full text of the License in the License file as well as the
 * following notice:
 *
 * NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION LICENSE
 * (CDDL)
 * For Covered Software in this distribution, this License shall be governed by the
 * laws of the State of California (excluding conflict-of-law provisions).
 * Any litigation relating to this License shall be subject to the jurisdiction of
 * the Federal Courts of the Northern District of California and the state courts
 * of the State of California, with venue lying in Santa Clara County, California.
 *
 * Contributor(s):
 *
 * If you wish your version of this file to be governed by only the CDDL or only
 * the LGPL Version 2.1, indicate your decision by adding "[Contributor]" elects to
 * include this software in this distribution under the [CDDL or LGPL Version 2.1]
 * license." If you don't indicate a single choice of license, a recipient has the
 * option to distribute your version of this file under either the CDDL or the LGPL
 * Version 2.1, or to extend the choice of license to its licensees as provided
 * above. However, if you add LGPL Version 2.1 code and therefore, elected the LGPL
 * Version 2 license, then the option applies only if the new code is made subject
 * to such option by the copyright holder.
 */

#include <stdlib.h>
#include <string.h>
#include "skin.h"

struct _skin_window_priv_t
{
    skin_label_t* labels;
    skin_button_t* btns;

    /* current expose environment */
    skin_button_t* highlight_btn;
    skin_button_t* pressdown_btn;

    GCallback      press_cb;
    GCallback      release_cb;
    GCallback      motion_cb;

    void*          press_cb_data;
    void*          release_cb_data;
    void*          motion_cb_data;

    /* drag to move positions */
    gboolean       enable_drag_to_move;
    int            drag_init_x;
    int            drag_init_y;
    gboolean       drag_begin;
};

struct _skin_button_priv_t
{
    skin_button_t* next;
    skin_window_t* parent;

    GCallback press_cb;
    GCallback release_cb;

    void*     press_cb_data;
    void*     release_cb_data;
};

struct _skin_label_priv_t
{
    skin_label_t*  next;
    skin_window_t* wind;
};

static void
zoom_and_composite(GdkPixbuf* src,
                   GdkPixbuf* dst,
                   int        x,
                   int        y,
                   int        width,
                   int        height,
                   int        dst_x,
                   int        dst_y,
                   int        dst_width,
                   int        dst_height)
{
    if (width <= 0 || height <= 0 || dst_width <= 0 || dst_height <= 0)
        return;
    GdkPixbuf* sub = gdk_pixbuf_new_subpixbuf(src, x, y, width, height);
    double x_scale = 1.0 * dst_width / width;
    double y_scale = 1.0 * dst_height / height;

    gdk_pixbuf_scale(sub, dst, dst_x, dst_y, dst_width, dst_height,
                     dst_x, dst_y, x_scale, y_scale, GDK_INTERP_BILINEAR);
    g_object_unref(sub);
}

static void
cairo_paint_pixbuf(cairo_t*   cr,
                   GdkPixbuf* buf,
                   int        off_x,
                   int        off_y)
{
    gdk_cairo_set_source_pixbuf(cr, buf, off_x, off_y);
    cairo_paint(cr);
}

static void
paint_background_with_mask(GtkWidget*      wid,
                           skin_window_t*  wind)
{
    GdkPixbuf* bg = wind->background_image;
    int width, height;
    int bg_width, bg_height;
    int top, left, bottom, right;

    width = wid->allocation.width;
    height = wid->allocation.height;
    bg_width = gdk_pixbuf_get_width(bg);
    bg_height = gdk_pixbuf_get_height(bg);

    top = wind->margin_top;
    left = wind->margin_left;
    right = wind->margin_right;
    bottom = wind->margin_bottom;

    GdkPixbuf* newbg = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8,
                                       width, height);

    // 4 corners
    gdk_pixbuf_copy_area(bg, 0, 0, left, top, newbg, 0, 0);
    gdk_pixbuf_copy_area(bg, bg_width - right, 0, right, top,
                         newbg, width - right, 0);
    gdk_pixbuf_copy_area(bg, 0, bg_height - bottom, left, bottom,
                         newbg, 0, height - bottom);
    gdk_pixbuf_copy_area(bg, bg_width - right, bg_height - bottom,
                         right, bottom,
                         newbg, width - right, height - bottom);

    // 4 margins and the center area
    int content_width = bg_width - left - right;
    int content_height = bg_height - top - bottom;
    int new_content_width = width - left - right;
    int new_content_height = height - top - bottom;

    // top
    zoom_and_composite(bg, newbg, left, 0, content_width, top,
                       left, 0, new_content_width, top);
    // bottom
    zoom_and_composite(bg, newbg,
                       left, bg_height - bottom, content_width, bottom,
                       left, height - bottom, new_content_width, bottom);
    // left
    zoom_and_composite(bg, newbg,
                       0, top, left, content_height,
                       0, top, left, new_content_height);
    // right
    zoom_and_composite(bg, newbg,
                       bg_width - right, top, right, content_height,
                       width - right, top, right, new_content_height);
    // center
    zoom_and_composite(bg, newbg,
                       left, top, content_width, content_height,
                       left, top, new_content_width, new_content_height);

    gdk_window_clear(wid->window);
    // paint it
    cairo_t* cr = gdk_cairo_create(wid->window);
    cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
    cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0);
    cairo_paint(cr);
    cairo_paint_pixbuf(cr, newbg, 0, 0);
    cairo_destroy(cr);
    // set the mask
    GdkBitmap* mask;
    gdk_pixbuf_render_pixmap_and_mask(newbg, NULL, &mask,
                                      wind->alpha_mask_threshold);
    gdk_window_shape_combine_mask(wid->window, mask, 0, 0);

    g_object_unref(newbg);
}

static void
paint_buttons(GtkWidget*     wid,
              skin_window_t* wind)
{
    cairo_t* cr = gdk_cairo_create(wid->window);
    skin_button_t* btn = wind->priv->btns;
    for (; btn != NULL; btn = btn->priv->next) {
        if (btn == wind->priv->pressdown_btn) {
            cairo_paint_pixbuf(cr, btn->pressdown_image, btn->x, btn->y);
        } else if (btn == wind->priv->highlight_btn) {
            cairo_paint_pixbuf(cr, btn->highlight_image, btn->x, btn->y);
        } else {
            cairo_paint_pixbuf(cr, btn->normal_image, btn->x, btn->y);
        }
    }
    cairo_destroy(cr);
}

static void
paint_labels(GtkWidget*     wid,
             skin_window_t* wind)
{
    cairo_t* cr = gdk_cairo_create(wid->window);
    skin_label_t* label = wind->priv->labels;
    for (; label != NULL; label = label->priv->next) {
        cairo_set_source_rgba(cr, label->color_r, label->color_g,
                              label->color_b, label->color_a);
        if (label->layout == NULL) {
            label->layout = pango_cairo_create_layout(cr);
            pango_layout_set_font_description(
                label->layout, pango_font_description_from_string(label->font));
        }
        pango_layout_set_text(label->layout, label->text, -1);
        cairo_move_to(cr, label->x, label->y);
        pango_cairo_layout_path(cr, label->layout);
        cairo_fill(cr);
    }
    cairo_destroy(cr);
}

static gboolean
window_on_expose(GtkWidget*      wid,
                 GdkEventExpose* evt,
                 skin_window_t*  wind)
{
    paint_background_with_mask(wid, wind);
    paint_labels(wid, wind);
    paint_buttons(wid, wind);
    return TRUE;
}

static gboolean
window_on_configure(GtkWidget*         wid,
                    GdkEventConfigure* evt,
                    skin_window_t*     wind)
{
    gtk_widget_queue_draw(wid);
    return FALSE;
}

static skin_button_t*
find_button(skin_window_t* wind, int pos_x, int pos_y)
{
    skin_button_t* btn = wind->priv->btns;
    for (; btn != NULL; btn = btn->priv->next) {
        int x = btn->x, y = btn->y, width = btn->width, height = btn->height;
        if (pos_x > x && pos_y > y && pos_x < x + width && pos_y < y + height) {
            return btn;
        }
    }
    return NULL;
}

static gboolean
set_expose_env(skin_window_t* wind,
               skin_button_t* highlight,
               skin_button_t* down)
{
    gboolean ret = FALSE;
    if (wind->priv->highlight_btn != highlight) {
        ret |= TRUE;
        wind->priv->highlight_btn = highlight;
    }
    if (wind->priv->pressdown_btn != down) {
        ret |= TRUE;
        wind->priv->pressdown_btn = down;
    }
    return ret;
}

typedef gboolean (*motion_cb_t) (GtkWidget*, GdkEventMotion*, void*);
typedef gboolean (*mouse_cb_t) (GtkWidget*, GdkEventButton*, void*);

static gboolean
window_on_motion(GtkWidget*      wid,
                 GdkEventMotion* evt,
                 skin_window_t*  wind)
{
    skin_button_t* btn = find_button(wind, evt->x, evt->y);
    gboolean need_redraw = FALSE;
    if (btn) {
        if ((evt->state & GDK_BUTTON1_MASK) != 0
            || (evt->state & GDK_BUTTON2_MASK) != 0
            || (evt->state & GDK_BUTTON3_MASK) != 0) {
            need_redraw = set_expose_env(wind, NULL, btn);
        } else {
            need_redraw = set_expose_env(wind, btn, NULL);
        }
    } else {
        /* move it if drag */
        if (wind->priv->enable_drag_to_move && wind->priv->drag_begin) {
            gtk_window_move(GTK_WINDOW(wind->widget),
                            evt->x_root - wind->priv->drag_init_x,
                            evt->y_root - wind->priv->drag_init_y);
        }
        need_redraw = set_expose_env(wind, NULL, NULL);
        motion_cb_t cb = (motion_cb_t) wind->priv->motion_cb;
        if (cb) {
            cb(wid, evt, wind->priv->motion_cb_data);
        }
    }
    if (need_redraw) {
        gtk_widget_queue_draw(wid);
    }
    return TRUE;
}

static gboolean
window_on_press_or_release(GtkWidget*      wid,
                           GdkEventButton* evt,
                           skin_window_t*  wind,
                           gboolean        press)
{
    skin_button_t* btn = find_button(wind, evt->x, evt->y);
    gboolean need_redraw = FALSE;
    skin_button_t* highlight_btn = NULL;
    skin_button_t* pressdown_btn = NULL;
    mouse_cb_t btncb = NULL;
    mouse_cb_t wincb = NULL;

    if (press) {
        wincb = (mouse_cb_t) wind->priv->press_cb;
        pressdown_btn = btn;
        if (!btn) {
            /* update drag init positions */
            wind->priv->drag_init_x = evt->x;
            wind->priv->drag_init_y = evt->y;
            wind->priv->drag_begin = wind->priv->enable_drag_to_move;
        } else {
            btncb = (mouse_cb_t) btn->priv->press_cb;
        }
    } else {
        wincb = (mouse_cb_t) wind->priv->release_cb;
        highlight_btn = btn;
        if (!btn) {
            wind->priv->drag_begin = FALSE;
        } else {
            btncb = (mouse_cb_t) btn->priv->release_cb;
        }
    }

    if (btn) {
        need_redraw = set_expose_env(wind, highlight_btn, pressdown_btn);
        if (btncb) {
            btncb(wid, evt, btn->priv->press_cb_data);
        }
    } else {
        if (wincb) {
            wincb(wid, evt, wind->priv->press_cb_data);
        }
    }
    if (need_redraw) {
        gtk_widget_queue_draw(wid);
    }
    return TRUE;
}

static gboolean
window_on_press(GtkWidget*      wid,
                GdkEventButton* evt,
                skin_window_t*  wind)
{
    return window_on_press_or_release(wid, evt, wind, TRUE);
}

static gboolean
window_on_release(GtkWidget* wid,
                  GdkEventButton* evt,
                  skin_window_t* wind)
{
    return window_on_press_or_release(wid, evt, wind, FALSE);
}

skin_window_t*
skin_window_new(GtkWindow* widget,
                GdkPixbuf* background_image,
                int        margin_top,
                int        margin_left,
                int        margin_bottom,
                int        margin_right,
                int        alpha_mask_threshold)
{
    skin_window_t* wind = malloc(sizeof(skin_window_t));
    wind->widget = GTK_WIDGET(widget);
    wind->background_image = background_image;
    wind->margin_top = margin_top;
    wind->margin_left = margin_left;
    wind->margin_bottom = margin_bottom;
    wind->margin_right = margin_right;
    wind->alpha_mask_threshold = alpha_mask_threshold;
    wind->priv = malloc(sizeof(skin_window_priv_t));
    memset(wind->priv, 0, sizeof(skin_window_priv_t));
    gtk_window_set_default_size(widget,
                                gdk_pixbuf_get_width(background_image),
                                gdk_pixbuf_get_height(background_image));

    /* set rgba */
    GdkScreen* screen = gdk_screen_get_default();
    GdkColormap* cmap = gdk_screen_get_rgba_colormap(screen);
    if (cmap) {
        gtk_widget_set_colormap(wind->widget, cmap);
    } else {
        fprintf(stderr, "Cannot set rgba colormap!\n");
    }

    /* signal expose */
    gtk_widget_set_events(wind->widget,
                          GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK
                          | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
    gtk_widget_realize(wind->widget);

    g_signal_connect(wind->widget, "expose-event",
                     G_CALLBACK(window_on_expose), wind);
    g_signal_connect(wind->widget, "configure-event",
                     G_CALLBACK(window_on_configure), wind);
    g_signal_connect(wind->widget, "motion-notify-event",
                     G_CALLBACK(window_on_motion), wind);
    g_signal_connect(wind->widget, "button-press-event",
                     G_CALLBACK(window_on_press), wind);
    g_signal_connect(wind->widget, "button-release-event",
                     G_CALLBACK(window_on_release), wind);
    return wind;
}

void
skin_window_destroy(skin_window_t* wind)
{
    gtk_widget_destroy(wind->widget);
    free(wind->priv);
    free(wind);
}

void
skin_window_add_button(skin_window_t* wind,
                       skin_button_t* btn,
                       int            x,
                       int            y)
{
    /* append to the buttons list */
    btn->priv->next = wind->priv->btns;
    wind->priv->btns = btn;

    btn->priv->parent = wind;
    btn->x = x;
    btn->y = y;
}

void
skin_window_set_drag_to_move(skin_window_t* wind,
                             gboolean       drag_to_move)
{
    wind->priv->enable_drag_to_move = drag_to_move;
}

skin_button_t*
skin_button_new(GdkPixbuf* normal_image,
                GdkPixbuf* highlight_image,
                GdkPixbuf* pressdown_image)
{
    skin_button_t* btn = malloc(sizeof(skin_button_t));
    btn->normal_image = normal_image;
    btn->highlight_image = highlight_image;
    btn->pressdown_image = pressdown_image;
    btn->width = gdk_pixbuf_get_width(normal_image);
    btn->height = gdk_pixbuf_get_height(normal_image);
    btn->priv = malloc(sizeof(skin_button_priv_t));
    memset(btn->priv, 0, sizeof(skin_button_priv_t));
    return btn;
}

void
skin_button_destroy(skin_button_t* btn)
{
    free(btn->priv);
    free(btn);
}

void
skin_button_set_image(skin_button_t* btn,
                      GdkPixbuf* normal_image,
                      GdkPixbuf* highlight_image,
                      GdkPixbuf* pressdown_image)
{
    /* since we're redraw it, we'd better check if we really changed
       the pixbuf. This can save a lot of time.
    */
    gboolean need_set = (btn->normal_image != normal_image) ||
        (btn->highlight_image != highlight_image) ||
        (btn->pressdown_image != pressdown_image);

    if (!need_set)
        return;

    btn->normal_image = normal_image;
    btn->highlight_image = highlight_image;
    btn->pressdown_image = pressdown_image;
    if (btn->priv->parent) {
        gtk_widget_queue_draw(btn->priv->parent->widget);
    }
}

skin_label_t*
skin_label_new(char*  font,
               char*  text,
               double color_r,
               double color_g,
               double color_b,
               double color_a)
{
    skin_label_t* label = malloc(sizeof(skin_label_t));
    label->color_r = color_r;
    label->color_g = color_g;
    label->color_b = color_b;
    label->color_a = color_a;
    label->font = strdup(font);
    if (text) {
        label->text = strdup(text);
    } else {
        label->text = NULL;
    }
    label->layout = NULL;
    label->priv = malloc(sizeof(skin_label_priv_t));
    memset(label->priv, 0, sizeof(skin_label_priv_t));

    return label;
}

void
skin_label_destroy(skin_label_t* label)
{
    free(label->text);
    free(label->font);
    free(label->priv);
    if (label->layout) {
        g_object_unref(label->layout);
    }
    free(label);
}

void
skin_window_add_label(skin_window_t* wind,
                      skin_label_t*  label,
                      int            x,
                      int            y)
{
    label->x = x;
    label->y = y;
    label->priv->wind = wind;
    label->priv->next = wind->priv->labels;
    wind->priv->labels = label;

    cairo_t* cr = gdk_cairo_create(wind->widget->window);
    label->layout = pango_cairo_create_layout(cr);
    pango_layout_set_font_description(
        label->layout, pango_font_description_from_string(label->font));
    cairo_destroy(cr);
}

void
skin_label_set_text(skin_label_t* label, const char* text)
{
    free(label->text);
    if (text) {
        label->text = strdup(text);
        pango_layout_set_text(label->layout, label->text, -1);
    } else {
        label->text = NULL;
    }
    if (label->layout && label->priv->wind) {
        gtk_widget_queue_draw(label->priv->wind->widget);
    }
}

#define SET_CB_IMPL(name, event)                                        \
    void skin_##name##_set_##event##_cb(skin_##name##_t* wid,           \
                                        GCallback        cb,            \
                                        void*            data)          \
    { wid->priv->event##_cb = cb; wid->priv->event##_cb_data = data; }  \


SET_CB_IMPL(window, press);
SET_CB_IMPL(window, release);
SET_CB_IMPL(window, motion);
SET_CB_IMPL(button, press);
SET_CB_IMPL(button, release);