#include <string.h>

#include <stdlib.h>

#include <cairo.h>

#include <ccss-cairo/ccss-cairo.h>

#include <gtk/gtk.h>

/* ================================================================ */

/* Our little hierarchy */

typedef enum _CopperClasses {

  CC_FRAME,

  CC_CONTENT, CC_TITLEBAR,

  CC_MENU, CC_TITLE, CC_MINIMIZE, CC_MAXIMIZE, CC_CLOSE,

  CC_FILLER,

  CC_LAST

} CopperClasses;

char *names[] =

  {

    "frame",

    "area", "area",

    "button", "title", "button", "button", "button",

    "area",

    "last"

  };

CopperClasses parents[] =

  {

    CC_LAST,

    CC_FRAME, CC_FRAME,

    CC_TITLEBAR, CC_TITLEBAR, CC_TITLEBAR, CC_TITLEBAR, CC_TITLEBAR,

    CC_TITLEBAR,

    CC_LAST

  };

char *copper_classnames[] =

  {

    NULL,

    "content", "titlebar",

    "menu", NULL, "minimize", "maximize", "close",

    "filler",

    NULL

  };

typedef struct

{

  ccss_node_t basic;

  CopperClasses copper_class;

} CopperNode;

CopperNode copper_nodes[CC_LAST];

static char const*

get_type (ccss_node_t const *self)

{

  g_warning ("It's %s", self->type_name);

  return self->type_name;

}

static ptrdiff_t

get_instance (ccss_node_t const *self)

{

  return self->instance;

}

static char const*

get_style (ccss_node_t const *self) {

  return self->inline_style;

}

static ccss_node_t*

get_container (ccss_node_t const *self)

{

  CopperClasses candidate = parents[((CopperNode*)self)->copper_class];

  if (candidate==CC_LAST)

    return NULL;

  else

    /* or should we allocate a new one? */

    return (ccss_node_t*) &(copper_nodes[candidate]);

}

static const char*

get_class (ccss_node_t const *self)

{

  return copper_classnames[((CopperNode*)self)->copper_class];

}

static ccss_node_class_t copper_node_class = {

  .get_type               = (ccss_node_get_type_f) get_type,

  .get_instance           = (ccss_node_get_instance_f) get_instance,

  .get_style              = (ccss_node_get_style_f) get_style,

  .get_container          = (ccss_node_get_container_f) get_container,

  .get_class              = (ccss_node_get_class_f) get_class

};

static void

initialise_classes (void)

{

  int i;

  for (i=0; i<CC_LAST; i++)

    {

      ccss_node_init ((ccss_node_t*) &copper_nodes[i], &copper_node_class);

      copper_nodes[i].basic.type_name = names[i];

      copper_nodes[i].basic.instance = 0;

      copper_nodes[i].basic.inline_style = NULL;

      copper_nodes[i].copper_class = i;

    }

}

/* ================================================================ */

static gboolean

get_number_from_style (ccss_style_t *style,

		       char *element,

		       int *dummy,

		       int *original_value)

{

  double d = 0.0;

  gboolean result;

  result = ccss_style_get_double (style, element, &d);

  if (original_value)

    *original_value = d;

  return result;

}

static void

reduce_by_padding_borders_and_margins (ccss_stylesheet_t *stylesheet,

				       CopperClasses style_id,

				       int *x, int *y, int *w, int *h,

				       gboolean honour_margins,

				       gboolean reverse)

