/*
 * Copyright 2013, Stephan Aßmus <superstippi@gmx.de>.
 * Copyright 2021, Andrew Lindesay <apl@lindesay.co.nz>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */
#ifndef PARAGRAPH_LAYOUT_H
#define PARAGRAPH_LAYOUT_H

#include <vector>

#include <Font.h>
#include <Referenceable.h>
#include <String.h>

#include "CharacterStyle.h"
#include "List.h"
#include "Paragraph.h"


class BView;


class GlyphInfo {
public:
        GlyphInfo()
                :
                charCode(0),
                x(0.0f),
                width(0.0f),
                lineIndex(0)
        {
        }

        GlyphInfo(uint32 charCode, float x, float width, int32 lineIndex)
                :
                charCode(charCode),
                x(x),
                width(width),
                lineIndex(lineIndex)
        {
        }

        GlyphInfo(const GlyphInfo& other)
                :
                charCode(other.charCode),
                x(other.x),
                width(other.width),
                lineIndex(other.lineIndex)
        {
        }

        GlyphInfo& operator=(const GlyphInfo& other)
        {
                charCode = other.charCode;
                x = other.x;
                width = other.width;
                lineIndex = other.lineIndex;
                return *this;
        }

        bool operator==(const GlyphInfo& other) const
        {
                return charCode == other.charCode
                        && x == other.x
                        && width == other.width
                        && lineIndex == other.lineIndex;
        }

        bool operator!=(const GlyphInfo& other) const
        {
                return !(*this == other);
        }

public:
        uint32                                  charCode;

        float                                   x;
        float                                   width;

        int32                                   lineIndex;
};


class LineInfo {
public:
        LineInfo()
                :
                textOffset(0),
                y(0.0f),
                height(0.0f),
                maxAscent(0.0f),
                maxDescent(0.0f),
                extraGlyphSpacing(0.0f),
                extraWhiteSpacing(0.0f),
                layoutedSpans()
        {
        }

        LineInfo(int32 textOffset, float y, float height, float maxAscent,
                float maxDescent)
                :
                textOffset(textOffset),
                y(y),
                height(height),
                maxAscent(maxAscent),
                maxDescent(maxDescent),
                extraGlyphSpacing(0.0f),
                extraWhiteSpacing(0.0f),
                layoutedSpans()
        {
        }

        LineInfo(const LineInfo& other)
                :
                textOffset(other.textOffset),
                y(other.y),
                height(other.height),
                maxAscent(other.maxAscent),
                maxDescent(other.maxDescent),
                extraGlyphSpacing(other.extraGlyphSpacing),
                extraWhiteSpacing(other.extraWhiteSpacing),
                layoutedSpans(other.layoutedSpans)
        {
        }

        LineInfo& operator=(const LineInfo& other)
        {
                textOffset = other.textOffset;
                y = other.y;
                height = other.height;
                maxAscent = other.maxAscent;
                maxDescent = other.maxDescent;
                extraGlyphSpacing = other.extraGlyphSpacing;
                extraWhiteSpacing = other.extraWhiteSpacing;
                layoutedSpans = other.layoutedSpans;
                return *this;
        }

        bool operator==(const LineInfo& other) const
        {
                return textOffset == other.textOffset
                        && y == other.y
                        && height == other.height
                        && maxAscent == other.maxAscent
                        && maxDescent == other.maxDescent
                        && extraGlyphSpacing == other.extraGlyphSpacing
                        && extraWhiteSpacing == other.extraWhiteSpacing
                        && layoutedSpans == other.layoutedSpans;
        }

        bool operator!=(const LineInfo& other) const
        {
                return !(*this == other);
        }

public:
        int32                   textOffset;

        float                   y;
        float                   height;

        float                   maxAscent;
        float                   maxDescent;

        float                   extraGlyphSpacing;
        float                   extraWhiteSpacing;

        std::vector<TextSpan>
                                        layoutedSpans;
};


class ParagraphLayout : public BReferenceable {
public:
                                                                ParagraphLayout();
                                                                ParagraphLayout(const Paragraph& paragraph);
                                                                ParagraphLayout(const ParagraphLayout& other);
        virtual                                         ~ParagraphLayout();

                        void                            SetParagraph(const Paragraph& paragraph);
                        const ParagraphStyle& Style() const
                                                                        { return fParagraphStyle; }

                        void                            SetWidth(float width);
                        float                           Width() const
                                                                        { return fWidth; }

                        float                           Height();
                        void                            Draw(BView* view, const BPoint& offset);

                        int32                           CountGlyphs() const;
                        int32                           CountLines();

                        int32                           LineIndexForOffset(int32 textOffset);
                        int32                           FirstOffsetOnLine(int32 lineIndex);
                        int32                           LastOffsetOnLine(int32 lineIndex);

                        void                            GetLineBounds(int32 lineIndex,
                                                                        float& x1, float& y1,
                                                                        float& x2, float& y2);

                        void                            GetTextBounds(int32 textOffset,
                                                                        float& x1, float& y1,
                                                                        float& x2, float& y2);

                        int32                           TextOffsetAt(float x, float y,
                                                                        bool& rightOfCenter);

private:
                        void                            _Init();

                        void                            _ValidateLayout();
                        void                            _Layout();
                        void                            _ApplyAlignment();

                        bool                            _AppendGlyphInfos(const TextSpan& span);
                        bool                            _AppendGlyphInfo(uint32 charCode,
                                                                        float advanceX,
                                                                        const CharacterStyle& style);

                        bool                            _FinalizeLine(int lineStart, int lineEnd,
                                                                        int lineIndex, float y, float& lineHeight);

                        void                            _IncludeStyleInLine(LineInfo& line,
                                                                        const CharacterStyle& style);

                        void                            _DrawLine(BView* view, const BPoint& offset,
                                                                        const LineInfo& line) const;
                        void                            _DrawSpan(BView* view, BPoint offset,
                                                                        const TextSpan& span,
                                                                        int32 textOffset) const;

                        void                            _GetEmptyLayoutBounds(float& x1, float& y1,
                                                                        float& x2, float& y2) const;

                        void                            _AppendTextSpans(const Paragraph& paragraph);

private:
                        std::vector<TextSpan>
                                                                fTextSpans;
                        ParagraphStyle          fParagraphStyle;

                        float                           fWidth;
                        bool                            fLayoutValid;

                        std::vector<GlyphInfo>
                                                                fGlyphInfos;
                        std::vector<LineInfo>
                                                                fLineInfos;
};


typedef BReference<ParagraphLayout> ParagraphLayoutRef;


#endif // PARAGRAPH_LAYOUT_H