/* EINA - EFL data type library
 * Copyright (C) 2007-2008 Gustavo Sverzut Barbieri, Jorge Luis Zapata Muga
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library;
 * if not, see <http://www.gnu.org/licenses/>.
 */

/* TODO
 * it is possible to have more than one tiler algorithm, but for now the
 * version Gustavo did is hardcoded here
 * http://blog.gustavobarbieri.com.br/2007/06/03/evas-now-using-rectangle-split-and-merge/
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

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

#include "eina_config.h"
#include "eina_private.h"
#include "eina_tiler.h"
#include "eina_cpu.h"

/*============================================================================*
*                                  Local                                     *
*============================================================================*/

/* The splitter data types */
typedef struct list_node list_node_t;
typedef struct list list_t;
typedef struct rect rect_t;
typedef struct rect_node rect_node_t;

struct list_node
{
   struct list_node *next;
};

struct list
{
   struct list_node *head;
   struct list_node *tail;
};

struct rect
{
   int right;
   int bottom;
   int left;
   int top;
   int width;
   int height;
   int area;
};

struct rect_node
{
   struct list_node _lst;
   struct rect rect;
};

typedef struct splitter
{
   Eina_Bool need_merge;
   list_t rects;
} splitter_t;

typedef struct list_node_pool
{
   list_node_t *node;
   int len;
   int max;
} list_node_pool_t;


static const list_node_t list_node_zeroed = { NULL };
static const list_t list_zeroed = { NULL, NULL };
static list_node_pool_t list_node_pool = { NULL, 0, 1024 };


typedef struct _Eina_Iterator_Tiler
{
   Eina_Iterator iterator;
   const Eina_Tiler *tiler;
   list_node_t *curr;
   Eina_Rectangle r;
   EINA_MAGIC
} Eina_Iterator_Tiler;

struct _Eina_Tiler
{
   struct
   {
      int w, h;
   } tile;

   struct
   {
      Eina_Rectangle add, del;
   } last;
   Eina_Rectangle area;
   EINA_MAGIC
   splitter_t splitter;

   Eina_Bool rounding : 1;
   Eina_Bool strict : 1;
};

#define EINA_MAGIC_CHECK_TILER(d, ...)                                  \
  do {                                                                  \
     if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_TILER))                        \
       {                                                                \
          EINA_MAGIC_FAIL(d, EINA_MAGIC_TILER);                         \
          return __VA_ARGS__;                                           \
       }                                                                \
  } while(0)


#define EINA_MAGIC_CHECK_TILER_ITERATOR(d, ...)                    \
  do {                                                             \
     if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_TILER_ITERATOR))          \
       {                                                           \
          EINA_MAGIC_FAIL(d, EINA_MAGIC_TILER_ITERATOR);           \
          return __VA_ARGS__;                                      \
       }                                                           \
  } while(0)

/* The Splitter algorithm */
static inline void rect_init(rect_t *r, int x, int y, int w, int h)
{
   r->area = w * h;

   r->left = x;
   r->top = y;

   r->right = x + w;
   r->bottom = y + h;

   r->width = w;
   r->height = h;
}

static inline list_node_t *
rect_list_node_pool_get(void)
{
   if (list_node_pool.node)
     {
        list_node_t *node;

        node = list_node_pool.node;
        list_node_pool.node = node->next;
        list_node_pool.len--;

        return node;
     }
   else
      return malloc(sizeof(rect_node_t));
}


static inline void rect_list_concat(list_t *rects, list_t *other)
{
   if (!other->head)
      return;

   if (rects->tail)
     {
        rects->tail->next = other->head;
        rects->tail = other->tail;
     }
   else
     {
        rects->head = other->head;
        rects->tail = other->tail;
     }

   *other = list_zeroed;
}

static inline void rect_list_append_node(list_t *rects, list_node_t *node)
{
   if (rects->tail)
     {
        rects->tail->next = node;
        rects->tail = node;
     }
   else
     {
        rects->head = node;
        rects->tail = node;
     }
}

static inline void rect_list_append(list_t *rects, const rect_t r)
{
   rect_node_t *rect_node;

   rect_node = (rect_node_t *)rect_list_node_pool_get();
   rect_node->rect = r;
   rect_node->_lst = list_node_zeroed;

   rect_list_append_node(rects, (list_node_t *)rect_node);
}

static inline void rect_list_append_xywh(list_t *rects,
                                         int x,
                                         int y,
                                         int w,
                                         int h)
{
   rect_t r;

   rect_init(&r, x, y, w, h);
   rect_list_append(rects, r);
}

static inline void _calc_intra_rect_area(const rect_t a, const rect_t b,
                                         int *width, int *height)
{
   int max_left, min_right, max_top, min_bottom;

   if (a.left < b.left)
      max_left = b.left;
   else
      max_left = a.left;

   if (a.right < b.right)
      min_right = a.right;
   else
      min_right = b.right;

   *width = min_right - max_left;

   if (a.top < b.top)
      max_top = b.top;
   else
      max_top = a.top;

   if (a.bottom < b.bottom)
      min_bottom = a.bottom;
   else
      min_bottom = b.bottom;

   *height = min_bottom - max_top;
}

