/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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/>.
 *
 */

/* Base class for all widgets -- the GUI operates on this class */

#ifndef NUVIE_GUI_GUI_WIDGET_H
#define NUVIE_GUI_GUI_WIDGET_H

#include "ultima/nuvie/gui/gui_status.h"
#include "ultima/nuvie/gui/gui_drag_area.h"
#include "ultima/nuvie/gui/gui_drag_manager.h"
#include "ultima/nuvie/screen/screen.h"
#include "ultima/nuvie/core/events.h"

namespace Ultima {
namespace Nuvie {

typedef GUI_status(*GUI_CallbackProc)(void *data);

class GUI_Widget : public GUI_DragArea {

protected:
	/* A generic pointer to user-specified data for the widget.
	 */
	void *widget_data;

	Screen *screen;
	/* The display surface for the widget */
	Graphics::ManagedSurface *surface;

	int offset_x, offset_y; /* original offsets to parent */

	/* Flag -- whether or not the widget should be freed */
	WIDGET_status status;

	/* should we redraw this widget */
	bool update_display;

	/* the button states for theoretically 3 buttons */
	int pressed[3];

	bool focused;

	Std::list<GUI_Widget *>children;
	GUI_Widget *parent;

	char *errorptr;
	char  errbuf[BUFSIZ];

	GUI_DragManager *gui_drag_manager;

	// SB-X
	/* The time of the last mouse click (SDL_GetTicks()). */
	unsigned int mouseup[3]; /* for 3 buttons */
	unsigned int mousedown[3]; /* waiting for MouseUp */
	bool accept_mouseclick[3]; /* which buttons can be [double]clicked */
	Events::MouseButton delayed_button; /* a MouseClick can be delayed on one button; 0=none */
	Events::MouseButton held_button; /* a MouseDown can be delayed on one button; 0=none */
	bool mouse_moved; /* true if mouse moves while button is pressed */

	bool mouse_over; // initialized here; toggled by GUI

public:
	/* The area covered by the widget */
	Common::Rect area;

	GUI_Widget(void *data);
	GUI_Widget(void *data, int x, int y, int w, int h);
	~GUI_Widget() override;

	int AddWidget(GUI_Widget *widget);

	/* Mark the widget as visible -- this is the default state */
	virtual void Show(void);

	/* Mark the widget as hidden;  no display, no events */
	virtual void Hide(void);

	/* Mark the widget as free, so it will be deleted by the GUI */
	virtual void Delete(void);

	virtual void MoveRelative(int dx, int dy);
	virtual void Move(int32 new_x, int32 new_y);
	void MoveRelativeToParent(int dx, int dy);
	bool has_focus() const {
		return focused;
	}
	void grab_focus();
	virtual void release_focus();
	void moveToFront();
	virtual void PlaceOnScreen(Screen *s, GUI_DragManager *dm, int x, int y);

	virtual WIDGET_status Status(void) const;  /* Reports status to GUI */

	/* Set the bounds of the widget.
	   If 'w' or 'h' is -1, that parameter will not be changed.
	 */
	virtual void SetRect(int x, int y, int w, int h);
	virtual void SetRect(Common::Rect **bounds);

	/* Return the whole area */
	virtual Common::Rect GetRect() {
		return area;
	}

	/* Return the bounds of the widget */
	virtual int X() const {
		return area.left;
	}
	virtual int Y() const {
		return area.top;
	}
	virtual int W() const {
		return area.width();
	}
	virtual int H() const {
		return area.height();
	}

	/* Check to see if a point intersects the bounds of the widget.
	 */
	virtual int HitRect(int x, int y);
	virtual int HitRect(int x, int y, const Common::Rect &rect);

	/* Set the display surface for this widget */
	virtual void SetDisplay(Screen *s);

	/* Show the widget.
	   If the surface needs to be locked, it will be locked
	   before this call, and unlocked after it returns.
	 */
	virtual void Display(bool full_redraw = false);
	void DisplayChildren(bool full_redraw = false);

	/* Redraw the widget and only the widget */
	virtual void Redraw(void);

	/* should this widget be redrawn */
	inline bool needs_redraw() const {
		return update_display;
	}
	/* widget has focus or no widget is focused */
	bool widget_has_focus(); // SB-X

	/* GUI idle function -- run when no events pending */
	virtual GUI_status Idle(void);

	/* Widget event handlers.
	   These functions should return a status telling the GUI whether
	   or not the event should be passed on to other widgets.
	   These are called by the default HandleEvent function.
	*/
	virtual GUI_status KeyDown(const Common::KeyState &key);
	virtual GUI_status KeyUp(Common::KeyState key);
	virtual GUI_status MouseDown(int x, int y, Events::MouseButton button);
	virtual GUI_status MouseUp(int x, int y, Events::MouseButton button);
	virtual GUI_status MouseMotion(int x, int y, uint8 state);
	virtual GUI_status MouseWheel(sint32 x, sint32 y);
	// <SB-X>
	virtual GUI_status MouseEnter(uint8 state);
	virtual GUI_status MouseLeave(uint8 state);
	virtual GUI_status MouseClick(int x, int y, Events::MouseButton button);
	virtual GUI_status MouseDouble(int x, int y, Events::MouseButton button);
	virtual GUI_status MouseDelayed(int x, int y, Events::MouseButton button);
	virtual GUI_status MouseHeld(int x, int y, Events::MouseButton button);
	// </SB-X>

	bool drag_accept_drop(int x, int y, int message, void *data) override;
	void drag_perform_drop(int x, int y, int message, void *data) override;

	/* Main event handler function.
	   This function gets raw SDL events from the GUI.
	 */
	virtual GUI_status HandleEvent(const Common::Event *event);

	/* Returns nullptr if everything is okay, or an error message if not */
	char *Error(void) {
		return errorptr;
	}

	/* yields click state: none, pressed, intermediate */
	inline virtual int ClickState(int button) {
		return pressed[button - 1];
	}

	/* set click state from remote */
	inline virtual void SetClickState(int button, int value) {
		if ((button > 0) && (button <= 3)) pressed[button - 1] = value;
	}

protected:
	/* The constructor, separated out for both access constructors */
	void Init(void *data, int x, int y, int w, int h);

	void setParent(GUI_Widget *widget);

	/* Useful for getting error feedback */
	void SetError(char *fmt, ...) {
		va_list ap;

		va_start(ap, fmt);
		Common::vsprintf_s(errbuf, fmt, ap);
		va_end(ap);
		errorptr = errbuf;
	}

	// SB-X
	void set_accept_mouseclick(bool set, int button = 0);
	void set_mouseup(int set, int button = 0);
	void set_mousedown(int set, int button = 0);
	int get_mouseup(int button) const {
		if (button > 0 && button < 4) return (mouseup[button - 1]);
		else return 0;
	}
	int get_mousedown(int button) const {
		if (button > 0 && button < 4) return (mousedown[button - 1]);
		else return 0;
	}
	void wait_for_mouseclick(int button) {
		if (button >= Events::BUTTON_NONE && button < Events::BUTTON_MIDDLE)
			delayed_button = (Events::MouseButton)button;
	}
	void wait_for_mousedown(int button) {
		if (button >= Events::BUTTON_NONE && button <= Events::BUTTON_MIDDLE)
			held_button = (Events::MouseButton)button;
	}
	virtual GUI_status try_mouse_delayed();
};

} // End of namespace Nuvie
} // End of namespace Ultima

#endif