/*
    SPDX-FileCopyrightText: 2010 Christoph Cullmann <cullmann@kde.org>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#ifndef KATE_TEXTLINE_H
#define KATE_TEXTLINE_H

#include <QSharedPointer>
#include <QString>
#include <QVector>

#include <ktexteditor_export.h>

#include <KSyntaxHighlighting/State>

namespace Kate
{
/**
 * Class representing a single text line.
 * For efficiency reasons, not only pure text is stored here, but also additional data.
 * Will be only accessed over shared pointers.
 */
class KTEXTEDITOR_EXPORT TextLineData
{
    /**
     * TexBlock is a friend class, only one allowed to touch the text content.
     */
    friend class TextBlock;

public:
    /**
     * Attribute storage
     */
    class Attribute
    {
    public:
        /**
         * Attribute constructor
         * @param _offset offset
         * @param _length length
         * @param _attributeValue attribute value
         */
        explicit Attribute(int _offset = 0, int _length = 0, short _attributeValue = 0)
            : offset(_offset)
            , length(_length)
            , attributeValue(_attributeValue)
        {
        }

        /**
         * offset
         */
        int offset;

        /**
         * length
         */
        int length;

        /**
         * attribute value (to encode type of this range)
         */
        short attributeValue;
    };

    /**
     * Folding storage
     */
    class Folding
    {
    public:
        /**
         * Construct folding.
         * @param _offset offset of the folding start
         * @param _length length of the folding
         * @param _foldingValue positive ones start foldings, negative ones end them
         */
        Folding(int _offset, int _length, int _foldingValue)
            : offset(_offset)
            , length(_length)
            , foldingValue(_foldingValue)
        {
        }

        /**
         * offset
         */
        int offset = 0;

        /**
         * length
         */
        int length = 0;

        /**
         * positive ones start foldings, negative ones end them
         */
        int foldingValue = 0;
    };

    /**
     * Flags of TextLineData
     */
    enum Flags { flagAutoWrapped = 1, flagFoldingStartAttribute = 2, flagLineModified = 4, flagLineSavedOnDisk = 8 };

    /**
     * Construct an empty text line.
     */
    TextLineData() = default;

    /**
     * Construct an text line with given text.
     * @param text text to use for this line
     */
    explicit TextLineData(const QString &text)
        : m_text(text)
        , m_flags(0)
    {
    }

    /**
     * Accessor to the text contained in this line.
     * @return text of this line as constant reference
     */
    const QString &text() const
    {
        return m_text;
    }

    /**
     * Returns the position of the first non-whitespace character
     * @return position of first non-whitespace char or -1 if there is none
     */
    int firstChar() const;

    /**
     * Returns the position of the last non-whitespace character
     * @return position of last non-whitespace char or -1 if there is none
     */
    int lastChar() const;

    /**
     * Find the position of the next char that is not a space.
     * @param pos Column of the character which is examined first.
     * @return True if the specified or a following character is not a space
     *          Otherwise false.
     */
    int nextNonSpaceChar(int pos) const;

    /**
     * Find the position of the previous char that is not a space.
     * @param pos Column of the character which is examined first.
     * @return The position of the first non-whitespace character preceding pos,
     *   or -1 if none is found.
     */
    int previousNonSpaceChar(int pos) const;

    /**
     * Returns the character at the given \e column. If \e column is out of
     * range, the return value is QChar().
     * @param column column you want char for
     * @return char at given column or QChar()
     */
    inline QChar at(int column) const
    {
        if (column >= 0 && column < m_text.length()) {
            return m_text.at(column);
        }

        return QChar();
    }

    inline void markAsModified(bool modified)
    {
        if (modified) {
            m_flags |= flagLineModified;
            m_flags &= (~flagLineSavedOnDisk);
        } else {
            m_flags &= (~flagLineModified);
        }
    }

    inline bool markedAsModified() const
    {
        return m_flags & flagLineModified;
    }

    inline void markAsSavedOnDisk(bool savedOnDisk)
    {
        if (savedOnDisk) {
            m_flags |= flagLineSavedOnDisk;
            m_flags &= (~flagLineModified);
        } else {
            m_flags &= (~flagLineSavedOnDisk);
        }
    }

    inline bool markedAsSavedOnDisk() const
    {
        return m_flags & flagLineSavedOnDisk;
    }

    /**
     * Clear folding start status.
     */
    void clearMarkedAsFoldingStart()
    {
        m_flags &= ~flagFoldingStartAttribute;
    }

    /**
     * Is on this line a folding start per attribute?
     * @return folding start line per attribute? or not?
     */
    bool markedAsFoldingStartAttribute() const
    {
        return m_flags & flagFoldingStartAttribute;
    }

