/*
 * Copyright (C) 2001 Havoc Pennington
 * Copyright (C) 2016 Alberts Muktupāvels
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#include <glib/gi18n-lib.h>

#include "meta-color-spec-private.h"
#include "meta-gradient-spec-private.h"
#include "meta-theme.h"

struct _MetaGradientSpec
{
  MetaGradientType  type;
  GSList           *color_specs;
};

struct _MetaAlphaGradientSpec
{
  MetaGradientType  type;
  guchar           *alphas;
  gint              n_alphas;
};


static cairo_pattern_t *
create_cairo_pattern_from_gradient_spec (const MetaGradientSpec      *spec,
                                         const MetaAlphaGradientSpec *alpha_spec,
                                         GtkStyleContext             *context)
{
  gint n_colors;
  cairo_pattern_t *pattern;
  GSList *tmp;
  gint i;

  n_colors = g_slist_length (spec->color_specs);
  if (n_colors == 0)
    return NULL;

  if (alpha_spec != NULL && alpha_spec->n_alphas != 1)
    g_assert (n_colors == alpha_spec->n_alphas);

  if (spec->type == META_GRADIENT_HORIZONTAL)
    pattern = cairo_pattern_create_linear (0, 0, 1, 0);
  else if (spec->type == META_GRADIENT_VERTICAL)
    pattern = cairo_pattern_create_linear (0, 0, 0, 1);
  else if (spec->type == META_GRADIENT_DIAGONAL)
    pattern = cairo_pattern_create_linear (0, 0, 1, 1);
  else
    g_assert_not_reached ();

  i = 0;
  tmp = spec->color_specs;
  while (tmp != NULL)
    {
      GdkRGBA color;

      meta_color_spec_render (tmp->data, context, &color);

      if (alpha_spec != NULL)
        {
          gdouble alpha;

          if (alpha_spec->n_alphas == 1)
            alpha = alpha_spec->alphas[0] / 255.0;
          else
            alpha = alpha_spec->alphas[i] / 255.0;

          cairo_pattern_add_color_stop_rgba (pattern, i / (gfloat) (n_colors - 1),
                                             color.red, color.green, color.blue,
                                             alpha);
        }
      else
        cairo_pattern_add_color_stop_rgb (pattern, i / (gfloat) (n_colors - 1),
                                          color.red, color.green, color.blue);

      tmp = tmp->next;
      ++i;
    }

  if (cairo_pattern_status (pattern) != CAIRO_STATUS_SUCCESS)
    {
      cairo_pattern_destroy (pattern);
      return NULL;
    }

  return pattern;
}

static void
free_color_spec (gpointer spec,
                 gpointer user_data)
{
  meta_color_spec_free (spec);
}

MetaGradientSpec *
meta_gradient_spec_new (MetaGradientType type)
{
  MetaGradientSpec *spec;

  spec = g_new (MetaGradientSpec, 1);

  spec->type = type;
  spec->color_specs = NULL;

  return spec;
}

void
meta_gradient_spec_free (MetaGradientSpec *spec)
{
  g_return_if_fail (spec != NULL);

  g_slist_foreach (spec->color_specs, free_color_spec, NULL);
  g_slist_free (spec->color_specs);

  g_free (spec);
}

void
meta_gradient_spec_add_color_spec (MetaGradientSpec *spec,
                                   MetaColorSpec    *color_spec)
{
  spec->color_specs = g_slist_append (spec->color_specs, color_spec);
}

void
meta_gradient_spec_render (const MetaGradientSpec      *spec,
                           const MetaAlphaGradientSpec *alpha_spec,
                           cairo_t                     *cr,
                           GtkStyleContext             *context,
                           gdouble                      x,
                           gdouble                      y,
                           gdouble                      width,
                           gdouble                      height)
{
  cairo_pattern_t *pattern;

  pattern = create_cairo_pattern_from_gradient_spec (spec, alpha_spec, context);
  if (pattern == NULL)
    return;

  cairo_save (cr);

  cairo_rectangle (cr, x, y, width, height);

  cairo_translate (cr, x, y);
  cairo_scale (cr, width, height);

  cairo_set_source (cr, pattern);
  cairo_fill (cr);
  cairo_pattern_destroy (pattern);

  cairo_restore (cr);
}

gboolean
meta_gradient_spec_validate (MetaGradientSpec  *spec,
                             GError           **error)
{
  g_return_val_if_fail (spec != NULL, FALSE);

  if (g_slist_length (spec->color_specs) < 2)
    {
      g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
                   _("Gradients should have at least two colors"));

      return FALSE;
    }

  return TRUE;
}

MetaAlphaGradientSpec *
meta_alpha_gradient_spec_new (MetaGradientType type,
                              gint             n_alphas)
{
  MetaAlphaGradientSpec *spec;

  g_return_val_if_fail (n_alphas > 0, NULL);

  spec = g_new0 (MetaAlphaGradientSpec, 1);

  spec->type = type;
  spec->alphas = g_new0 (guchar, n_alphas);
  spec->n_alphas = n_alphas;

  return spec;
}

void
meta_alpha_gradient_spec_free (MetaAlphaGradientSpec *spec)
{
  g_return_if_fail (spec != NULL);

  g_free (spec->alphas);
  g_free (spec);
}

void
meta_alpha_gradient_spec_add_alpha (MetaAlphaGradientSpec *spec,
                                    gint                   n_alpha,
                                    gdouble                alpha)
{
  spec->alphas[n_alpha] = (guchar) (alpha * 255);
}

guchar
meta_alpha_gradient_spec_get_alpha (MetaAlphaGradientSpec *spec,
                                    gint                   n_alpha)
{
  return spec->alphas[n_alpha];
}

void
meta_alpha_gradient_spec_render (MetaAlphaGradientSpec *spec,
                                 GdkRGBA                color,
                                 cairo_t               *cr,
                                 gdouble                x,
                                 gdouble                y,
                                 gdouble                width,
                                 gdouble                height)
{
  if (!spec || spec->n_alphas == 1)
    {
      if (spec)
        color.alpha = spec->alphas[0] / 255.0;

      gdk_cairo_set_source_rgba (cr, &color);
      cairo_rectangle (cr, x, y, width, height);
      cairo_fill (cr);
    }
  else
    {
      cairo_pattern_t *pattern;
      gint n_alphas;
      gint i;

      /* Hardcoded in meta-theme-metacity.c */
      g_assert (spec->type == META_GRADIENT_HORIZONTAL);

      pattern = cairo_pattern_create_linear (0, 0, 1, 0);
      n_alphas = spec->n_alphas;

      for (i = 0; i < n_alphas; i++)
        cairo_pattern_add_color_stop_rgba (pattern, i / (gfloat) (n_alphas - 1),
                                           color.red, color.green, color.blue,
                                           spec->alphas[i] / 255.0);

      if (cairo_pattern_status (pattern) != CAIRO_STATUS_SUCCESS)
        {
          cairo_pattern_destroy (pattern);
          return;
        }

      cairo_save (cr);
      cairo_rectangle (cr, x, y, width, height);

      cairo_translate (cr, x, y);
      cairo_scale (cr, width, height);

      cairo_set_source (cr, pattern);
      cairo_fill (cr);

      cairo_pattern_destroy (pattern);
      cairo_restore (cr);
    }
}

cairo_pattern_t *
meta_alpha_gradient_spec_get_mask (const MetaAlphaGradientSpec *spec)
{
  gint n_alphas;
  cairo_pattern_t *pattern;
  gint i;

  /* Hardcoded in meta-theme-metacity.c */
  g_assert (spec->type == META_GRADIENT_HORIZONTAL);

  n_alphas = spec->n_alphas;
  if (n_alphas == 0)
    return NULL;

  if (n_alphas == 1)
    return cairo_pattern_create_rgba (0, 0, 0, spec->alphas[0] / 255.0);

  pattern = cairo_pattern_create_linear (0, 0, 1, 0);

  for (i = 0; i < n_alphas; i++)
    cairo_pattern_add_color_stop_rgba (pattern, i / (gfloat) (n_alphas - 1),
                                       0, 0, 0, spec->alphas[i] / 255.0);

  if (cairo_pattern_status (pattern) != CAIRO_STATUS_SUCCESS)
    {
      cairo_pattern_destroy (pattern);
      return NULL;
    }

  return pattern;
}