/** @file
 * @author Edouard DUPIN
 * @copyright 2011, Edouard DUPIN, all right reserved
 * @license APACHE v2.0 (see license file)
 */
#pragma once

#include <vector>
#include <etk/types.h>
#include <etk/math/Vector2D.h>

#include <ewol/debug.h>
#include <ewol/object/Object.h>
#include <gale/Dimension.h>
#include <gale/context/cursor.h>

namespace ewol {
	class Widget;
	namespace widget {
		class Manager;
		class Windows;
	};
	using WidgetShared = ememory::SharedPtr<ewol::Widget>;
	using WidgetWeak = ememory::WeakPtr<ewol::Widget>;
};
#include <gale/context/clipBoard.h>
#include <gale/key/key.h>
#include <gale/context/cursor.h>
#include <ewol/event/Input.h>
#include <ewol/event/Entry.h>
#include <ewol/event/Time.h>
#include <ewol/translate.h>
#include <esignal/ISignal.h>
#include <ewol/DrawProperty.h>
#include <ewol/gravity.h>

#define ULTIMATE_MAX_SIZE  (99999999)

#define DECLARE_WIDGET_FACTORY(className, name) \
	DECLARE_FACTORY(className); \
	static void createManagerWidget(ewol::widget::Manager& _widgetManager) { \
		_widgetManager.addWidgetCreator(name,   []() -> ewol::WidgetShared { \
		                                        	return className::create(); \
		                                        }); \
	}

namespace ewol {
	/**
	 * @not_in_doc
	 */
	// TODO: change position of this ...
	class EventShortCut {
		public:
			std::string message; //!< data link with the event
			gale::key::Special specialKey; //!< special board key
			char32_t unicodeValue; //!< 0 if not used
			enum gale::key::keyboard keyboardMoveValue; //!< ewol::EVENT_KB_MOVE_TYPE_NONE if not used
			EventShortCut() {
				message = "";
				unicodeValue = 0;
				keyboardMoveValue = gale::key::keyboard::unknow;
			};
			virtual ~EventShortCut() { };
	};
	/**
	 * @brief Widget class is the main widget interface, it hase some generic properties: 
	 * :** known his parent
	 * :** Can be display at a special position with a special scale
	 * :** Can get focus
	 * :** Receive Event (keyboard / mouse / ...)
	 * 
	 */
	class Widget : public ewol::Object {
		public: // signals:
			
