#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

#include "../block.h"
#include "../format.h"
#include "../any_log.h"

typedef struct {
    block_spec_t block;
    int value;
    unsigned int height;
    unsigned int width;
    unsigned int line_width;
    gradient_t bar_color;
    gradient_t line_color;
    gradient_t bg_color;
    bool seekable;
} block_slider_t;

static void block_slider_layout(block_t *block, layout_t *layout, layout_info_t info)
{
    block_slider_t *slider = (block_slider_t *)block;
    layout->width = info.height + slider->width;
}

static void block_slider_render(layout_t *layout, cairo_t *cr)
{
    block_slider_t *slider = (block_slider_t *)layout->block;

    const int radius = slider->height / 2;
    int bar_y = layout->y + (layout->height - slider->height) / 2;
    int bar_x = layout->x + (layout->width - slider->width) / 2;

    cairo_matrix_t matrix;
    cairo_matrix_init_scale(&matrix, 1.0 / slider->width, 1.0);
    cairo_matrix_translate(&matrix, -bar_x, 0.0);

    cairo_pattern_t *pattern = slider->bg_color.pattern;
    if (pattern != NULL) {
        render_capsule_fast(cr, bar_x, bar_y, slider->width, radius, radius);

        cairo_pattern_set_matrix(pattern, &matrix);
        cairo_set_source(cr, pattern);
        cairo_fill(cr);
    }

    pattern = slider->bar_color.pattern;
    if (pattern != NULL) {
        int current = slider->width * (slider->value / 100.0);
        render_capsule(cr, bar_x, bar_y, current, radius, radius);

        cairo_pattern_set_matrix(pattern, &matrix);
        cairo_set_source(cr, pattern);
        cairo_fill(cr);
    }

    pattern = slider->line_color.pattern;
    if (pattern != NULL) {
        int line_radius = radius - slider->line_width / 2;
        render_capsule_fast(cr, bar_x, bar_y, slider->width, radius, line_radius);

        cairo_pattern_set_matrix(pattern, &matrix);
        cairo_set_source(cr, pattern);
        cairo_set_line_width(cr, slider->line_width);
        cairo_stroke(cr);
    }
}

static void block_slider_event(layout_t *layout, event_t event)
{
    block_slider_t *slider = (block_slider_t *)layout->block;
    int value = slider->value;

    if (!slider->seekable) return;

    if (event_is_click(event)) {
        int bar_x = layout->x + (layout->width - slider->width) / 2;
        int bar_y = layout->y + (layout->height - slider->height) / 2;

        if (check_capsule(event.x, event.y, bar_x, bar_y, slider->width, slider->height)) {
            int value = 100 * (event.x - bar_x) / (double)(slider->width - 1);
            slider->value = value;
        }
    } else if (event_is_scroll(event)) {
        int step = event.type == EVENT_SCROLL_DOWN ? -1 : 1;
        slider->value += step;

        if (slider->value > 100) slider->value = 100;
        if (slider->value < 0)   slider->value = 0;
    }

    log_value_debug("Updated slider value",
                    "s:label", layout->block->label,
                    "i:old_value", value,
                    "i:new_value", slider->value);
}

static void block_slider_init(block_t *block, const block_scheme_t *scheme)
{
    block->type = BLOCK_SPEC;
    block_slider_t *slider  = (block_slider_t *)block;
    slider->block.layout_fn = block_slider_layout;
    slider->block.render_fn = block_slider_render;
    slider->block.event_fn  = block_slider_event;
}

static void block_slider_clean(block_t *block)
{
    block_slider_t *slider = (block_slider_t *)block;
    gradient_free(&slider->bar_color);
    gradient_free(&slider->line_color);
    gradient_free(&slider->bg_color);
}

static int block_slider_validate(block_t *block, const block_scheme_t *scheme)
{
    block_slider_t *slider = (block_slider_t *)block;
    int errors = 0;

    if (slider->value < 0 || slider->value > 100) {
        log_error("Block '%s' requires '%s' to be between 0 and 100", block->label, "bar-value");
        errors++;
    }

    return errors;
}

static const config_entry_t block_slider_entries[] = {
    // TODO: Ugly names
    { "bar-color",      CONFIG_GRADIENT, NULL, offsetof(block_slider_t, bar_color) },
    { "bar-line-color", CONFIG_GRADIENT, NULL, offsetof(block_slider_t, line_color) },
    { "bar-bg-color",   CONFIG_GRADIENT, NULL, offsetof(block_slider_t, bg_color) },
    { "bar-height",     CONFIG_UINT,     NULL, offsetof(block_slider_t, height) },
    { "bar-width",      CONFIG_UINT,     NULL, offsetof(block_slider_t, width) },
    { "bar-line-width", CONFIG_UINT,     NULL, offsetof(block_slider_t, line_width) },
    { "bar-value",      CONFIG_INT,      NULL, offsetof(block_slider_t, value) },
    { "seekable",       CONFIG_BOOL,     NULL, offsetof(block_slider_t, seekable) },
    { 0 },
};

const block_scheme_t block_slider_scheme = {
    .name = "slider",
    .entries = block_slider_entries,
    .size = sizeof(block_slider_t),
    .init_fn = block_slider_init,
    .clean_fn = block_slider_clean,
    .validate_fn = block_slider_validate,
};