    /**
     * Mark as folding start line of an attribute based folding.
     */
    void markAsFoldingStartAttribute()
    {
        m_flags |= flagFoldingStartAttribute;
    }

    /**
     * Returns the line's length.
     */
    int length() const
    {
        return m_text.length();
    }

    /**
     * Returns \e true, if the line was automagically wrapped, otherwise returns
     * \e false.
     * @return was this line auto-wrapped?
     */
    bool isAutoWrapped() const
    {
        return m_flags & flagAutoWrapped;
    }

    /**
     * Returns the substring with \e length beginning at the given \e column.
     * @param column start column of text to return
     * @param length length of text to return
     * @return wanted part of text
     */
    QString string(int column, int length) const
    {
        return m_text.mid(column, length);
    }

    /**
     * Leading whitespace of this line
     * @return leading whitespace of this line
     */
    QString leadingWhitespace() const;

    /**
     * Returns the indentation depth with each tab expanded into \e tabWidth characters.
     */
    int indentDepth(int tabWidth) const;

    /**
     * Returns the \e column with each tab expanded into \e tabWidth characters.
     */
    int toVirtualColumn(int column, int tabWidth) const;

    /**
     * Returns the "real" column where each tab only counts one character.
     * The conversion calculates with \e tabWidth characters for each tab.
     */
    int fromVirtualColumn(int column, int tabWidth) const;

    /**
     * Returns the text length with each tab expanded into \e tabWidth characters.
     */
    int virtualLength(int tabWidth) const;

    /**
     * Returns \e true, if \e match equals to the text at position \e column,
     * otherwise returns \e false.
     */
    bool matchesAt(int column, const QString &match) const;

    /**
     * Returns \e true, if the line starts with \e match, otherwise returns \e false.
     */
    bool startsWith(const QString &match) const
    {
        return m_text.startsWith(match);
    }

    /**
     * Returns \e true, if the line ends with \e match, otherwise returns \e false.
     */
    bool endsWith(const QString &match) const
    {
        return m_text.endsWith(match);
    }

    /**
     * context stack
     * @return context stack
     */
    const KSyntaxHighlighting::State &highlightingState() const
    {
        return m_highlightingState;
    }

    /**
     * Sets the syntax highlight context number
     * @param val new context array
     */
    void setHighlightingState(const KSyntaxHighlighting::State &val)
    {
        m_highlightingState = val;
    }

    /**
     * Add attribute to this line.
     * @param attribute new attribute to append
     */
    void addAttribute(const Attribute &attribute);

    /**
     * Clear attributes and foldings of this line
     */
    void clearAttributesAndFoldings()
    {
        m_attributesList.clear();
        m_foldings.clear();
    }

    /**
     * Accessor to attributes
     * @return attributes of this line
     */
    const QVector<Attribute> &attributesList() const
    {
        return m_attributesList;
    }

    /**
     * Accessor to foldings
     * @return foldings of this line
     */
    const std::vector<Folding> &foldings() const
    {
        return m_foldings;
    }

    /**
     * Add new folding at end of foldings stored in this line
     * @param offset offset of folding start
     * @param length length of the string that represents the folding
     * @param folding folding to add, positive to open, negative to close
     */
    void addFolding(int offset, int length, int folding)
    {
        m_foldings.emplace_back(offset, length, folding);
    }

    /**
     * Gets the attribute at the given position
     * use KRenderer::attributes  to get the KTextAttribute for this.
     *
     * @param pos position of attribute requested
     * @return value of attribute
     */
    short attribute(int pos) const;

    /**
     * set auto-wrapped property
     * @param wrapped line was wrapped?
     */
    void setAutoWrapped(bool wrapped)
    {
        if (wrapped) {
            m_flags = m_flags | flagAutoWrapped;
        } else {
            m_flags = m_flags & ~flagAutoWrapped;
        }
    }

private:
    /**
     * Accessor to the text contained in this line.
     * This accessor is private, only the friend class text buffer/block is allowed to access the text read/write.
     * @return text of this line
     */
    QString &textReadWrite()
    {
        return m_text;
    }

private:
    /**
     * text of this line
     */
    QString m_text;

    /**
     * attributes of this line
     */
    QVector<Attribute> m_attributesList;

    /**
     * foldings of this line
     */
    std::vector<Folding> m_foldings;

    /**
     * current highlighting state
     */
    KSyntaxHighlighting::State m_highlightingState;

    /**
     * flags of this line
     */
    unsigned int m_flags = 0;
};

/**
 * The normal world only accesses the text lines with shared pointers.
 */
typedef std::shared_ptr<TextLineData> TextLine;
}

#endif
