ShapeViewController.h

#pragma once

#include "Types.h"
#include "ShapeEventTypes.h"
#include "ICallback.h"
#include "Positioning.h"
#include "IPositioningViewComponent.h"
#include "IShapeView.h"
#include "ShapeHelpers.h"
#include "InteriorInteractionModel.h"

#include <unordered_set>


namespace Eegeo
{
    namespace Shapes
    {

        
        template <typename TArgs>
        class TShapeViewController : private Eegeo::NonCopyable
        {
        public:
            typedef TShapeViewController<TArgs> ThisType;
            
            TShapeViewController(typename TArgs::ShapeViewFactoryType& viewFactory,
                                 typename TArgs::ShapeViewRepositoryType& viewRepository,
                                 const Eegeo::Positioning::IPositioningViewComponent& positioningViewComponent,
                                 typename TArgs::ShapeModelAddedEventType& shapeModelAddedEvent,
                                 typename TArgs::ShapeModelRemovedEventType& shapeModelRemovedEvent,
                                 typename TArgs::ShapeModelChangedEventType& shapeModelChangedEvent,
                                 const Resources::Interiors::InteriorInteractionModel& interiorInteractionModel)
            : m_viewFactory(viewFactory)
            , m_viewRepository(viewRepository)
            , m_positioningViewComponent(positioningViewComponent)
            , m_shapeModelAddedEvent(shapeModelAddedEvent)
            , m_shapeModelRemovedEvent(shapeModelRemovedEvent)
            , m_shapeModelChangedEvent(shapeModelChangedEvent)
            , m_shapeModelAddedHandler(this, &ThisType::OnShapeModelAdded)
            , m_shapeModelRemovedHandler(this, &ThisType::OnShapeModelRemoved)
            , m_shapeModelChangedHandler(this, &ThisType::OnShapeModelChanged)
            , m_positioningViewComponentChangedHandler(this, &ThisType::OnPositioningViewComponentChanged)
            , m_positioningViewComponentChanged(true)
            , m_interiorInteractionModel(interiorInteractionModel)
            {
                m_shapeModelAddedEvent.Register(m_shapeModelAddedHandler);
                m_shapeModelRemovedEvent.Register(m_shapeModelRemovedHandler);
                m_shapeModelChangedEvent.Register(m_shapeModelChangedHandler);
                m_positioningViewComponent.GetPositioningViewComponentChangedEvent().Register(m_positioningViewComponentChangedHandler);
            }
            
            virtual ~TShapeViewController()
            {
                m_shapeModelAddedEvent.Unregister(m_shapeModelAddedHandler);
                m_shapeModelRemovedEvent.Unregister(m_shapeModelRemovedHandler);
                m_shapeModelChangedEvent.Unregister(m_shapeModelChangedHandler);
                m_positioningViewComponent.GetPositioningViewComponentChangedEvent().Unregister(m_positioningViewComponentChangedHandler);
            }
            
            void Update()
            {
                for (auto pShapeModel : m_modelsNeedingViewRebind)
                {
                    UnbindView(*pShapeModel);
                    BindView(*pShapeModel);
                }
                m_modelsNeedingViewRebind.clear();
                
                if (m_positioningViewComponentChanged)
                {
                    std::vector<typename TArgs::ShapeViewType*> views;
                    m_viewRepository.AllItems(views);
                    
                    for (auto view : views)
                    {
                        UpdateView(*view);
                    }
                    m_positioningViewComponentChanged = false;
                }
            }
            
        private:
            void BindView(const typename TArgs::ShapeModelType& shapeModel)
            {
                auto pView = m_viewFactory.CreateView(shapeModel);
                m_viewRepository.Add(shapeModel.GetId(), pView);
                
                UpdateView(*pView);
            }
            
            void UnbindView(const typename TArgs::ShapeModelType& shapeModel)
            {
                auto pView = m_viewRepository.Get(shapeModel.GetId());
                m_viewRepository.Remove(shapeModel.GetId());
                Eegeo_DELETE pView;
            }
            
            void OnShapeModelAdded(const typename TArgs::ShapeModelType& shapeModel)
            {
                BindView(shapeModel);
            }
            
            void OnShapeModelRemoved(const typename TArgs::ShapeModelType& shapeModel)
            {
                m_modelsNeedingViewRebind.erase(&shapeModel);
                UnbindView(shapeModel);
            }
            
            void OnShapeModelChanged(const typename TArgs::ShapeModelChangedMessageType& message)
            {
                if (message.GeometryChanged)
                {
                    m_modelsNeedingViewRebind.insert(&message.ShapeModel);
                }
                else
                {
                    auto& view = *m_viewRepository.Get(message.ShapeModel.GetId());
                    UpdateView(view);
                }
            }
            
            void OnPositioningViewComponentChanged()
            {
                m_positioningViewComponentChanged = true;
                
            }
            
            void UpdateView(IShapeView& view) const
            {
                const bool show = ShouldShowView(view);
                view.SetHidden(!show);
                view.Update();
            }
            
            bool ShouldShowView(const IShapeView& view) const
            {
                const auto& model = view.GetShapeModel();
                bool isExpanded = m_interiorInteractionModel.IsFullyExpanded() || m_interiorInteractionModel.IsEnteringExpanded();
                return ShapeHelpers::ShouldDisplayShape(model, m_positioningViewComponent, isExpanded);
            }
            
            typename TArgs::ShapeViewFactoryType& m_viewFactory;
            typename TArgs::ShapeViewRepositoryType& m_viewRepository;
            const Eegeo::Positioning::IPositioningViewComponent& m_positioningViewComponent;
            typename TArgs::ShapeModelAddedEventType& m_shapeModelAddedEvent;
            typename TArgs::ShapeModelRemovedEventType& m_shapeModelRemovedEvent;
            typename TArgs::ShapeModelChangedEventType& m_shapeModelChangedEvent;
            
            Helpers::TCallback1<TShapeViewController, const typename TArgs::ShapeModelType> m_shapeModelAddedHandler;
            Helpers::TCallback1<TShapeViewController, const typename TArgs::ShapeModelType> m_shapeModelRemovedHandler;
            Helpers::TCallback1<TShapeViewController, const typename TArgs::ShapeModelChangedMessageType> m_shapeModelChangedHandler;
            Helpers::TCallback0<TShapeViewController> m_positioningViewComponentChangedHandler;

            std::unordered_set<const typename TArgs::ShapeModelType*> m_modelsNeedingViewRebind;
            bool m_positioningViewComponentChanged;

            const Resources::Interiors::InteriorInteractionModel& m_interiorInteractionModel;
        };
    }
}