{

  ccss_style_t *style = ccss_stylesheet_query (stylesheet,

					       (ccss_node_t*) &copper_nodes[style_id]);

  int bt=0, br=0, bb=0, bl=0, pt=0, pr=0, pb=0, pl=0;

  if (!style) return;

  /* FIXME this is silly; libccss should do this for us */

  /* FIXME maybe it does if we get the property rather than the number */

  if (get_number_from_style (style, "border-width",    NULL, &bl))

    {

      bt = br = bb = bl;

    }

  else

    {

      get_number_from_style (style, "border-top-width",     NULL, &bt);

      get_number_from_style (style, "border-right-width",   NULL, &br);

      get_number_from_style (style, "border-bottom-width",  NULL, &bb);

      get_number_from_style (style, "border-left-width",    NULL, &bl);

    }

  if (get_number_from_style (style, "padding",    NULL, &pl))

    {

      pt = pr = pb = pl;

    }

  else

    {

      get_number_from_style (style, "padding-top",          NULL, &pt);

      get_number_from_style (style, "padding-right",        NULL, &pr);

      get_number_from_style (style, "padding-bottom",       NULL, &pb);

      get_number_from_style (style, "padding-left",         NULL, &pl);

    }

  /* FIXME honour honour_margins */

  bt += pt;

  br += pr;

  bb += pb;

  bl += pl;

  if (reverse)

    {

      if (x) *x -= bl;

      if (y) *y -= bt;

      if (w) *w += (bl+br);

      if (h) *h += (bt+bb);

    }

  else

    {

      if (x) *x += bl;

      if (y) *y += bt;

      if (w) *w -= (bl+br);

      if (h) *h -= (bt+bb);

    }

  ccss_style_destroy (style);

}

static gint

draw_rectangle (ccss_stylesheet_t *stylesheet,

		cairo_t *cr,

		CopperClasses style_id,

		int x, int y, int w, int h,

		gboolean honour_margins,

		gboolean from_the_right,

		PangoLayout *layout)

{

  ccss_style_t *style = ccss_stylesheet_query (stylesheet,

					       (ccss_node_t*) &copper_nodes[style_id]);

  int full_width;

  int horizontal_margin = 0;

  if (!style) return 0;

  if (honour_margins)

    {

      int mn, mt, mr, mb, ml;

      /* FIXME: Setting just "margin" doesn't work

       * because libccss doesn't know about margins.

       */

      get_number_from_style (style, "margin",              NULL, &mn);

      if (mn)

	{

	  /* FIXME this is broken; "margin" may have multiple values */

	  mt = mr = mb = ml = mn;

	}

      else

	{

	  get_number_from_style (style, "margin-top",          NULL, &mt);

	  get_number_from_style (style, "margin-right",        NULL, &mr);

	  get_number_from_style (style, "margin-bottom",       NULL, &mb);

	  get_number_from_style (style, "margin-left",         NULL, &ml);

	}

      x += ml;

      y += mt;

      horizontal_margin = ml+mr;

      h -= (mt+mb);

    }

  if (w==0)

    {

      int height, width;

      get_number_from_style (style, "height", NULL, &height);

      get_number_from_style (style, "width",  NULL, &width);

      if (height!=0 && width!=0)

	{

	  int min_w, max_w;

	  double scale = ((double)h/(double)height);

	  w = (int) ((double)width) * scale;

	  get_number_from_style (style, "min-width", NULL, &min_w);

	  get_number_from_style (style, "max-width", NULL, &max_w);

	  if (max_w && w>max_w && max_w>min_w) w = max_w;

	  if (w<min_w) w = min_w;

	}

    }

  full_width = w+ horizontal_margin;

  if (from_the_right)

    x -= full_width;

  ccss_cairo_style_draw_rectangle (style, cr, x, y, w, h);

  if (layout)

    {

      reduce_by_padding_borders_and_margins (stylesheet, CC_TITLE,

					     &x, &y, &w, &h,

					     TRUE, FALSE);

      /*

       * we should maybe undo the translate later, but

       * we're always the last one to use this context anyway

       */

      cairo_translate (cr, x, y);

      pango_cairo_show_layout (cr, layout);

    }

  ccss_style_destroy (style);

  return full_width;

}

static char*

handle_data_url(char *data)

{

  const char* base64 = "base64";

  char *cursor = data;

  const char *base64_cursor = base64;

  gchar *result;

  gsize result_length;

  gchar *md5, *filename, *uri;

  md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5, cursor, -1);

  /* FIXME: here we should check whether it already exists in /tmp

   * and return that if so

   */

  while (*cursor && *cursor!=',')

    {

      if (*base64_cursor)

	{

	  if (*cursor==*base64_cursor)

	    base64_cursor++;

	  else

	    base64_cursor = base64;

	}

      cursor++;

    }

  if (*base64_cursor)

    {

      /* we didn't see "base64" */

      g_warning ("data: URLs must be base64 encoded in this system!");

      g_free (md5);

      return NULL;

    }

  result = g_base64_decode (cursor+1, &result_length);

  /* unfortunately we can't just return the data; libccss requires it

   * to be in a file.

   */

  filename = g_build_filename ("/tmp", md5, NULL);

  g_file_set_contents (filename, result, result_length, NULL);

  uri = g_strdup_printf ("file://%s", filename);

  g_free (filename);

  g_free (result);

  g_free (md5);

  return uri;

}