static inline void _split_strict(list_t *dirty, const rect_t current, rect_t r)
{
   int h_1, h_2, w_1, w_2;

   h_1 = current.top - r.top;
   h_2 = r.bottom - current.bottom;
   w_1 = current.left - r.left;
   w_2 = r.right - current.right;

   if (h_1 > 0)
     {
        /*    .--.r (b)                .---.r2
         *    |  |                     |   |
         *  .-------.cur (a) .---.r    '---'
         *  | |  |  |     -> |   |   +
         *  | `--'  |        `---'
         *  `-------'
         */
        rect_list_append_xywh(dirty, r.left, r.top, r.width, h_1);
        r.height -= h_1;
        r.top = current.top;
     }

   if (h_2 > 0)
     {
        /*  .-------.cur (a)
         *  | .---. |        .---.r
         *  | |   | |    ->  |   |
         *  `-------'        `---'   +  .---.r2
         *    |   |                     |   |
         *    `---'r (b)                `---'
         */
        rect_list_append_xywh(dirty, r.left, current.bottom, r.width,
                              h_2);
        r.height -= h_2;
     }

   if (w_1 > 0)
      /* (b) r  .----.cur (a)
       *     .--|-.  |      .--.r2   .-.r
       *     |  | |  |  ->  |  |   + | |
       *     `--|-'  |      `--'     `-'
       *        `----'
       */
        rect_list_append_xywh(dirty, r.left, r.top, w_1, r.height);  /* not necessary to keep these, r (b) will be destroyed */

   /* r.width -= w_1; */
   /* r.left = current.left; */

   if (w_2 > 0)
      /*  .----.cur (a)
       *  |    |
       *  |  .-|--.r (b)  .-.r   .--.r2
       *  |  | |  |    -> | |  + |  |
       *  |  `-|--'       `-'    `--'
       *  `----'
       */
        rect_list_append_xywh(dirty, current.right, r.top, w_2,
                            r.height);  /* not necessary to keep this, r (b) will be destroyed */

   /* r.width -= w_2; */
}

static inline void _calc_intra_outer_rect_area(const rect_t a, const rect_t b,
                                               rect_t *intra, rect_t *outer)
{
   int min_left, max_left, min_right, max_right;
   int min_top, max_top, min_bottom, max_bottom;

   if (a.left < b.left)
     {
        max_left = b.left;
        min_left = a.left;
     }
   else
     {
        max_left = a.left;
        min_left = b.left;
     }

   if (a.right < b.right)
     {
        min_right = a.right;
        max_right = b.right;
     }
   else
     {
        min_right = b.right;
        max_right = a.right;
     }

   intra->left = max_left;
   intra->right = min_right;
   intra->width = min_right - max_left;

   outer->left = min_left;
   outer->right = max_right;
   outer->width = max_right - min_left;

   if (a.top < b.top)
     {
        max_top = b.top;
        min_top = a.top;
     }
   else
     {
        max_top = a.top;
        min_top = b.top;
     }

   if (a.bottom < b.bottom)
     {
        min_bottom = a.bottom;
        max_bottom = b.bottom;
     }
   else
     {
        min_bottom = b.bottom;
        max_bottom = a.bottom;
     }

   intra->top = max_top;
   intra->bottom = min_bottom;
   intra->height = min_bottom - max_top;
   if ((intra->width > 0) && (intra->height > 0))
      intra->area = intra->width * intra->height;
   else
      intra->area = 0;

   outer->top = min_top;
   outer->bottom = max_bottom;
   outer->height = max_bottom - min_top;
   outer->area = outer->width * outer->height;
}

enum
{
   SPLIT_FUZZY_ACTION_NONE,
   SPLIT_FUZZY_ACTION_SPLIT,
   SPLIT_FUZZY_ACTION_MERGE
};

static inline int _split_fuzzy(list_t *dirty, const rect_t a, rect_t *b)
{
   int h_1, h_2, w_1, w_2, action;

   h_1 = a.top - b->top;
   h_2 = b->bottom - a.bottom;
   w_1 = a.left - b->left;
   w_2 = b->right - a.right;

   action = SPLIT_FUZZY_ACTION_NONE;

   if (h_1 > 0)
     {
        /*    .--.r (b)                .---.r2
         *    |  |                     |   |
         *  .-------.cur (a) .---.r    '---'
         *  | |  |  |     -> |   |   +
         *  | `--'  |        `---'
         *  `-------'
         */
        rect_list_append_xywh(dirty, b->left, b->top, b->width, h_1);
        b->height -= h_1;
        b->top = a.top;
        action = SPLIT_FUZZY_ACTION_SPLIT;
     }

   if (h_2 > 0)
     {
        /*  .-------.cur (a)
         *  | .---. |        .---.r
         *  | |   | |    ->  |   |
         *  `-------'        `---'   +  .---.r2
         *    |   |                     |   |
         *    `---'r (b)                `---'
         */
        rect_list_append_xywh(dirty, b->left, a.bottom, b->width, h_2);
        b->height -= h_2;
        action = SPLIT_FUZZY_ACTION_SPLIT;
     }

   if (((w_1 > 0) || (w_2 > 0)) && (a.height == b->height))
      return SPLIT_FUZZY_ACTION_MERGE;

   if (w_1 > 0)
     {
        /* (b)  r  .----.cur (a)
         *      .--|-.  |      .--.r2   .-.r
         *      |  | |  |  ->  |  |   + | |
         *      `--|-'  |      `--'     `-'
         *         `----'
         */
        rect_list_append_xywh(dirty, b->left, b->top, w_1, b->height);
        /* not necessary to keep these, r (b) will be destroyed */
        /* b->width -= w_1; */
        /* b->left = a.left; */
        action = SPLIT_FUZZY_ACTION_SPLIT;
     }

   if (w_2 > 0)
     {
        /* .----.cur (a)
         * |    |
         * |  .-|--.r (b)  .-.r   .--.r2
         * |  | |  |    -> | |  + |  |
         * |  `-|--'       `-'    `--'
         * `----'
         */
        rect_list_append_xywh(dirty, a.right, b->top, w_2, b->height);
        /* not necessary to keep these, r (b) will be destroyed */
        /* b->width -= w_2; */
        action = SPLIT_FUZZY_ACTION_SPLIT;
     }

   return action;
}

