#ifndef PARSEBRIDGE_H
#define PARSEBRIDGE_H

#include <QDomDocument>
#include <QStandardItemModel>

namespace bridge {

    class DocumentInst {
    public:
        DocumentInst(const QString &name, const QString &path);

        QString name() const;
        QString path() const;

    private:
        QString n, p;
    };

    class ContentNode : public QStandardItem {
    public:
        ContentNode(const QString &name);
        virtual ~ContentNode() = default;

        virtual void append(const QString &section);
        virtual QString desc() const;

        virtual void clear();

    private:
        QString desc_sections;
        QString name_store;
    };

    class SyntaxNode {
    public:
        virtual ~SyntaxNode() = default;

        virtual std::tuple<int, int> startPos() const;
        virtual std::tuple<int, int> endPos() const;
        virtual void loadPos(int start_r, int start_c, int end_r, int end_c);

    private:
        std::tuple<int, int> start, end;
    };

    class ParseException : public QStandardItem {
    public:
        ParseException(DocumentInst *pinst);

        void load(const QString &message, int row, int col);

        const DocumentInst *doc() const;
        QString message() const;
        int row() const;
        int col() const;

        QString operator[](int index);

    private:
        std::tuple<DocumentInst *, QString, int, int> key_store;
    };

    class StorychainInst : public ContentNode, public SyntaxNode {
    public:
        StorychainInst(DocumentInst *pinst, const QString &name);

        void indexSet(int sort);
        int sortIndex() const;

        DocumentInst *doc() const;
        QString operator[](int index);

    private:
        int sort_store;
        DocumentInst *const pinst_store;
    };

    class StoryfragmentInst : public SyntaxNode, public ContentNode {
    public:
        StoryfragmentInst(const QString &name);

        int logicIndex() const;
        void setLogicIndex(int index);

        QString operator[](int index);

    private:
        int sort_store;
    };

    class StoryfragmentRefer : public SyntaxNode, public ContentNode {
    public:
        StoryfragmentRefer(StoryfragmentInst *inst);

        QString storyRef() const;
        void appointStory(const QString &ref);

        QString fragmentRef() const;
        void appointFragment(const QString &ref);

        QString operator[](int index);

    private:
        QString story, fragment;
    };

    class StoryvolumeInst : public SyntaxNode, public ContentNode {
    public:
        StoryvolumeInst(DocumentInst *inst, const QString &name);

        DocumentInst *doc() const;

        QString operator[](int index);

    private:
        DocumentInst *const doc_store;
    };

    class StoryarticleInst : public SyntaxNode, public ContentNode {
    public:
        StoryarticleInst(const QString &name);

        QString operator[](int index);
    };

    template <class T, int idx> class SupplyItem : public QStandardItem {
    public:
        SupplyItem(T *bitem) : value_store(bitem) { setText((*bitem)[idx]); }

    private:
        const T *const value_store;
    };

    /**
     * @brief 小说解析核心
     */
    class ParseBridge {
    public:
        ParseBridge();
        virtual ~ParseBridge();

        QString novelName() const;

        QStandardItemModel *chainsPresentModel() const;
        QStandardItemModel *volumesPresentModel() const;
        QStandardItemModel *errorsPresentModel() const;

        void load(const QString &data_path);

    private:
        QStandardItemModel *const chains_model, *const volumes_model, *const errors_model;
        QDomDocument doc_ins;
        QString name_store;
        std::vector<DocumentInst *> docs_store;

        void load_document(const QDomElement &pdoc, std::vector<DocumentInst *> node_sets);
        void load_element(const QDomElement &telm, DocumentInst *pinst, QStandardItem *pitem = nullptr);

        void load_errors(QStandardItemModel *anchor, const QDomElement &error_elm, DocumentInst *pinst);
        void load_story(QStandardItemModel *model, const QDomElement &chain_elm, DocumentInst *pinst);
        void load_desc(const QDomElement &desc_elm, ContentNode *pitem);
        void load_fragment(const QDomElement &frag_elm, QStandardItem *pinst);
        void load_frag_refer(const QDomElement &refer_elm, QStandardItem *pitem);

        void load_volumes(QStandardItemModel *model, const QDomElement &volume_elm, DocumentInst *pinst);
        void load_article(const QDomElement &article_elm, QStandardItem *pitem);

        QStandardItem *locate_node(QStandardItemModel *model, const QStringList path);
    };

} // namespace bridge

#endif // PARSEBRIDGE_H