static char *

url (GSList const	*args,

     void		*user_data)

{

  char *cwd;

  char *path;

  char *uri;

  char *filename = NULL;

  g_return_val_if_fail (args && args->data, NULL);

  filename = (char*) args->data;

  if (strcmp (filename, "wm:icon")==0)

    {

      /* this is magic */

      return g_strdup ("file:///service/website/themecreator.marnanel.org/htdocs/gtk-edit.png");

    }

#if 0

  else if (strncmp (filename, "data:", 5)==0)

    {

      return handle_data_url (filename+5);

    }

#endif

  else if (index (filename, '/') == NULL)

    {

      char *md5, *result;

      md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5, filename, -1);

      result = g_strdup_printf ("file:///service/website/themecreator.marnanel.org/htdocs/w/images/%c/%c%c/%s",

				md5[0], md5[0], md5[1],

				filename);

      g_free (md5);

      return result;

    }

  else

    {

      return g_strdup ("file:///service/website/themecreator.marnanel.org/htdocs/gtk-error.png");

    }

}

static char *

named (GSList const *args, void *user_data)

{

  char *name = NULL;

  if (!name)

    /* fall back to black */

    return g_strdup("#00000000");

  name = args->data;

  g_warning ("Looking up named colour %s", name);

  /* stub: magenta for everything */

  return g_strdup("#FF00FFFF");

}

static ccss_function_t const _functions[] = 

{

  { "url",	url,	NULL },

  { "named",    named,  NULL },

  { NULL }

};

static PangoLayout*

title_text (ccss_stylesheet_t *stylesheet,

	    cairo_t *cr,

	    char *text)

{

  PangoLayout			 *layout;

  PangoAttrList *attrs = NULL;

  ccss_style_t *style = ccss_stylesheet_query (stylesheet,

					       (ccss_node_t*) &copper_nodes[CC_TITLE]);

  char *align;

  ccss_color_t const *colour;

  layout = pango_cairo_create_layout (cr);

  attrs = pango_attr_list_new ();

  /* We have to handle CSS text properties ourselves here because

   * libccss doesn't know how to render them yet.  We don't try

   * to do all the funky effects like shadows and so on,

   * unfortunately.

   */

  if (ccss_style_get_property (style, "color",

			       (const ccss_property_base_t**) &colour))

    {

      pango_attr_list_insert (attrs,

			      pango_attr_foreground_new

			      ((int)65535.0*colour->red,

			       (int)65535.0*colour->green,

			       (int)65535.0*colour->blue));

    }

  /* Alignment */

  if (ccss_style_get_string (style, "text-align", &align))

    {

      if (strcmp (align, "left")==0)

	{

	  pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);

	}

      else if (strcmp (align, "center")==0)

	{

	  pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);

	}

      else if (strcmp (align, "right")==0)

	{

	  pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);

	}

      else

	/* FIXME: "align" contains garbage if it's undefined;

	 * is there an easy way of checking?

	 */

	g_warning ("Unknown alignment: %s", align);

    }

  pango_layout_set_attributes (layout, attrs);

  /* The actual text */

  pango_layout_set_text (layout, text, -1);

  ccss_style_destroy (style);

  return layout;

}

static void

render_copper (cairo_surface_t *surface,

	       ccss_stylesheet_t *stylesheet)