#if 0
static void rect_list_node_pool_set_max(int max)
{
   int diff;

   diff = list_node_pool.len - max;
   for (; diff > 0 && list_node_pool.node != NULL; diff--)
     {
        list_node_t *node;

        node = list_node_pool.node;
        list_node_pool.node = node->next;
        list_node_pool.len--;

        free(node);
     }

   list_node_pool.max = max;
}
#endif

static void rect_list_node_pool_flush(void)
{
   while (list_node_pool.node)
     {
        list_node_t *node;

        node = list_node_pool.node;
        list_node_pool.node = node->next;
        list_node_pool.len--;

        free(node);
     }
}



static inline void rect_list_node_pool_put(list_node_t *node)
{
   if (list_node_pool.len < list_node_pool.max)
     {
        node->next = list_node_pool.node;
        list_node_pool.node = node;
        list_node_pool.len++;
     }
   else
        free(node);
}

#if 0
static void rect_print(const rect_t r)
{
        printf("<rect(%d, %d, %d, %d)>", r.left, r.top, r.width, r.height);
}

static void rect_list_print(const list_t rects)
{
   list_node_t *node;
   int len;

   len = 0;
   for (node = rects.head; node != NULL; node = node->next)
      len++;

        printf("[");
   for (node = rects.head; node != NULL; node = node->next)
     {
        rect_print(((rect_node_t *)node)->rect);
        if (node->next)
          {
                  putchar(',');
             if (len < 4)
                  putchar(' ');
             else
               {
                  putchar('\n');
                  putchar(' ');
               }
          }
     }
   printf("]\n");
}
#endif

static inline list_node_t *
rect_list_unlink_next(list_t *rects, list_node_t *parent_node)
{
   list_node_t *node;

   if (parent_node)
     {
        node = parent_node->next;
        parent_node->next = node->next;
     }
   else
     {
        node = rects->head;
        rects->head = node->next;
     }

   if (rects->tail == node)
      rects->tail = parent_node;

   *node = list_node_zeroed;
   return node;
}

static inline void rect_list_del_next(list_t *rects, list_node_t *parent_node)
{
   list_node_t *node;

   node = rect_list_unlink_next(rects, parent_node);
        rect_list_node_pool_put(node);
}

static void rect_list_clear(list_t *rects)
{
   list_node_t *node;

   node = rects->head;
   while (node)
     {
        list_node_t *aux;

        aux = node->next;
        rect_list_node_pool_put(node);
        node = aux;
     }
   *rects = list_zeroed;
}

static void rect_list_del_split_strict(list_t *rects, const rect_t del_r)
{
   list_t modified = list_zeroed;
   list_node_t *cur_node, *prev_node;

   prev_node = NULL;
   cur_node = rects->head;
   while (cur_node)
     {
        int intra_width, intra_height;
        rect_t current;

        current = ((rect_node_t *)cur_node)->rect;

        _calc_intra_rect_area(del_r, current, &intra_width,
                              &intra_height);
        if ((intra_width <= 0) || (intra_height <= 0))
          {
             /*  .---.current      .---.del_r
              *  |   |             |   |
              *  `---+---.del_r    `---+---.current
              *      |   |             |   |
              *      `---'             `---'
              * no intersection, nothing to do
              */
             prev_node = cur_node;
             cur_node = cur_node->next;
          }
        else if ((intra_width == current.width) && (intra_height
                                                    == current.height))
          {
             /*  .-------.del_r
              *  | .---. |
              *  | |   | |
              *  | `---'current
              *  `-------'
              * current is contained, remove from rects
              */
             cur_node = cur_node->next;
             rect_list_del_next(rects, prev_node);
          }
        else
          {
             _split_strict(&modified, del_r, current);
             cur_node = cur_node->next;
             rect_list_del_next(rects, prev_node);
          }
     }

   rect_list_concat(rects, &modified);
}

#if 0
static void rect_list_add_split_strict(list_t *rects, list_node_t *node)
{
   list_t dirty = list_zeroed;
   list_t new_dirty = list_zeroed;
   list_node_t *cur_node;

   if (!rects->head)
     {
        rect_list_append_node(rects, node);
        return;
     }

        rect_list_append_node(&dirty, node);

   cur_node = rects->head;
   while (dirty.head)
     {
        rect_t current;

        if (!cur_node)
          {
             rect_list_concat(rects, &dirty);
             break;
          }

        current = ((rect_node_t *)cur_node)->rect;

        while (dirty.head)
          {
             int intra_width, intra_height;
             rect_t r;

             r = ((rect_node_t *)dirty.head)->rect;
             _calc_intra_rect_area(r, current, &intra_width,
                                   &intra_height);
             if ((intra_width == r.width) && (intra_height
                                              == r.height))
                /*  .-------.cur
                 *  | .---.r|
                 *  | |   | |
                 *  | `---' |
                 *  `-------'
                 */
                rect_list_del_next(&dirty, NULL);
             else if ((intra_width <= 0) || (intra_height <= 0))
               {
                  /*  .---.cur     .---.r
                   *  |   |        |   |
                   *  `---+---.r   `---+---.cur
                   *      |   |        |   |
                   *      `---'        `---'
                   */
                  list_node_t *tmp;
                  tmp = rect_list_unlink_next(&dirty, NULL);
                  rect_list_append_node(&new_dirty, tmp);
               }
             else
               {
                  _split_strict(&new_dirty, current, r);
                  rect_list_del_next(&dirty, NULL);
               }
          }
        dirty = new_dirty;
        new_dirty = list_zeroed;

        cur_node = cur_node->next;
     }
}
#endif