		public: // properties:
			eproperty::Value<gale::Dimension> propertyMinSize; //!< user define the minimum size of the widget
			eproperty::Value<gale::Dimension> propertyMaxSize; //!< user define the maximum size of the widget
			eproperty::Value<bvec2> propertyExpand; //!< the widget will expand if possible
			eproperty::Value<bvec2> propertyFill; //!< the widget will fill all the space provided by the parrent.
			eproperty::Value<bool> propertyHide; //!< hide a widget on the display
			eproperty::List<enum ewol::gravity> propertyGravity; //!< Gravity of the widget
			eproperty::Value<bool> propertyCanFocus; //!< the focus can be done on this widget
		protected:
			/**
			 * @brief Constructor of the widget classes
			 * @return (no execption generated (not managed in embended platform))
			 */
			Widget();
		public:
			/**
			 * @brief Destructor of the widget classes
			 */
			virtual ~Widget();
		// ----------------------------------------------------------------------------------------------------------------
		// -- Widget size:
		// ----------------------------------------------------------------------------------------------------------------
		protected:
			vec2 m_size; //!< internal: current size of the widget
			vec2 m_minSize; //!< internal: minimum size of the widget
			vec2 m_maxSize; //!< internal: maximum size of the widget
		public:
			/**
			 * @brief convert the absolute position in the local Position (Relative)
			 * @param[in] _pos Absolute position that you request convertion
			 * @return the relative position
			 */
			virtual vec2 relativePosition(const vec2& _pos);
			/**
			 * @brief Parent have set the size and the origin. the container need to update the subwidget property
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual void onChangeSize();
			virtual void calculateSize() {};
			/**
			 * @brief get the widget size
			 * @return Requested size
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual vec2 getSize();
			/**
			 * @brief set the widget size
			 * @return Requested size
			 * @note : INTERNAL EWOL SYSTEM Do not modify the size yourself: calculation is complex and need knowledge of around widget
			 */
			virtual void setSize(const vec2& _value) {
				m_size = _value;
			}
			/**
			 * @brief calculate the minimum and maximum size (need to estimate expend properties of the widget)
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual void calculateMinMaxSize();
			/**
			 * @brief get the widget minimum size calculated
			 * @return Requested size
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual vec2 getCalculateMinSize();
			/**
			 * @brief get the widget maximum size calculated
			 * @return Requested size
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual vec2 getCalculateMaxSize();
		protected:
			vec2 m_offset; //!< Offset of the display in the viewport
		public:
			/**
			 * @brief set the zoom property of the widget.
			 * @param[in] _newVal offset value.
			 */
			virtual void setOffset(const vec2& _newVal);
			/**
			 * @brief get the offset property of the widget.
			 * @return The current offset value.
			 */
			virtual const vec2& getOffset() {
				return m_offset;
			};
		protected:
			// internal element calculated by the system
			float m_zoom; //!< generic widget zoom
		public:
			/**
			 * @brief set the zoom property of the widget
			 * @param[in] _newVal newZoom value
			 */
			virtual void setZoom(float _newVal);
			/**
			 * @brief get the zoom property of the widget
			 * @return the current zoom value
			 */
			virtual float getZoom();
			/**
			 * @brief Change Zoom property.
			 * @param[in] _range Range of the zoom change.
			 */
			virtual void changeZoom(float _range) {};
		protected:
			vec2 m_origin; //!< internal ... I do not really known how if can use it ...
		public:
			/**
			 * @brief set origin at the widget (must be an parrent widget that set this parameter).
			 * This represent the absolute origin in the program windows
			 * @param[in] _pos Position of the origin
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual void setOrigin(const vec2& _pos);
			/**
			 * @brief get the origin (obsolute position in the windows)
			 * @return coordonate of the origin requested
			 */
			virtual vec2 getOrigin();
		public:
			/**
			 * @brief User set No minimum size.
			 */
			void setNoMinSize(); // TODO : Remove ==> default ... of the property
			/**
			 * @brief Check if the current min size is compatible with the user minimum size
			 *        If it is not the user minimum size will overWrite the minimum size set.
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual void checkMinSize();
		protected:
			
		public:
			/**
			 * @brief User set No maximum size.
			 */
			void setNoMaxSize(); // TODO : Remove ==> default ... of the property
			/**
			 * @brief Check if the current max size is compatible with the user maximum size
			 *        If it is not the user maximum size will overWrite the maximum size set.
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual void checkMaxSize();
		public:
			/**
			 * @brief get the expend capabilities (x&y)
			 * @return 2D boolean repensent the capacity to expend
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual bvec2 canExpand();
		public:
			/**
			 * @brief get the filling capabilities x&y
			 * @return bvec2 repensent the capacity to x&y filling
			 * @note : INTERNAL EWOL SYSTEM
			 */
			const bvec2& canFill();
		// ----------------------------------------------------------------------------------------------------------------
		// -- focus Area
		// ----------------------------------------------------------------------------------------------------------------
		private:
			bool m_hasFocus; //!< set the focus on this widget
			
		public:
			/**
			 * @brief get the focus state of the widget
			 * @return focus state
			 */
			virtual bool getFocus() {
				return m_hasFocus;
			};
			/**
			 * @brief set focus on this widget
			 * @return return true if the widget keep the focus
			 */
			virtual bool setFocus();
			/**
			 * @brief remove the focus on this widget
			 * @return return true if the widget have release his focus (if he has it)
			 */
			virtual bool rmFocus();
			/**
			 * @brief keep the focus on this widget  == > this remove the previous focus on all other widget
			 */
			virtual void keepFocus();
		protected:
			/**
			 * @brief Event of the focus has been grep by the current widget
			 */
			virtual void onGetFocus() {};
			/**
			 * @brief Event of the focus has been lost by the current widget
			 */
			virtual void onLostFocus() {};
		
