#pragma once
#include "../RenderAble.h"
#include "../Axis/AbsAxis.h"

namespace YSG {
    struct HoverInfoRenderState;
    struct HoverInfoRenderAbleInterFace;
    struct LIB_DECL HoverInfoRenderState {
        virtual ~HoverInfoRenderState() = default;
        HoverInfoRenderState() {
            hoverInfoBrush = QBrush(Qt::white);
        }
        int hoverInfoLeft = 4, hoverInfoTop = 4, hoverInfoRight = 4, hoverInfoBottom = 4;
        QBrush hoverInfoBrush;
        QFont hoverInfoFont;
        QPen hoverInfoPen;
        bool useHoverInfo = true;
        bool hoverInfoActive = false;
        QPoint hoverInfoPos;
        HoverInfoRenderAbleInterFace *renderAble{};
        void drawHover(QPainter* painter, AbsAxis *h, AbsAxis *v);
        bool hoverOK(RenderAble* able) const;
    };
    struct LIB_DECL HoverInfoRenderAbleInterFace {
        virtual QVector<QString> createHoverString(AbsAxis* h, AbsAxis* v, QPoint pos);
        virtual ~HoverInfoRenderAbleInterFace() = default;
        virtual void drawHover(QPainter* painter, AbsAxis *h, AbsAxis *v) {
            return hoverState(SRC::Render)->drawHover(painter, h, v);
        }
        virtual bool hoverOK(RenderAble* able) {
            return hoverState(SRC::Render)->hoverOK(able);
        }
        virtual bool hoverTest(QPoint pos) {
            return true;
        }
        bool useHoverInfo(SRC src = SRC::Edit) {
            return hoverState(src)->useHoverInfo;
        }
        void setUseHoverInfo(bool use) {
            HoverInfoRenderState* sc = beginHoverEdit();
            sc->useHoverInfo = use;
            finishHoverEdit();
        }
        void setHoverInfoFont(const QFont& font) {
            HoverInfoRenderState* sc = beginHoverEdit();
            sc->hoverInfoFont = font;
            finishHoverEdit();
        }
        QFont HoverInfoFont(SRC src = SRC::Edit) {
            return hoverState(src)->hoverInfoFont;
        }
        QBrush hoverInfoBackgroundBrush(SRC src = SRC::Edit) {
            return hoverState(src)->hoverInfoBrush;
        }
        void setHoverInfoBackgroundBrush(const QBrush& brush) {
            HoverInfoRenderState* sc = beginHoverEdit();
            sc->hoverInfoBrush = brush.color().isValid() ? brush : Qt::NoBrush;
            finishHoverEdit();
        }
        QPen hoverInfoPen(SRC src = SRC::Edit) {
            return hoverState(src)->hoverInfoPen;
        }
        void setHoverInfoPen(const QPen& pen) {
            HoverInfoRenderState* sc = beginHoverEdit();
            sc->hoverInfoPen = pen.color().isValid() ? pen : Qt::NoPen;
            finishHoverEdit();
        }
        void getHoverInfoContentsMargins(int& left, int& top, int& right, int& bottom, SRC src) {
            auto s = hoverState(src);
            left = s->hoverInfoLeft;
            top = s->hoverInfoTop;
            right = s->hoverInfoRight;
            bottom = s->hoverInfoBottom;
        }

        void setHoverInfoContentsMargins(int left, int top, int right, int bottom) {
            HoverInfoRenderState* sc = beginHoverEdit();
            sc->hoverInfoLeft = left;
            sc->hoverInfoTop = top;
            sc->hoverInfoRight = right;
            sc->hoverInfoBottom = bottom;
            finishHoverEdit();
        }
    protected:
        virtual HoverInfoRenderState* hoverState(SRC src) = 0;
        virtual HoverInfoRenderState* beginHoverEdit() = 0;
        virtual void finishHoverEdit() = 0;
    };
    struct LIB_DECL HoverInfoIndependRenderAble : HoverInfoRenderAbleInterFace {
    private:
        HoverInfoRenderState s, sc;
        HoverInfoRenderState* hoverState(SRC src) override {
            if(src == SRC::Edit) {
                return &sc;
            }
            return &s;
        }
        HoverInfoRenderState* beginHoverEdit() override {
            return &sc;
        }
        void finishHoverEdit() override {
        }
    public:
        void drawHover(QPainter* painter, AbsAxis* h, AbsAxis* v) override {
            s.renderAble = this;
            sc.renderAble = this;
            s = sc;
            HoverInfoRenderAbleInterFace::drawHover(painter, h, v);
        }
    };
    template <typename That>
    struct LIB_DECL HoverInfoRenderAble : HoverInfoRenderAbleInterFace {
    private:
        That *that() {
            return static_cast<That*>(this);
        }
        Triple_Buffer_Lease mHoverLease{};
        HoverInfoRenderState* hoverState(SRC src) override {
            auto t = that();
            return dynamic_cast<HoverInfoRenderState*>(t->dPtr->state(src));
        }
        HoverInfoRenderState* beginHoverEdit() override {
            auto t = that();
            mHoverLease = t->dPtr->mStateControl.wait_mark_use_role(State_Edit);
            return dynamic_cast<HoverInfoRenderState*>(t->dPtr->stateByIndex(mHoverLease.index));
        }
        void finishHoverEdit() override {
            auto t = that();
            ++t->dPtr->stateByIndex(mHoverLease.index)->version;
            t->markRenderDirty();
            t->dPtr->mStateControl.unmark_use(mHoverLease);
            mHoverLease = {};
        }
    };
}