static list_node_t *
rect_list_add_split_fuzzy(list_t *rects, list_node_t *node, int accepted_error)
{
   list_t dirty = list_zeroed;
   list_node_t *old_last;

   old_last = rects->tail;

   if (!rects->head)
     {
        rect_list_append_node(rects, node);
        return old_last;
     }

        rect_list_append_node(&dirty, node);
   while (dirty.head)
     {
        list_node_t *d_node, *cur_node, *prev_cur_node;
        int keep_dirty;
        rect_t r;

        d_node = rect_list_unlink_next(&dirty, NULL);
        r = ((rect_node_t *)d_node)->rect;

        prev_cur_node = NULL;
        cur_node = rects->head;
        keep_dirty = 1;
        while (cur_node)
          {
             int area, action;
             rect_t current, intra, outer;

             current = ((rect_node_t *)cur_node)->rect;

             _calc_intra_outer_rect_area(r, current, &intra, &outer);
             area = current.area + r.area - intra.area;

             if ((intra.width == r.width) && (intra.height
                                              == r.height))
               {
                  /*  .-------.cur
                   *  | .---.r|
                   *  | |   | |
                   *  | `---' |
                   *  `-------'
                   */
                  keep_dirty = 0;
                  break;
               }
             else if ((intra.width == current.width)
                      && (intra.height == current.height))
               {
                  /* .-------.r
                   * | .---.cur
                   * | |   | |
                   * | `---' |
                   * `-------'
                   */
                  if (old_last == cur_node)
                     old_last = prev_cur_node;

                  cur_node = cur_node->next;
                  rect_list_del_next(rects, prev_cur_node);
               }
             else if ((outer.area - area) <= accepted_error)
               {
                  /* .-----------. bounding box (outer)
                   * |.---. .---.|
                   * ||cur| |r  ||
                   * ||   | |   ||
                   * |`---' `---'|
                   * `-----------'
                   * merge them, remove both and add merged
                   */
                  rect_node_t *n;

                  if (old_last == cur_node)
                     old_last = prev_cur_node;

                  n = (rect_node_t *)rect_list_unlink_next(
                        rects, prev_cur_node);
                  n->rect = outer;
                       rect_list_append_node(&dirty, (list_node_t *)n);

                  keep_dirty = 0;
                  break;
               }
             else if (intra.area <= accepted_error)
               {
                  /*  .---.cur     .---.r
                   *  |   |        |   |
                   *  `---+---.r   `---+---.cur
                   *      |   |        |   |
                   *      `---'        `---'
                   *  no split, no merge
                   */
                  prev_cur_node = cur_node;
                  cur_node = cur_node->next;
               }
             else
               {
                  /* split is required */
                  action = _split_fuzzy(&dirty, current, &r);
                  if (action == SPLIT_FUZZY_ACTION_MERGE)
                    {
/* horizontal merge is possible: remove both, add merged */
                       rect_node_t *n;

                       if (old_last == cur_node)
                          old_last = prev_cur_node;

                       n
                          = (rect_node_t *)rect_list_unlink_next(
                                rects,
                                prev_cur_node);

                       n->rect.left = outer.left;
                       n->rect.width = outer.width;
                       n->rect.right = outer.right;
                       n->rect.area = outer.width * r.height;
                       rect_list_append_node(&dirty,
                                             (list_node_t *)n);
                    }
                  else if (action == SPLIT_FUZZY_ACTION_NONE)
                    {
/*
 * this rect check was totally useless,
 * should never happen
 */
/* prev_cur_node = cur_node; */
/* cur_node = cur_node->next; */
                       printf("Should not get here!\n");
                       abort();
                    }

                  keep_dirty = 0;
                  break;
               }
          }
        if (EINA_UNLIKELY(keep_dirty))
           rect_list_append_node(rects, d_node);
        else
           rect_list_node_pool_put(d_node);
     }

   return old_last;
}

static inline void _calc_outer_rect_area(const rect_t a, const rect_t b,
                                         rect_t *outer)
{
   int min_left, max_right;
   int min_top, max_bottom;

   if (a.left < b.left)
      min_left = a.left;
   else
      min_left = b.left;

   if (a.right < b.right)
      max_right = b.right;
   else
      max_right = a.right;

   outer->left = min_left;
   outer->right = max_right;
   outer->width = max_right - min_left;

   if (a.top < b.top)
      min_top = a.top;
   else
      min_top = b.top;

   if (a.bottom < b.bottom)
      max_bottom = b.bottom;
   else
      max_bottom = a.bottom;

   outer->top = min_top;
   outer->bottom = max_bottom;
   outer->height = max_bottom - min_top;

   outer->area = outer->width * outer->height;
}

