#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;
}