#include <glib.h>
#include <stdbool.h>
#include <math.h>

#include "animate.h"
#include "state.h"
#include "log.h"

double clamp(double x, double min, double max)
{
    const double t = x < min ? min : x;
    return t > max ? max : t;
}

double smoothstep(double x, double edge0, double edge1)
{
   x = clamp((x - edge0) / (edge1 - edge0), 0, 1);
   return x * x * (3.0 - 2.0 * x);
}

double quadratic_bezier(double x, double a, double b, double c)
{
	g_assert(x >= 0 && x <= 1);
	g_assert(a >= 0 && a <= 1);
	g_assert(b >= 0 && b <= 1);
	g_assert(c >= 0 && c <= 1);

	const double t = 1 - x;
	return a * t * t + 2 * b * t * x + c * x * x;
}

double cubic_bezier(double x, double a, double b, double c, double d)
{
	g_assert(x >= 0 && x <= 1);
	g_assert(a >= 0 && a <= 1);
	g_assert(b >= 0 && b <= 1);
	g_assert(c >= 0 && c <= 1);
	g_assert(d >= 0 && d <= 1);

	const double t = 1 - x;
	return a * (t * t * t) + 3 * b * (t * t * x) + 3 * c * (t * x * x) + d * (x * x * x);
}

typedef struct {
    Animation anim;
    int width;
    cairo_pattern_t *gradient;
} AnimationShine;

// FIXME: Not working for button group
static bool shine_paint(AnimationShine *shine, cairo_t *cr, const Layout *layout)
{
    gint64 end = shine->anim.start + shine->anim.duration;
    gint64 now = g_get_monotonic_time();
    if (now > end) return false;

    double t = (double)(now - shine->anim.start) / (end - shine->anim.start);
    double pos = cubic_bezier(t, 0.19, 1.0, 0.22, 1.0);

    double angle = atan((double)layout->height / layout->width);

    // Make it double just to be sure
    int h = 2 * (double)layout->height / cos(angle);
    int x = layout->x + pos * layout->width - shine->width;
    int y = layout->y;

    cairo_matrix_t matrix;
    cairo_matrix_init_translate(&matrix, -x, -y);
    cairo_pattern_set_matrix(shine->gradient, &matrix);

    int dx = layout->x + layout->width / 2;
    int dy = layout->y + layout->height / 2;

    cairo_translate(cr, dx, dy);
    cairo_rotate(cr, -angle);
    cairo_translate(cr, -dx, -dy);

    cairo_set_operator(cr, CAIRO_OPERATOR_ATOP);
    cairo_set_source(cr, shine->gradient);
    cairo_rectangle(cr, x, y - (h - layout->height) / 2, shine->width, h);
    cairo_fill(cr);

    return true;
}

Animation *animation_shine_create(gint64 duration)
{
    // Note the 0 initialization
    AnimationShine *shine = g_malloc0(sizeof(AnimationShine));
    shine->anim.type = ANIM_SHINE;
    shine->anim.paint_func = (DrawFunc)shine_paint;
    shine->anim.duration = duration;

    // TODO: Change it depending on container size
    shine->width = 20;

    shine->gradient = cairo_pattern_create_linear(0, 0, shine->width, 0);
    cairo_pattern_add_color_stop_rgba(shine->gradient, 0, 1, 1, 1, 0);
    cairo_pattern_add_color_stop_rgba(shine->gradient, 0.5, 1, 1, 1, 0.333);
    cairo_pattern_add_color_stop_rgba(shine->gradient, 1, 1, 1, 1, 0);

    return (gpointer)shine;
}

static bool pulse_layout(Animation *pulse, Layout *layout)
{
    gint64 end = pulse->start + pulse->duration;
    gint64 now = g_get_monotonic_time();
    if (now > end) return false;

    // After half the duration we invert direction
    gint64 mid = pulse->start + pulse->duration / 2;
    double t = now <= mid
        ? (double)(now - pulse->start) / (mid - pulse->start)
        : 1.0 - (double)(now - mid) / (end - mid);

    double pos = cubic_bezier(t, 0.19, 1.0, 0.22, 1.0);
    int max = 0.15 * layout->height;

    layout->x_pad = layout->btn->x_pad + max * pos;
    layout->y_pad = layout->btn->y_pad + max * pos;

    return true;
}

Animation *animation_pulse_create(gint64 duration)
{
    // Note the 0 initialization
    Animation *pulse = g_malloc0(sizeof(Animation));
    pulse->type = ANIM_PULSE;
    pulse->layout_func = (LayoutFunc)pulse_layout;
    pulse->duration = duration;

    return (gpointer)pulse;
}

void animation_destroy(Animation *anim)
{
    if (anim == NULL) return;

    if (anim->type == ANIM_SHINE)
        cairo_pattern_destroy(CAST(anim, AnimationShine)->gradient);

    g_free(anim);
}

// vim: ts=4 sw=4 et