static void rect_list_merge_rects(list_t *rects,
                                  list_t *to_merge,
                                  int accepted_error)
{
   while (to_merge->head)
     {
        list_node_t *node, *parent_node;
        rect_t r1;
        int merged;

        r1 = ((rect_node_t *)to_merge->head)->rect;

        merged = 0;
        parent_node = NULL;
        node = rects->head;
        while (node)
          {
             rect_t r2, outer;
             int area;

             r2 = ((rect_node_t *)node)->rect;

             _calc_outer_rect_area(r1, r2, &outer);
             area = r1.area + r2.area; /* intra area is taken as 0 */
             if (outer.area - area <= accepted_error)
               {
                  /*
                   * remove both r1 and r2, create r3
                   * actually r3 uses r2 instance, saves memory
                   */
                  rect_node_t *n;

                  n = (rect_node_t *)rect_list_unlink_next(
                        rects, parent_node);
                  n->rect = outer;
                  rect_list_append_node(to_merge,
                                        (list_node_t *)n);
                  merged = 1;
                  break;
               }

             parent_node = node;
             node = node->next;
          }

        if (!merged)
          {
             list_node_t *n;
             n = rect_list_unlink_next(to_merge, NULL);
                  rect_list_append_node(rects, n);
          }
        else
                  rect_list_del_next(to_merge, NULL);
     }
}

static void rect_list_add_split_fuzzy_and_merge(list_t *rects,
                                                list_node_t *node,
                                                int split_accepted_error,
                                                int merge_accepted_error)
{
   list_node_t *n;

   n = rect_list_add_split_fuzzy(rects, node, split_accepted_error);
   if (n && n->next)
     {
        list_t to_merge;

        /* split list into 2 segments, already merged and to merge */
        to_merge.head = n->next;
        to_merge.tail = rects->tail;
        rects->tail = n;
        n->next = NULL;

        rect_list_merge_rects(rects, &to_merge, merge_accepted_error);
     }
}

static inline void _splitter_new(Eina_Tiler *t)
{
   t->splitter.rects = list_zeroed;
   t->splitter.need_merge = EINA_FALSE;
}

static inline void _splitter_del(Eina_Tiler *t)
{
   rect_list_clear(&t->splitter.rects);
   rect_list_node_pool_flush();
}

static inline void _splitter_tile_size_set(Eina_Tiler *t,
                                           int w EINA_UNUSED,
                                           int h EINA_UNUSED)
{
   /* TODO are w and h used for something? */
   t->splitter.rects = list_zeroed;
}

static inline Eina_Bool _splitter_rect_add(Eina_Tiler *t, Eina_Rectangle *rect)
{
   rect_node_t *rn;

   //printf("ACCOUNTING[1]: add_redraw: %4d,%4d %3dx%3d\n", x, y, w, h);
   if (t->rounding)
     {
        // FIXME: Seems that this trigger overdraw bug in Evas implementation and
        // was disable. Need to investigate.
        rect->x >>= 1;
        rect->y >>= 1;
        rect->w += 2;
        rect->w >>= 1;
        rect->h += 2;
        rect->h >>= 1;
     }

   rn = (rect_node_t *)rect_list_node_pool_get();
   rn->_lst = list_node_zeroed;
   rect_init(&rn->rect, rect->x, rect->y, rect->w, rect->h);
   //printf("ACCOUNTING[2]: add_redraw: %4d,%4d %3dx%3d\n", x, y, w, h);
   //testing on my core2 duo desktop - fuzz of 32 or 48 is best.
   rect_list_add_split_fuzzy_and_merge(&t->splitter.rects,
                                       (list_node_t *)rn,
                                       t->tile.w * t->tile.h,
                                       t->tile.w * t->tile.h);
   return EINA_TRUE;
}

static inline void _splitter_rect_del(Eina_Tiler *t, Eina_Rectangle *rect)
{
   rect_t r;

   if (!t->splitter.rects.head)
      return;

   if (t->rounding)
     {
        rect->x += 1;
        rect->y += 1;
        rect->x >>= 1;
        rect->y >>= 1;
        rect->w -= 1;
        rect->w >>= 1;
        rect->h -= 1;
        rect->h >>= 1;
     }

   if ((rect->w <= 0) || (rect->h <= 0))
      return;

   rect_init(&r, rect->x, rect->y, rect->w, rect->h);
   //fprintf(stderr, "ACCOUNTING: del_redraw: %4d,%4d %3dx%3d\n", x, y, w, h);

   rect_list_del_split_strict(&t->splitter.rects, r);
   t->splitter.need_merge = EINA_TRUE;
   return;
}

static inline void _splitter_clear(Eina_Tiler *t)
{
   rect_list_clear(&t->splitter.rects);
   t->splitter.need_merge = EINA_FALSE;
}
/* end of splitter algorithm */

static Eina_Bool _iterator_next(Eina_Iterator_Tiler *it, void **data)
{
   list_node_t *n;

   for (n = it->curr; n; n = n->next)
     {
        rect_t cur;

        cur = ((rect_node_t *)n)->rect;

        if (it->tiler->rounding)
          {
             it->r.x = cur.left << 1;
             it->r.y = cur.top << 1;
             it->r.w = cur.width << 1;
             it->r.h = cur.height << 1;
          }
        else
          {
             it->r.x = cur.left;
             it->r.y = cur.top;
             it->r.w = cur.width;
             it->r.h = cur.height;             
          }

        if (eina_rectangle_intersection(&it->r, &it->tiler->area) == EINA_FALSE)
           continue;

        if ((it->r.w <= 0) || (it->r.h <= 0))
           continue;

        it->curr = n->next;
        *(Eina_Rectangle **)data = &it->r;
        return EINA_TRUE;
     }
   return EINA_FALSE;
}