		// ----------------------------------------------------------------------------------------------------------------
		// -- Mouse event properties Area
		// ----------------------------------------------------------------------------------------------------------------
		private:
			int32_t m_limitMouseEvent; //!< this is to limit the number of mouse event that the widget can supported
		public:
			/**
			 * @brief get the number of mouse event supported
			 * @return return the number of event that the mouse supported [0..3]
			 */
			virtual int32_t getMouseLimit() {
				return m_limitMouseEvent;
			};
			/**
			 * @brief get the number of mouse event supported
			 * @param[in] _numberState The number of event that the mouse supported [0..3]
			 */
			virtual void setMouseLimit(int32_t _numberState) {
				m_limitMouseEvent = _numberState;
			};
		// ----------------------------------------------------------------------------------------------------------------
		// -- keyboard event properties Area
		// ----------------------------------------------------------------------------------------------------------------
		private:
			bool m_allowRepeateKeyboardEvent; //!< This remove the repeating keybord event due to the constant pressing key.
		public:
			/**
			 * @brief get the keyboard repeating event supporting.
			 * @return true : the event can be repeated.
			 * @return false : the event must not be repeated.
			 */
			virtual bool getKeyboardRepeate() {
				return m_allowRepeateKeyboardEvent;
			};
		protected:
			/**
			 * @brief set the keyboard repeating event supporting.
			 * @param[in] _state The repeating status (true: enable, false disable).
			 */
			virtual void setKeyboardRepeate(bool _state) {
				m_allowRepeateKeyboardEvent = _state;
			};
			/**
			 * @brief display the virtual keyboard (if needed)
			 */
			virtual void showKeyboard();
			/**
			 * @brief Hide the virtual keyboard (if needed)
			 */
			virtual void hideKeyboard();
		// ----------------------------------------------------------------------------------------------------------------
		// -- periodic call Area
		// ----------------------------------------------------------------------------------------------------------------
		protected:
			// TODO : Remove this API ==> deprecated since 28/10/2014
			esignal::Connection m_periodicCallHandle;
			/**
			 * @brief disable the periodic call.
			 */
			void periodicCallDisable();
			/**
			 * @brief disable the periodic call.
			 */
			void periodicCallEnable();
		public:
			/**
			 * @brief periodic call of this widget
			 * @param _event Current time property
			 */
			virtual void periodicCall(const ewol::event::Time& _event) {
				
			};
		public:
			/**
			 * @brief get the widget at the specific windows absolute position
			 * @param[in] _pos gAbsolute position of the requested widget knowledge
			 * @return nullptr No widget found
			 * @return pointer on the widget found
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual ewol::WidgetShared getWidgetAtPos(const vec2& _pos) {
				if (propertyHide.get() == false) {
					return ememory::dynamicPointerCast<ewol::Widget>(sharedFromThis());
				}
				return nullptr;
			};
		
		// event section:
		public:
			/**
			 * @brief {SYSTEM} system event input (only meta widget might overwrite this function).
			 * @param[in] _event Event properties
			 * @return true the event is used
			 * @return false the event is not used
			 */
			virtual bool systemEventInput(ewol::event::InputSystem& _event);
		protected:
			/**
			 * @brief Event on an input of this Widget (finger, mouse, stilet)
			 * @param[in] _event Event properties
			 * @return true the event is used
			 * @return false the event is not used
			 */
			virtual bool onEventInput(const ewol::event::Input& _event) {
				return false;
			};
		public:
			/**
			 * @brief {SYSTEM} Entry event (only meta widget might overwrite this function).
			 * @param[in] _event Event properties
			 * @return true if the event has been used
			 * @return false if the event has not been used
			 */
			virtual bool systemEventEntry(ewol::event::EntrySystem& _event);
		protected:
			/**
			 * @brief Entry event.
			 *        represent the physical event :
			 *            - Keyboard (key event and move event)
			 *            - Accelerometer
			 *            - Joystick
			 * @param[in] _event Event properties
			 * @return true if the event has been used
			 * @return false if the event has not been used
			 */
			virtual bool onEventEntry(const ewol::event::Entry& _event) {
				return false;
			};
		public:
			/**
			 * @brief Event on a past event  == > this event is asynchronous due to all system does not support direct getting datas
			 * @note : need to have focus ...
			 * @param[in] mode Mode of data requested
			 */
			virtual void onEventClipboard(enum gale::context::clipBoard::clipboardListe _clipboardID) { };
		
