//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2009-2015 Marianne Gagnon
//
//  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, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.



#ifndef HEADER_RIBBON_HPP
#define HEADER_RIBBON_HPP

#include <irrString.h>

#include "guiengine/widget.hpp"
#include "guiengine/widgets/icon_button_widget.hpp"
#include "utils/cpp2011.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"

#include <IGUIStaticText.h>

namespace GUIEngine
{
    /** Types of ribbons */
    enum RibbonType
    {
        RIBBON_COMBO,   //!< select one item out of many, like in a combo box
        RIBBON_TOOLBAR, //!< a row of individual buttons
        RIBBON_TABS,    //!< a tab bar
        RIBBON_VERTICAL_TABS //!< a vertical tab bar
    };

    /** \brief A static text/icons/tabs bar widget.
      * The contents of this ribbon are static.
      * \ingroup widgetsgroup
      * \note items you add to a list are kept after the the ribbon was in
      *       is removed (i.e. you don't need to add items everytime the
      *       screen is shown, only upon loading)
      */
    class RibbonWidget : public Widget
    {
    public:
        class IRibbonListener
        {
        public:
            virtual ~IRibbonListener(){}
            virtual void onRibbonWidgetScroll(const int delta_x) = 0;
            virtual void onRibbonWidgetFocus(RibbonWidget* emitter,
                                             const int playerID) = 0;
            virtual void onSelectionChange() = 0;
        };
        
    private:
        friend class DynamicRibbonWidget;
        friend class EventHandler;
        
        int m_selection[MAX_PLAYER_COUNT];
        
        /** The type of this ribbon (toolbar, combo, tabs, vertical tabs) */
        RibbonType m_ribbon_type;
                
        /** Each item within the ribbon holds a flag saying whether it is
         *  selected or not. This method updates the flag in all of this
         *  ribbon's children. Called everytime selection changes.*/
        void updateSelection();

        /** Callbacks */
        virtual EventPropagation rightPressed(const int playerID=0) OVERRIDE;
        virtual EventPropagation leftPressed (const int playerID=0) OVERRIDE;
        virtual EventPropagation upPressed   (const int playerID=0) OVERRIDE;
        virtual EventPropagation downPressed (const int playerID=0) OVERRIDE;
        EventPropagation moveToNextItem(const bool horizontally, const bool reverse, const int playerID);
        EventPropagation propagationType(const bool horizontally);
        void selectNextActiveWidget(const bool horizontally, const bool reverse,
                                    const int playerID, const int old_selection);
        virtual EventPropagation mouseHovered(Widget* child,
                                              const int playerID) OVERRIDE;
        virtual EventPropagation transmitEvent(Widget* w,
                                               const std::string& originator,
                                               const int playerID=0) OVERRIDE;
        virtual EventPropagation focused(const int playerID) OVERRIDE;
        virtual void unfocused(const int playerID, Widget* new_focus) OVERRIDE;
        
        virtual EventPropagation onClick() OVERRIDE;
        
        PtrVector<irr::gui::IGUIStaticText, REF> m_labels;
        
        IRibbonListener* m_listener;
        PtrVector<Widget> m_active_children;
        
    public:
        
        LEAK_CHECK()
        
        /** Internal identifier of filler items that are added in a ribbon
         *  widget to filllines when the number of items cannot be divided
         *  by the number of rows in the grid (mostly used by dynamic ribbon
         *  widgets, but the base ribbon needs to know about filler items)
         */
        static const char NO_ITEM_ID[];
        
        /** Contains which element within the ribbon is currently focused by
         *  player 0 (used by the skin to show mouse hovers over items that
         *  are not selected). Only used for COMBO and TAB ribbons. */
        Widget* m_mouse_focus;
        
        RibbonWidget(const RibbonType type=RIBBON_COMBO);
        virtual ~RibbonWidget();
        
        virtual void add() OVERRIDE;

        /** Sets a listener that will be notified of changes on this ribbon.
         *  Does _not_ take ownership of the listener, i.e. will not delete it.
         *  You may call this with the listener parameter set to NULL to
         *  remove the listener. */
        void setListener(IRibbonListener* listener) { m_listener = listener; }
        // --------------------------------------------------------------------
        /** Returns the type of this ribbon (see the GUI module overview page
         *  for detailed descriptions) */
        RibbonType getRibbonType() const { return m_ribbon_type; }
        // --------------------------------------------------------------------
        /** Returns the number of active items within the ribbon */
        int getActiveChildrenNumber(const int playerID) const
                                              { return m_active_children.size(); }
        // --------------------------------------------------------------------
        /** Returns the numerical ID of the selected item within the ribbon */
        int getSelection(const int playerID) const
                                              { return m_selection[playerID]; }
        // --------------------------------------------------------------------
        /** Returns the string ID (internal name) of the selection */
        const std::string& getSelectionIDString(const int playerID);
        // --------------------------------------------------------------------
        /** Returns the user-visible text of the selection */
        irr::core::stringw getSelectionText(const int playerID)
        {
            const int selection = m_selection[playerID];
            if (selection < 0 || selection >= int(m_children.size())) return "";
            return m_children[selection].m_text;
        }
        // --------------------------------------------------------------------

        /** Sets the ID of the selected item within the ribbon */
        void setSelection(const int i, const int playerID)
                             { m_selection[playerID] = i; updateSelection(); }
        
        /** Select an item in the ribbon by its internal name */
        void select(std::string item, const int playerID);
        
        /**
          * \brief This method can be used to rename an item.
          * Has no effect for ribbons without individual labels.
          *
          * \pre Must be called after the ribbon was add()ed
          * \param id The index of the item to rename, in range [0 .. item count - 1]
          */
        void setLabel(const unsigned int id, irr::core::stringw new_name);
        
        void setItemVisible(const unsigned int id, bool visible);

        /** Returns the ID of the item, or -1 if not found */
        int findItemNamed(const char* internalName);
        
        /** Returns the the widget, or NULL if not found */
        GUIEngine::Widget * findWidgetNamed(const char* interalName);

        /** \brief Dynamically (at runtime) add a text item to this ribbon
          * \pre This must be called before RibbonWidget::add, while the
          *      widget is not yet displayed
          * \pre only valid for ribbons that take text-only contents
          *       (e.g. tab bars)
          */
        void addTextChild(const wchar_t* text, const std::string &id);
        
        
        /** \brief Dynamically (at runtime) add an icon item to this ribbon.
         *  \pre this must be called before RibbonWidget::add, while the widget
         *       is not yet displayed
         *  \pre only valid for ribbons that take icon contents
         */
        void addIconChild(const wchar_t* text, const std::string &id,
                          const int w, const int h, const std::string &icon,
                          const IconButtonWidget::IconPathType iconPathType=
                                    IconButtonWidget::ICON_PATH_TYPE_RELATIVE);
    
        /**
          * \brief clear all children of this ribbon (likely because new ones will be added soon after)
          * \pre this must be called before RibbonWidget::add, while the widget is not yet displayed
          */
        void clearAllChildren();
        
        /**
         * \brief clear one child from this ribbon
         * \pre this must be called before RibbonWidget::add, while the widget is not yet displayed
         */
        void removeChildNamed(const char* name);
        
        PtrVector<Widget>& getRibbonChildren() { return m_children; }

        virtual EventPropagation onActivationInput(const int playerID) OVERRIDE;
    };

}

#endif