static void *_iterator_get_container(Eina_Iterator_Tiler *it)
{
   EINA_MAGIC_CHECK_TILER_ITERATOR(it, NULL);
   return (void *)it->tiler;
}

static void _iterator_free(Eina_Iterator_Tiler *it)
{
   EINA_MAGIC_CHECK_TILER_ITERATOR(it);
   free(it);
}

/*============================================================================*
*                                 Global                                     *
*============================================================================*/

/*============================================================================*
*                                   API                                      *
*============================================================================*/

EAPI Eina_Tiler *eina_tiler_new(int w, int h)
{
   Eina_Tiler *t;

   EINA_SAFETY_ON_TRUE_RETURN_VAL((w <= 0) || (h <= 0), NULL);

   t = calloc(1, sizeof(Eina_Tiler));
   t->last.add.w = -1;
   t->last.add.h = -1;
   t->last.del.w = -1;
   t->last.del.h = -1;
   t->area.w = w;
   t->area.h = h;
   t->tile.w = 32;
   t->tile.h = 32;
   t->rounding = EINA_TRUE;
   EINA_MAGIC_SET(t, EINA_MAGIC_TILER);
   _splitter_new(t);
   return t;
}

EAPI void eina_tiler_free(Eina_Tiler *t)
{
   if (!t)
     return;

   EINA_MAGIC_CHECK_TILER(t);
   _splitter_del(t);
   free(t);
}

EAPI void eina_tiler_area_size_set(Eina_Tiler *t, int w, int h)
{
   EINA_MAGIC_CHECK_TILER(t);
   if ((w <= 0) || (h <= 0))
     return;

   t->area.w = w;
   t->area.h = h;
}

EAPI void eina_tiler_area_size_get(const Eina_Tiler *t, int *w, int *h)
{
   EINA_MAGIC_CHECK_TILER(t);
   if (w) *w = t->area.w;
   if (h) *h = t->area.h;
}

EAPI void eina_tiler_tile_size_set(Eina_Tiler *t, int w, int h)
{
   EINA_MAGIC_CHECK_TILER(t);
   if ((w <= 0) || (h <= 0))
      return;
   if ((t->tile.w == w) && (t->tile.h == h)) return;

   if (w == 1 || h == 1) t->rounding = EINA_FALSE;
   t->tile.w = w;
   t->tile.h = h;
   _splitter_tile_size_set(t, w, h);
}

EAPI Eina_Bool
eina_tiler_empty(const Eina_Tiler *t)
{
   EINA_MAGIC_CHECK_TILER(t, EINA_TRUE);
   return ((!t->splitter.rects.head) && (!t->splitter.rects.tail));
}

typedef struct _Rectangle_Same
{
   unsigned long long x, y;
} Rectangle_Same;

static inline Eina_Bool
_rect_same(Eina_Rectangle *rec1, Eina_Rectangle *rec2)
{
   // this is ok because all the rects being compared will be aligned to 8bytes
   Rectangle_Same *same1 = (Rectangle_Same *)rec1;
   Rectangle_Same *same2 = (Rectangle_Same *)rec2;
   return ((same1->x == same2->x) && (same1->y == same2->y));
}

EAPI Eina_Bool eina_tiler_rect_add(Eina_Tiler *t, const Eina_Rectangle *r)
{
   Eina_Rectangle tmp __attribute__ ((aligned (8)));

   EINA_MAGIC_CHECK_TILER(t, EINA_FALSE);
   EINA_SAFETY_ON_NULL_RETURN_VAL(r, EINA_FALSE);

   if ((r->w <= 0) || (r->h <= 0))
      return EINA_FALSE;

   tmp = *r;
   if (eina_rectangle_intersection(&tmp, &t->area) == EINA_FALSE)
      return EINA_FALSE;

   if ((tmp.w <= 0) || (tmp.h <= 0))
      return EINA_FALSE;

   if (_rect_same(&tmp, &t->last.add))
      return EINA_TRUE;

   t->last.add = tmp;
   t->last.del.w = t->last.del.h = -1;

   return _splitter_rect_add(t, &tmp);
}

EAPI void eina_tiler_rect_del(Eina_Tiler *t, const Eina_Rectangle *r)
{
   Eina_Rectangle tmp __attribute__ ((aligned (8)));

   EINA_MAGIC_CHECK_TILER(t);
   EINA_SAFETY_ON_NULL_RETURN(r);

   if ((r->w <= 0) || (r->h <= 0))
      return;

   tmp = *r;
   if (eina_rectangle_intersection(&tmp, &t->area) == EINA_FALSE)
      return;

   if ((tmp.w <= 0) || (tmp.h <= 0))
      return;

   if (_rect_same(&tmp, &t->last.del))
      return;

   t->last.del = tmp;
   t->last.add.w = t->last.add.h = -1;

   _splitter_rect_del(t, &tmp);
}

EAPI void eina_tiler_clear(Eina_Tiler *t)
{
   EINA_MAGIC_CHECK_TILER(t);
   _splitter_clear(t);
   t->last.add.w = -1;
   t->last.add.h = -1;
   t->last.del.w = -1;
   t->last.del.h = -1;
}

EAPI void
eina_tiler_strict_set(Eina_Tiler *t, Eina_Bool strict)
{
   EINA_MAGIC_CHECK_TILER(t);
   t->strict = strict;
}