{

  cairo_t *cr = cairo_create (surface);

  int x = 0;

  int y = 0;

  int w = cairo_image_surface_get_width (surface);

  int h = cairo_image_surface_get_height (surface);

  PangoRectangle text_extents;

  int titlebar_height;

  CopperClasses left_buttons[] = {CC_MENU, CC_LAST};

  CopperClasses right_buttons[] = {CC_CLOSE, CC_MAXIMIZE, CC_MINIMIZE, CC_LAST};

  CopperClasses *cursor;

  int leftpos, rightpos;

  PangoLayout *layout = title_text (stylesheet, cr, "Badgers");

  pango_layout_get_pixel_extents (layout, NULL, &text_extents);

  reduce_by_padding_borders_and_margins (stylesheet, CC_TITLE,

					 &text_extents.x, &text_extents.y,

					 &text_extents.width,

					 &text_extents.height,

					 TRUE, TRUE);

  titlebar_height = text_extents.height;

  reduce_by_padding_borders_and_margins (stylesheet, CC_TITLEBAR,

					 NULL, NULL, NULL,

				         &titlebar_height,

					 TRUE, TRUE);

  draw_rectangle (stylesheet, cr, CC_FRAME, x, y, w, h, FALSE, FALSE, NULL);

  reduce_by_padding_borders_and_margins (stylesheet, CC_FRAME, &x, &y, &w, &h, FALSE, FALSE);

  draw_rectangle (stylesheet, cr, CC_TITLEBAR, x, y, w, titlebar_height, TRUE, FALSE, NULL);

  draw_rectangle (stylesheet, cr, CC_CONTENT,  x, y+titlebar_height, w, h-titlebar_height, TRUE, FALSE, NULL);

  h = titlebar_height;

  reduce_by_padding_borders_and_margins (stylesheet, CC_TITLEBAR, &x, &y, &w, &h, TRUE, FALSE);

  cursor = left_buttons;

  leftpos = x;

  while (*cursor != CC_LAST)

    {

      leftpos += draw_rectangle (stylesheet, cr, *cursor, leftpos, y, 0, h, TRUE, FALSE, NULL);

      cursor++;

    }

  cursor = right_buttons;

  rightpos = x+w;

  while (*cursor != CC_LAST)

    {

      rightpos -= draw_rectangle (stylesheet, cr, *cursor,    rightpos, y, 0, h, TRUE, TRUE, NULL);

      cursor++;

    }

  switch (pango_layout_get_alignment (layout))

    {

    case PANGO_ALIGN_LEFT:

      x = leftpos;

      draw_rectangle (stylesheet, cr, CC_FILLER, leftpos+text_extents.width, y,

		      (rightpos-leftpos)-text_extents.width, h, TRUE, FALSE, NULL);

      break;

    case PANGO_ALIGN_CENTER:

      x = leftpos + ((rightpos-leftpos)/2 - text_extents.width);

      draw_rectangle (stylesheet, cr, CC_FILLER, leftpos, y,

		      x-leftpos, h, TRUE, FALSE, NULL);

      draw_rectangle (stylesheet, cr, CC_FILLER, x+text_extents.width, y,

		      rightpos-(x+text_extents.width), h, TRUE, FALSE, NULL);

      break;

    case PANGO_ALIGN_RIGHT:

      x = rightpos - text_extents.width;

      draw_rectangle (stylesheet, cr, CC_FILLER, leftpos, y,

		      rightpos-(leftpos-text_extents.width), h, TRUE, FALSE, NULL);

      break;

    default:

      g_error ("Unknown alignment");

    }

  draw_rectangle (stylesheet, cr, CC_TITLE, x, y, text_extents.width, h, TRUE, FALSE, layout);

  g_object_unref (G_OBJECT (layout));

  cairo_destroy (cr);

}

int

main (int	  argc,

      char	**argv)

{

	ccss_grammar_t		*grammar;

	ccss_stylesheet_t	*stylesheet;

	ccss_style_t		*style;

	cairo_surface_t         *surface;

	int image_width = 800;

	int image_height = 250;

	initialise_classes ();

	surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,

					      image_width,

					      image_height);

	grammar = ccss_cairo_grammar_create ();

	ccss_grammar_add_functions (grammar, _functions);

	stylesheet = ccss_grammar_create_stylesheet_from_file (grammar,

							       argv[1],

							       NULL);

	render_copper (surface, stylesheet);

	ccss_stylesheet_destroy (stylesheet);

	ccss_grammar_destroy (grammar);

	cairo_surface_write_to_png (surface, argv[2]);

	cairo_surface_destroy (surface);

	return EXIT_SUCCESS;

}