#ifndef	__OD2SRC_GUI_H__
#define	__OD2SRC_GUI_H__	1

/* OD2 - Dune II Clone
 *  
 * Copyright (C) 2009 Robert Crossfield		<robert.crossfield@strobs.com>

 * 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/>.
 *  
 * 
 * $Id$
 * 
 */

template <class cEng> class cButton;

template <class cEng> class cInterface : public cBase< cEng > {
    private:
	cVideoSurface				 *_surface;

	cInterface					*_interfaceParent;
	map< UPoint*, cInterface<cEng>* >	 _interfaces;

	bool						 _redraw,			_enabled;

    protected:
	UPoint					_size;

    public:
	cInterface(cEng *pEngine, cInterface< cEng > *pParent , UPoint pSize): cBase< cEng >(pEngine) {
	    _size = pSize;
	    _redraw = true;
	    _enabled = true;

	    _surface = new cVideoSurface(pSize);

	    _interfaceParent = pParent;
	}

	~cInterface() {
	    typename map< UPoint*, cInterface<cEng>* >::iterator	interfaceIT;

	    for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {
		delete interfaceIT->first;
		delete interfaceIT->second;
	    }

	    delete _surface;
	}

	void			disable() {
	    _enabled = false;
	}

	cInterface<cEng>	*interfaceAdd(cInterface<cEng> *pButton, UPoint p) {
	    UPoint *pos = new UPoint(p);

	    _interfaces.insert(pair< UPoint*, cInterface<cEng> *>(pos, (cInterface*) pButton));
	    return pButton;
	}

	cInterface<cEng>	*interfaceAdd(cButton<cEng> *pButton, UPoint p) {
	    UPoint *pos = new UPoint(p);

	    _interfaces.insert(pair< UPoint*, cInterface<cEng> *>(pos, (cInterface*) pButton));
	    return pButton;
	}

	void				 interfaceRemove(cInterface<cEng> *Interface) {
	    typename map<UPoint*, cInterface<cEng>* >::iterator	interfaceIT;

	    if(!Interface)
		return;

	    for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {

		if(interfaceIT->second ==  Interface)
		    break;

	    }

	    if(interfaceIT == _interfaces.end())
		return;

	    delete interfaceIT->second;
	    _interfaces.erase(interfaceIT);
	}

	cInterface<cEng>	*interfaceParentGet() {
	    return _interfaceParent;
	}

	cInterface<cEng>	*interfaceGet(UPoint p) {
	    typename map<UPoint*, cInterface<cEng>* >::iterator	interfaceIT;

	    for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {

		if(isInside(p, *interfaceIT->first, interfaceIT->second->getScreenSize()))
		    return interfaceIT->second;
	    }

	    return 0;
	}

	virtual void	 draw() {
	    typename map< UPoint*, cInterface<cEng>* >::iterator	interfaceIT;
	    cInterface<cEng>	*Interface;

	    for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {
		Interface = interfaceIT->second;

		if(Interface->redrawGet()) {
		    Interface->draw();
		    Interface->redrawSet(false);
		    redrawSet();
		}

	    }

	    if(redrawGet())
		for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {
		    Interface = interfaceIT->second;
		    Interface->drawTo(_surface);
		}


	}

	virtual void	 drawTo(cVideoSurface *pSurface) {
	    UPoint *pos = 0;

	    if(_interfaceParent)
		pos = _interfaceParent->positionGet(this);

	    if(!pos) {
		pSurface->surfacePut(surfaceGet()->surfaceGet());
		return;
	    }

	    pSurface->surfacePut(surfaceGet()->surfaceGet(), *pos);

	}

	virtual void	 redrawAll() {
	    redrawSet();

	    typename map< UPoint*, cInterface<cEng>* >::iterator	interfaceIT;
	    cInterface<cEng>	*Interface;

	    for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {
		Interface = interfaceIT->second;

		Interface->redrawAll();
	    }
	}

	bool isInside(UPoint p, UPoint p2, UPoint size) {	// Is X/Y inside the button
	    // Check if within co-ordinates
	    if(p.x > p2.x && p.x < (p2.x + size.x))
		if(p.y > p2.y && p.y < (p2.y + size.y))
		    return true;

	    return false;
	}

	inline	bool	 enabledGet() { return _enabled; }
	inline UPoint getScreenSize() { return _size; }

	virtual void	 mouseClear() {
	    typename map< UPoint*, cInterface<cEng>* >::iterator	interfaceIT;

	    for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {
		interfaceIT->second->mouseClear();
	    }
	}

	virtual void	 mouseRelease(uint32_t pButton, UPoint p) {
	    // Find a button
	    cInterface<cEng> *Interface = cInterface::interfaceGet(p);

	    if(Interface) {
		UPoint *pos = 0;
		pos = positionGet(Interface);
		if(pos)
		    p -= *pos;
	    }

	    mouseClear();

	    if(Interface && Interface->enabledGet()) {
		Interface->mouseRelease(pButton, p);
		return;
	    }

	    return;
	}

	virtual bool	 mousePress(uint32_t pButton, UPoint p) {
	    // Find a button
	    cInterface<cEng> *Interface = cInterface::interfaceGet(p);

	    if(Interface) {
		UPoint *pos = 0;
		pos = positionGet(Interface);
		if(pos)
		    p -= *pos;
	    }

	    if(Interface && Interface->enabledGet()) {
		Interface->mousePress(pButton, p);
		return true;
	    }

	    return false;
	}

	virtual bool	mouseMove(UPoint p) {

	    // Find a button
	    cInterface<cEng> *Interface = cInterface::interfaceGet(p);

	    if(Interface && Interface->enabledGet()) {
		if(Interface->interfaceParentGet()) {
		    UPoint *pos = 0;
		    pos = positionGet(Interface->interfaceParentGet());
		    if(pos)
			p -= *pos;
		}

		p -= Interface->getPos();
		Interface->mouseMove(p);
		return true;
	    }

	    return false;
	}

	inline UPoint			*positionGet(cInterface<cEng> *pInterface) {
	    typename map<UPoint*, cInterface<cEng>* >::iterator	interfaceIT;

	    for(interfaceIT = _interfaces.begin(); interfaceIT != _interfaces.end(); ++interfaceIT) {

		if(interfaceIT->second == pInterface)
		    return interfaceIT->first;
	    }

	    if(_interfaceParent)
		return _interfaceParent->positionGet(pInterface);

	    return 0;
	}

	inline UPoint getPos()	{ UPoint *pos = positionGet(this); if(pos) return *pos; return UPoint(); }

	inline bool				 redrawGet()						{ return _redraw; }
	inline void				 redrawSet(bool value = true)		{	_redraw = value; 
	    if(_interfaceParent) _interfaceParent->redrawSet(); }

	    inline cVideoSurface	*surfaceGet()		{ return _surface; }
    	    inline eastwood::SDL::Surface& surfaceSDLGet()	{ return _surface->surfaceGet(); }

};

template <class cEng> class cButton : public cInterface< cEng > {
    private:

    public:
	cButton(cEng *pEngine, cInterface< cEng > *pParent, UPoint pSize) : cInterface< cEng > (pEngine, pParent, pSize) { }

	virtual void	 mouseClear() { 
	    buttonClear();
	}

	virtual bool	 mousePress(uint32_t pButton, UPoint p) {

	    if(pButton == 1)	// Left
		buttonPressLeft(p);

	    //if(pButton == 2)	// Middle

	    if(pButton == 3)	// Right
		buttonPressRight(p);

	    return true;
	}

	virtual void	 mouseRelease(uint32_t pButton, UPoint p) {
	    if(pButton == 1)
		buttonReleaseLeft(p);

	    if(pButton == 3)
		buttonReleaseRight(p);
	}

	virtual void	 buttonClear() = 0;
	virtual void	 buttonPressLeft(UPoint p) = 0;
	virtual void	 buttonPressRight(UPoint p) = 0;
	virtual void	 buttonReleaseLeft(UPoint p) = 0;
	virtual void	 buttonReleaseRight(UPoint p) = 0;

};



#endif // __OD2SRC_GUI_H__