EAPI Eina_Iterator *eina_tiler_iterator_new(const Eina_Tiler *t)
{
   Eina_Iterator_Tiler *it;

   if (!t) return NULL;

   EINA_MAGIC_CHECK_TILER(t, NULL);

   it = calloc(1, sizeof (Eina_Iterator_Tiler));
   if (!it)
      return NULL;

   it->tiler = t;

   if (t->splitter.need_merge == EINA_TRUE)
     {
        splitter_t *sp;
        list_t to_merge;

        to_merge = t->splitter.rects;
        if (t->strict)
          {
             rect_node_t *rn;
             list_node_t *n;

             // round up rects to tb->tile_size.w and tb->tile_size.h
             to_merge = list_zeroed;
             for (n = t->splitter.rects.head; n; n = n->next)
               {
                  int x1, x2, y1, y2;

                  x1 = ((rect_node_t *)n)->rect.left;
                  x2 = x1 + ((rect_node_t *)n)->rect.width;
                  y1 = ((rect_node_t *)n)->rect.top;
                  y2 = y1 + ((rect_node_t *)n)->rect.height;
                  x1 = t->tile.w * (x1 / t->tile.w);
                  y1 = t->tile.h * (y1 / t->tile.h);
                  x2 = t->tile.w * ((x2 + t->tile.w - 1) / t->tile.w);
                  y2 = t->tile.h * ((y2 + t->tile.h - 1) / t->tile.h);

                  rn = (rect_node_t *)rect_list_node_pool_get();
                  rn->_lst = list_node_zeroed;
                  rect_init(&rn->rect, x1, y1, x2 - x1, y2 - y1);
                  rect_list_add_split_fuzzy_and_merge(&to_merge,
                                                      (list_node_t *)rn,
                                                      t->tile.w * t->tile.h,
                                                      t->tile.w * t->tile.h);
               }
          }

        sp = (splitter_t *)&(t->splitter);
        sp->rects = list_zeroed;
        rect_list_merge_rects(&sp->rects, &to_merge, t->tile.w * t->tile.h);
        sp->need_merge = 0;
     }

   it->curr = it->tiler->splitter.rects.head;
   if (!it->tiler->splitter.rects.head)
     {
        free(it);
        return NULL;
     }

   it->iterator.version = EINA_ITERATOR_VERSION;
   it->iterator.next = FUNC_ITERATOR_NEXT(_iterator_next);
   it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(
         _iterator_get_container);
   it->iterator.free = FUNC_ITERATOR_FREE(_iterator_free);

   EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
   EINA_MAGIC_SET(it,            EINA_MAGIC_TILER_ITERATOR);

   return &it->iterator;
}

EAPI Eina_Bool
eina_tiler_union(Eina_Tiler *dst,
                 Eina_Tiler *src)
{
   Eina_Iterator *itr;
   Eina_Rectangle *rect, _rect;

   if ((!src) || (!dst))
     return EINA_FALSE;

   EINA_MAGIC_CHECK_TILER(src, EINA_FALSE);
   EINA_MAGIC_CHECK_TILER(dst, EINA_FALSE);

   if ((src->area.w <= 0) || (src->area.h <=0))
     return EINA_FALSE;

   dst->area.w = MAX(src->area.w, dst->area.w);
   dst->area.h = MAX(src->area.h, dst->area.h);

   itr = eina_tiler_iterator_new(src);
   if (!itr)
     return EINA_FALSE;

   EINA_ITERATOR_FOREACH(itr, rect)
     {
        _rect = *rect;
        if (src->rounding)
          {
             _rect.w -= 1;
             _rect.h -= 1;
          }
        _splitter_rect_add(dst, &_rect);
     }

   if (rect)
     dst->last.add = *rect;

   eina_iterator_free(itr);

   return EINA_TRUE;
}

EAPI Eina_Bool
eina_tiler_subtract(Eina_Tiler *dst,
                    Eina_Tiler *src)
{
   Eina_Iterator *itr;
   Eina_Rectangle *rect, _rect;

   if ((!src) || (!dst))
     return EINA_FALSE;

   EINA_MAGIC_CHECK_TILER(src, EINA_FALSE);
   EINA_MAGIC_CHECK_TILER(dst, EINA_FALSE);

   if ((src->area.w <= 0) || (src->area.h <= 0))
     return EINA_FALSE;

   itr = eina_tiler_iterator_new(src);
   if (!itr)
     return EINA_FALSE;

   EINA_ITERATOR_FOREACH(itr, rect)
     {
        _rect = *rect;
        if (src->rounding)
          {
             _rect.w -= 1;
             _rect.h -= 1;
          }
        _splitter_rect_del(dst, &_rect);
     }

   if (rect)
     dst->last.del = *rect;

   eina_iterator_free(itr);

   return EINA_TRUE;
}