		// ----------------------------------------------------------------------------------------------------------------
		// -- Shortcut : management of the shortcut
		// ----------------------------------------------------------------------------------------------------------------
		public:
			esignal::ISignal<std::string> signalShortcut; //!< signal handle of the message
		private:
			std::vector<EventShortCut*> m_localShortcut; //!< list of all shortcut in the widget
		protected:
			/**
			 * @brief add a specific shortcut with his description
			 * @param[in] _descriptiveString Description string of the shortcut
			 * @param[in] _message massage to generate (or shortcut name)
			 */
			virtual void shortCutAdd(const std::string& _descriptiveString,
			                         const std::string& _message="");
			/**
			 * @brief remove all curent shortCut
			 */
			virtual void shortCutClean();
			/**
			 * @brief remove a specific shortCut whith his event name
			 * @param[in] _message renerated event name
			 */
			virtual void shortCutRemove(const std::string& _message);
		public:
			/**
			 * @brief Event on a short-cut of this Widget (in case of return false, the event on the keyevent will arrive in the function @ref onEventKb).
			 * @param[in] _special All the special kay pressed at this time.
			 * @param[in] _unicodeValue Key pressed by the user not used if the kbMove!=ewol::EVENT_KB_MOVE_TYPE_NONE.
			 * @param[in] _kbMove Special key of the keyboard.
			 * @return true if the event has been used.
			 * @return false if the event has not been used.
			 * @note To prevent some error when you get an event get it if it is down and Up ...  == > like this it could not generate some ununderstanding error.
			 */
			virtual bool onEventShortCut(const gale::key::Special& _special,
			                             char32_t _unicodeValue,
			                             enum gale::key::keyboard _kbMove,
			                             bool _isDown);
		// ----------------------------------------------------------------------------------------------------------------
		// -- drawing : All drawing must be done in 2 separate buffer 1 for the current display and 1 for the working...
		// ----------------------------------------------------------------------------------------------------------------
		protected:
			bool m_needRegenerateDisplay; //!< the display might be done the next regeneration
			/**
			 * @brief The widget mark itself that it need to regenerate the nest time.
			 */
			virtual void markToRedraw();
			/**
			 * @brief get the need of the redrawing of the widget and reset it to false
			 * @return true if we need to redraw
			 * @return false if we have no need to redraw
			 */
			virtual bool needRedraw() {
				bool tmpData = m_needRegenerateDisplay;
				m_needRegenerateDisplay = false;
				return tmpData;
			};
		public:
			/**
			 * @brief {SYSTEM} extern interface to request a draw ...  (called by the drawing thread [Android, X11, ...])
			 * This function generate a clipping with the viewport openGL system. Like this a widget draw can not draw over an other widget
			 * @note This function is virtual for the scrolled widget, and the more complicated openGl widget
			 * @param[in] _displayProp properties of the current display
			 * @note : INTERNAL EWOL SYSTEM
			 */
			virtual void systemDraw(const DrawProperty& _displayProp);
		protected:
			/**
			 * @brief Common widget drawing function (called by the drawing thread [Android, X11, ...])
			 */
			virtual void onDraw() { };
		public:
			/**
			 * @brief Event generated when a redraw is needed
			 */
			virtual void onRegenerateDisplay() { };
		// grab cursor mode
		private:
			bool m_grabCursor;
		public:
			/**
			 * @brief Grab the cursor : This get all the mouvement of the mouse in PC mode, and generate an ofset instead of a position.
			 * @note : the generation of the offset is due to the fact the cursor position is forced at the center of the widget.
			 * @note This done nothing in "Finger" or "Stylet" mode.
			 */
			virtual void grabCursor();
			/**
			 * @brief Un-Grab the cursor (default mode cursor offset)
			 */
			virtual void unGrabCursor();
			/**
			 * @brief get the grabbing status of the cursor.
			 * @return true if the cursor is curently grabbed
			 */
			virtual bool getGrabStatus();
		private:
			enum gale::context::cursor m_cursorDisplay;
		public:
			/**
			 * @brief set the cursor display type.
			 * @param[in] _newCursor selected new cursor.
			 */
			virtual void setCursor(enum gale::context::cursor _newCursor);
			/**
			 * @brief get the currrent cursor.
			 * @return the type of the cursor.
			 */
			virtual enum gale::context::cursor getCursor();
		public:
			virtual bool loadXML(const exml::Element& _node) override;
		public:
			/**
			 * @brief need to be call When the size of the current widget have change  ==> this force the system to recalculate all the widget positions
			 */
			void requestUpdateSize();
			/**
			 * @brief get the current Widget Manager
			 */
			ewol::widget::Manager& getWidgetManager();
			/**
			 * @brief get the curent Windows
			 */
			ememory::SharedPtr<ewol::widget::Windows> getWindows();
		/*
		 * Annimation section :
		 */
		public:
			// event generated :
			esignal::ISignal<> signalAnnimationStart; //!< event when start annimation
			esignal::ISignal<float> signalAnnimationRatio; //!< event when % of annimation change (integer)
			esignal::ISignal<> signalAnnimationStop;  //!< event when stop annimation
		protected:
			enum annimationMode {
				annimationModeEnableAdd,
				annimationModeEnableRemove,
				annimationModeDisable
			};
			enum annimationMode m_annimationMode; //!< true when the annimation is started
			float m_annimationratio; //!< Ratio of the annimation [0..1]
		protected:
			eproperty::List<int32_t> propertyAnnimationTypeStart; //!< type of start annimation
			eproperty::Range<float> propertyAnnimationTimeStart; //!< time to produce start annimation
			eproperty::List<int32_t> propertyAnnimationTypeStop; //!< type of start annimation
			eproperty::Range<float> propertyAnnimationTimeStop; //!< time to produce start annimation
		protected:
			/**
			 * @brief Add a annimation type capabilities of this widget.
			 * @param[in] _mode Configuring mode.
			 * @param[in] _type Type of the annimation.
			 */
			void addAnnimationType(enum ewol::Widget::annimationMode _mode, const char* _type);
		public:
			/**
			 * @brief set a annimation type.
			 * @param[in] _mode Configuring mode.
			 * @param[in] _type type of the annimation
			 */
			void setAnnimationType(enum ewol::Widget::annimationMode _mode, const std::string& _type);
			/**
			 * @brief set a annimation time to produce.
			 * @param[in] _mode Configuring mode.
			 * @param[in] _time Time in second of the annimation display
			 */
			void setAnnimationTime(enum ewol::Widget::annimationMode _mode, float _time);
			/**
			 * @brief Start the annimation.
			 * @param[in] _mode Configuring mode.
			 * @return true if an annimation will be started, false ==> no annimation and no event
			 */
			bool startAnnimation(enum ewol::Widget::annimationMode _mode);
			/**
			 * @brief Stop/Break the annimation.
			 * @return true if an annimation will be stoped, false ==> no curent annimation and no event wil be generated
			 */
			bool stopAnnimation();
		protected:
			/**
			 * @brief Event when start the annimation.
			 * @param[in] _mode Configuring mode.
			 * @return true need to add periodic call.
			 */
			virtual bool onStartAnnimation(enum ewol::Widget::annimationMode _mode) {
				return false;
			};
			/**
			 * @brief Event when Stop the annimation.
			 */
			virtual void onStopAnnimation() { };
		protected:
			virtual void onChangePropertyCanFocus();
			virtual void onChangePropertyGravity();
			virtual void onChangePropertyHide();
			virtual void onChangePropertyFill();
			virtual void onChangePropertyExpand();
			virtual void onChangePropertyMaxSize();
			virtual void onChangePropertyMinSize();
	};
};

#include <ewol/widget/Manager.h>