/*
 * Copyright (c) 2012 Petr Koupy
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup gui
 * @{
 */
/**
 * @file
 */

#include <assert.h>
#include <mem.h>
#include <malloc.h>
#include <surface.h>

#include "window.h"
#include "grid.h"

static void paint_internal(widget_t *w)
{
	grid_t *grid = (grid_t *) w;

	surface_t *surface = window_claim(grid->widget.window);
	if (!surface) {
		window_yield(grid->widget.window);
	}

	for (sysarg_t y = w->vpos; y <  w->vpos + w->height; ++y) {
		for (sysarg_t x = w->hpos; x < w->hpos + w->width; ++x) {
			surface_put_pixel(surface, x, y, grid->background);
		}
	}

	window_yield(grid->widget.window);
}

static widget_t **widget_at(grid_t *grid, size_t row, size_t col)
{
	if (row < grid->rows && col < grid->cols) {
		return grid->layout + (row * grid->cols + col);
	} else {
		return NULL;
	}
}

void deinit_grid(grid_t *grid)
{
	widget_deinit(&grid->widget);
	free(grid->layout);
}

static void grid_destroy(widget_t *widget)
{
	grid_t *grid = (grid_t *) widget;

	deinit_grid(grid);

	free(grid);
}

static void grid_reconfigure(widget_t *widget)
{
	/* no-op */
}

static void grid_rearrange(widget_t *widget, sysarg_t hpos, sysarg_t vpos,
    sysarg_t width, sysarg_t height)
{
	grid_t *grid = (grid_t *) widget;

	widget_modify(widget, hpos, vpos, width, height);
	paint_internal(widget);

	sysarg_t cell_width = width / grid->cols;
	sysarg_t cell_height = height / grid->rows;

	list_foreach(widget->children, link) {
		widget_t *child = list_get_instance(link, widget_t, link);

		sysarg_t widget_hpos = 0;
		sysarg_t widget_vpos = 0;
		sysarg_t widget_width = 0;
		sysarg_t widget_height = 0;

		size_t r = 0;
		size_t c = 0;
		for (r = 0; r < grid->rows; ++r) {
			bool found = false;
			for (c = 0; c < grid->cols; ++c) {
				widget_t **cell = widget_at(grid, r, c);
				if (cell && *cell == child) {
					found = true;
					break;
				}
			}
			if (found) {
				break;
			}
		}

		widget_hpos = cell_width * c + hpos;
		widget_vpos = cell_height * r + vpos;

		for (size_t _c = c; _c < grid->cols; ++_c) {
			widget_t **cell = widget_at(grid, r, _c);
			if (cell && *cell == child) {
				widget_width += cell_width;
			} else {
				break;
			}
		}

		for (size_t _r = r; _r < grid->rows; ++_r) {
			widget_t **cell = widget_at(grid, _r, c);
			if (cell && *cell == child) {
				widget_height += cell_height;
			} else {
				break;
			}
		}

		if (widget_width > 0 && widget_height > 0) {
			child->rearrange(child,
			    widget_hpos, widget_vpos, widget_width, widget_height);
		}
	}
}

static void grid_repaint(widget_t *widget)
{
	paint_internal(widget);
	list_foreach(widget->children, link) {
		widget_t *child = list_get_instance(link, widget_t, link);
		child->repaint(child);
	}
	window_damage(widget->window);
}

static void grid_handle_keyboard_event(widget_t *widget, kbd_event_t event)
{
	/* no-op */
}

static void grid_handle_position_event(widget_t *widget, pos_event_t event)
{
	grid_t *grid = (grid_t *) widget;

	if ((widget->height / grid->rows) == 0) {
		return;
	}
	if ((widget->width / grid->cols) == 0) {
		return;
	}

	sysarg_t row = (event.vpos - widget->vpos) / (widget->height / grid->rows);
	sysarg_t col = (event.hpos - widget->hpos) / (widget->width / grid->cols);

	widget_t **cell = widget_at(grid, row, col);
	if (cell && *cell) {
		(*cell)->handle_position_event(*cell, event);
	}
}

static void grid_add(grid_t *grid, widget_t *widget,
    size_t row, size_t col, size_t rows, size_t cols)
{
	assert(row + rows <= grid->rows);
	assert(col + cols <= grid->cols);

	widget->parent = (widget_t *) grid;
	list_append(&widget->link, &grid->widget.children);
	widget->window = grid->widget.window;

	for (size_t r = row; r < row + rows; ++r) {
		for (size_t c = col; c < col + cols; ++c) {
			widget_t **cell = widget_at(grid, r, c);
			if (cell) {
				*cell = widget;
			}
		}
	}
}

bool init_grid(grid_t *grid,
    widget_t *parent, size_t rows, size_t cols, pixel_t background)
{
	assert(rows > 0);
	assert(cols > 0);

	widget_t **layout = (widget_t **) malloc(rows * cols * sizeof(widget_t *));
	if (!layout) {
		return false;
	}
	memset(layout, 0, rows * cols * sizeof(widget_t *));

	widget_init(&grid->widget, parent);

	grid->widget.destroy = grid_destroy;
	grid->widget.reconfigure = grid_reconfigure;
	grid->widget.rearrange = grid_rearrange;
	grid->widget.repaint = grid_repaint;
	grid->widget.handle_keyboard_event = grid_handle_keyboard_event;
	grid->widget.handle_position_event = grid_handle_position_event;

	grid->add = grid_add;
	grid->background = background;
	grid->rows = rows;
	grid->cols = cols;
	grid->layout = layout;

	return true;
}

grid_t *create_grid(widget_t *parent, size_t rows, size_t cols, pixel_t background)
{
	grid_t *grid = (grid_t *) malloc(sizeof(grid_t));
	if (!grid) {
		return NULL;
	}

	if (init_grid(grid, parent, rows, cols, background)) {
		return grid;
	} else {
		free(grid);
		return NULL;
	}
}

/** @}
 */