EAPI Eina_Tiler *
eina_tiler_intersection(Eina_Tiler *t1,
                        Eina_Tiler *t2)
{
   Eina_Tiler *t = NULL;
   int w, h;

   Eina_Iterator *itr1 = NULL, *itr2 = NULL;
   Eina_Rectangle rect, *rect1 = NULL, *rect2 = NULL;

   EINA_MAGIC_CHECK_TILER(t1, NULL);
   EINA_MAGIC_CHECK_TILER(t2, NULL);

   if (!(eina_rectangles_intersect(&t1->area, &t2->area)))
     return NULL;

   itr1 = eina_tiler_iterator_new(t1);
   itr2 = eina_tiler_iterator_new(t2);

   if (!((itr1) && (itr2)))
     goto cleanup;

   if ((!eina_iterator_next(itr1, (void**)(void*)(&rect1))) && (!rect1))
     goto cleanup;
   if ((!eina_iterator_next(itr2, (void**)(void*)(&rect2))) && (!rect2))
     goto cleanup;

   w = MIN(t1->area.w, t2->area.w);
   h = MIN(t1->area.h, t2->area.h);
   t = eina_tiler_new(w, h);

   while((rect1) && (rect2))
     {
        if (eina_rectangles_intersect(rect1, rect2))
          {
             rect.x = MAX(rect1->x, rect2->x);
             rect.y = MAX(rect1->y, rect2->y);
             rect.w = MIN(rect1->x + rect1->w, rect2->x + rect2->w) - rect.x;
             rect.h = MIN(rect1->y + rect1->h, rect2->y + rect2->h) - rect.y;

             if ((t1->rounding) || (t2->rounding))
               {
                  rect.w -= 1;
                  rect.h -= 1;
               }

             _splitter_rect_add(t, &rect);

             t->last.add = rect;
          }

        if (rect1->x + rect1->w  < rect2->x + rect2->w)
          {
             if(eina_iterator_next(itr1, (void**)&rect1))
               continue;
          }
        else if (rect1->x + rect1->w > rect2->x + rect2->w)
          {
             if (eina_iterator_next(itr2, (void**)&rect2))
               continue;
          }

        if (eina_iterator_next(itr1, (void**)&rect1))
          continue;
        if (eina_iterator_next(itr2, (void**)&rect2))
          continue;

        break;
     }

   if (eina_tiler_empty(t))
     {
        eina_tiler_free(t);
        t = NULL;
     }

cleanup:
   eina_iterator_free(itr1);
   eina_iterator_free(itr2);

   return t;
}

EAPI Eina_Bool
eina_tiler_equal(const Eina_Tiler *t1,
                 const Eina_Tiler *t2)
{
   Eina_Iterator  *itr1 = NULL, *itr2 = NULL;
   Eina_Rectangle *rect1 = NULL, *rect2 = NULL;
   Eina_Bool      next_t1 = EINA_FALSE, next_t2 = EINA_FALSE;
   Eina_Bool r = EINA_FALSE;

   EINA_MAGIC_CHECK_TILER(t1, EINA_FALSE);
   EINA_MAGIC_CHECK_TILER(t2, EINA_FALSE);

   if (!(eina_rectangles_intersect(&t1->area, &t2->area)))
     return EINA_FALSE;

   itr1 = eina_tiler_iterator_new(t1);
   itr2 = eina_tiler_iterator_new(t2);

   if (!((itr1) && (itr2)))
     goto cleanup;

   if ((!eina_iterator_next(itr1, (void**)(void*)(&rect1))) && (!rect1))
     goto cleanup;
   if ((!eina_iterator_next(itr2, (void**)(void*)(&rect2))) && (!rect2))
     goto cleanup;

   while((rect1) && (rect2))
     {
        if (!eina_rectangles_intersect(rect1, rect2))
          goto cleanup;

        if ((rect1->x != rect2->x) || (rect1->y != rect2->y) ||
            (rect1->w != rect2->w) || (rect1->h != rect2->h))
          goto cleanup;

        next_t1 = eina_iterator_next(itr1, (void**)&rect1);
        next_t2 = eina_iterator_next(itr2, (void**)&rect2);

        if (next_t1 != next_t2)
          goto cleanup;

        if (!next_t1 && !next_t2)
          break;
     }

   r = EINA_TRUE;

cleanup:
   eina_iterator_free(itr1);
   eina_iterator_free(itr2);

   return r;
}

struct _Eina_Tile_Grid_Slicer_Iterator
{
   Eina_Iterator iterator;
   Eina_Tile_Grid_Slicer priv;
};

typedef struct _Eina_Tile_Grid_Slicer_Iterator Eina_Tile_Grid_Slicer_Iterator;

static void
eina_tile_grid_slicer_iterator_free(Eina_Tile_Grid_Slicer_Iterator *it)
{
   EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_NONE);
   free(it);
}

static Eina_Bool
eina_tile_grid_slicer_iterator_next(Eina_Tile_Grid_Slicer_Iterator *it,
                                    void **data)
{
   return eina_tile_grid_slicer_next
             (&it->priv, (const Eina_Tile_Grid_Info **)data);
}

EAPI Eina_Iterator *
eina_tile_grid_slicer_iterator_new(int x,
                                   int y,
                                   int w,
                                   int h,
                                   int tile_w,
                                   int tile_h)
{
   Eina_Tile_Grid_Slicer_Iterator *it;

   if ((x < 0) || (y < 0) || (w <= 0) || (h <= 0) || 
       (tile_w <= 0) || (tile_h <= 0))
     return NULL;

   it = calloc(1, sizeof(*it));
   if (!it) return NULL;

   EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);

   it->iterator.version = EINA_ITERATOR_VERSION;
   it->iterator.next = FUNC_ITERATOR_NEXT(eina_tile_grid_slicer_iterator_next);
   it->iterator.free = FUNC_ITERATOR_FREE(eina_tile_grid_slicer_iterator_free);

   eina_tile_grid_slicer_setup(&it->priv, x, y, w, h, tile_w, tile_h);

   return &it->iterator;
}