/*
 * 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 3 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/>.
 *
 * Copyright (C) 2009 Martin Nordholts
 */

#include <string.h>

#include "gegl.h"
#include "gegl-utils.h"


#define SUCCESS  0
#define FAILURE -1

#define INFINITE_PLANE G_MININT / 2, G_MININT / 2, G_MAXINT, G_MAXINT

typedef struct
{
  GeglRectangle rect1;
  GeglRectangle rect2;

  GeglRectangle bounding_box_result;

  GeglRectangle intersect_result;
  gboolean      intersect_return_value;

  gboolean      contains_return_value;
} GeglRectangleTestCase;

static GeglRectangleTestCase tests[] =
{
  /* 1 */
  { { INFINITE_PLANE },
    { INFINITE_PLANE },

    { INFINITE_PLANE },

    { INFINITE_PLANE },
    TRUE,

    TRUE },

  /* 2 */
  { { INFINITE_PLANE   },
    { -10, -10, 20, 20 },

    { INFINITE_PLANE   },

    { -10, -10, 20, 20 },
    TRUE,

    TRUE },


  /* 3 */
  { { -10, -10, 20, 20 },
    { INFINITE_PLANE   },

    { INFINITE_PLANE   },

    { -10, -10, 20, 20 },
    TRUE,

    FALSE },


  /* 4 */
  { { -10, -10, 10, 10 },
    {  0,   0,  10, 10 },

    { -10, -10, 20, 20 },

    {  0,   0,  0,  0  },
    FALSE,

    FALSE },


  /* 5 */
  { {  0,   0,  10, 10 },
    { -10, -10, 10, 10 },

    { -10, -10, 20, 20 },

    {  0,   0,  0,  0 },
    FALSE,

    FALSE },


  /* 6 */
  { { -10, -10, 0, 0 },
    {  1,   2,  3, 4 },

    {  1,   2,  3, 4 },

    {  0,   0,  0, 0 },
    FALSE,

    FALSE },


  /* 7 */
  { {  1,   2,  3, 4 },
    { -10, -10, 0, 0 },

    {  1,   2,  3, 4 },

    {  0,   0,  0, 0 },
    FALSE,

    FALSE },


  /* 8 */
  { { G_MININT / 2, G_MININT / 2, 1, 1 },
    { INFINITE_PLANE                   },

    { INFINITE_PLANE                   },

    { G_MININT / 2, G_MININT / 2, 1, 1 },
    TRUE,

    FALSE },


  /* 9 */
  { { G_MAXINT / 2 - 1, G_MAXINT / 2- 1, 1, 1  },
    { INFINITE_PLANE                           },

    { INFINITE_PLANE                           },

    { G_MAXINT / 2 - 1, G_MAXINT / 2 - 1, 1, 1 },
    TRUE,

    FALSE },


  /* 10 */
  { { -5,  -5,  10, 10 },
    {  0,   0,  5,  5  },

    { -5,  -5,  10, 10 },

    {  0,   0,  5,  5  },
    TRUE,

    TRUE },
};

int main(int argc, char *argv[])
{
  GeglRectangle expected_infinite_plane = gegl_rectangle_infinite_plane ();
  GeglRectangle infinite_plane          = { INFINITE_PLANE };
  int           result = SUCCESS;
  int           i      = 0;

  /* Make sure our representation of an infinite plane GeglRectangle
   * is correct
   */
  if (! gegl_rectangle_equal (&infinite_plane, &expected_infinite_plane))
    {
      result = FAILURE;
      g_printerr("This test case and GEGL does not represent an infinite plane\n"
                 "GeglRectangle in the same way, update this test case. Aborting.\n");
      goto abort;
    }

  for (i = 0; i < G_N_ELEMENTS (tests); i++)
    {
      GeglRectangle result_rect;
      gboolean      return_value;

      /* gegl_rectangle_bounding_box() */
      gegl_rectangle_bounding_box (&result_rect,
                                   &tests[i].rect1,
                                   &tests[i].rect2);
      if (! gegl_rectangle_equal (&result_rect, &tests[i].bounding_box_result))
        {
          result = FAILURE;
          g_printerr("The gegl_rectangle_bounding_box() test #%d failed. Aborting.\n", i + 1);
          goto abort;
        }

      /* gegl_rectangle_intersect() */
      return_value = gegl_rectangle_intersect (&result_rect,
                                               &tests[i].rect1,
                                               &tests[i].rect2);
      if (! gegl_rectangle_equal (&result_rect, &tests[i].intersect_result) ||
          return_value != tests[i].intersect_return_value)
        {
          result = FAILURE;
          g_printerr("The gegl_rectangle_intersect() test #%d failed. Aborting.\n", i + 1);
          goto abort;
        }

      /* gegl_rectangle_contains() */
      return_value = gegl_rectangle_contains (&tests[i].rect1,
                                              &tests[i].rect2);
      if (return_value != tests[i].contains_return_value)
        {
          result = FAILURE;
          g_printerr("The gegl_rectangle_contains() test #%d failed. Aborting.\n", i + 1);
          goto abort;
        }
    }

abort:
  return result;
}