spreadsheet.h

#pragma once
 
// Application headers
#include "include/spreadsheet/private/spreadsheet_file.h"
namespace ehm_dal::column_data {
class ColumnIndexList;
}
 
namespace ehm_dal::data_types {
class Pointer;
}
namespace ehm_dal::settings {
class FolderPath;
}
namespace ehm_dal::tables {
class AbstractTable;
}
 
// Qt headers
class QAbstractTableModel;
#include <QString>
#include <QVariant>
#include <span>
#include <vector>
 
namespace ehm_dal::spreadsheet {
 
// --- Spreadsheet --- //
class Spreadsheet
{
public:
    // Constructor
    Spreadsheet(const QString &file_path = QString());
    Spreadsheet(const QString &folder_path, const QString &file_name);
    Spreadsheet(const settings::FolderPath &path);
    ~Spreadsheet();
 
    // Add data - cells/rows: basic
    inline void add() { add(QVariant()); }
    inline void add(const QString &text) { add(QVariant(text)); }
    void add(const QVariant &data);
    void add(const QVariant &data, const qint32 row);
    void add(const QVariant &data, const qint32 start_row, const qint32 row_count);
 
    // Add data - cells/rows: AbstractTable data
    void add(ehm_dal::tables::AbstractTable *model, const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(ehm_dal::tables::AbstractTable *model,
             const qint32 row,
             const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(ehm_dal::tables::AbstractTable *model,
             const std::vector<qint32> &rows,
             const Qt::ItemDataRole role = Qt::DisplayRole);
 
    // Add data - cells/rows: Column index list
    void add(const ehm_dal::column_data::ColumnIndexList &columns,
             const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(const ehm_dal::column_data::ColumnIndexList &columns,
             const qint32 row,
             const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(const ehm_dal::column_data::ColumnIndexList &columns,
             const std::vector<qint32> &rows,
             const Qt::ItemDataRole role = Qt::DisplayRole);
 
    // Add data - cells/rows: QAbstractTableModel data
    void add(QAbstractTableModel *model, const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(QAbstractTableModel *model,
             const qint32 row,
             const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(QAbstractTableModel *model,
             const std::vector<qint32> &rows,
             const Qt::ItemDataRole role = Qt::DisplayRole);
 
    // Add data - cells/rows: Pointer data
    void add(const ehm_dal::data_types::Pointer &pointer, const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(const ehm_dal::data_types::Pointer &pointer,
             const std::vector<qint32> &column_index_list,
             const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(const std::vector<ehm_dal::data_types::Pointer> &pointer_list,
             const Qt::ItemDataRole role = Qt::DisplayRole);
    void add(const std::vector<ehm_dal::data_types::Pointer> &pointer_list,
             const std::vector<qint32> &column_index_list,
             const Qt::ItemDataRole role = Qt::DisplayRole);
 
    // Add data - prefix cells
    inline void addPrefix() { addPrefix(QVariant()); }
    inline void addPrefix(const QVariant &data) { prefix_cell_data_.push_back(data); }
 
    // Add data - header: basic
    inline void addHeader() { add(QVariant()); }
    inline void addHeader(const QString &text) { addHeader(QVariant(text)); }
    void addHeader(const QStringList &text_list);
    void addHeader(const QVariant &data);
 
    // Add data - header: model data
    void addHeader(QAbstractTableModel *model);
    void addHeader(const ehm_dal::column_data::ColumnIndexList &columns);
    void addHeader(QAbstractTableModel *model, const std::vector<qint32> &column_index_list);
 
    // Add data - prefix header
    inline void addHeaderPrefix() { addHeaderPrefix(QVariant()); }
    inline void addHeaderPrefix(const QVariant &data) { prefix_header_data_.push_back(data); }
 
    // Date format
    enum class DateFormat {
        DateMonthYear, 
        MonthDateYear, 
        YearMonthDate  
    };
 
    static DateFormat dateFormat();
    inline static QString dateFormatString() { return date_format_; }
    static void setDateFormat(const DateFormat date_format);
 
    // Debugging / diagnostics
    void printDiagnosticData() const;
 
    // File details - get data
    QString file();
    QString fileExtension() const;
    inline QString fileName() { return file_name_; }
    inline QString fileNameAndExtension()
    {
        return QStringLiteral("%1.%2").arg(fileName(), fileExtension());
    }
    inline QString folderPath() const { return path_; }
    inline QString identifier() { return headerCell(0,0).toString().replace(" ", "_").toLower(); }
 
    // File details - set data
    void addFileNameSuffix(const QString &suffix);
    bool setFile(const QString &path);
    bool setFileName(const QString &file_name);
 
    // File extensions
    static qint32 defaultFileExtension();
    static QString fileExtensionListAsString(const bool merged_list = true);
    static QStringList fileExtensionListAsStringList();
    static void setDefaultFileExtension(const qint32 i);
 
    // File I/O
    bool open(const QString &file_path);
    bool open(const QString &folder, const QString &file_name);
    bool read();
    bool save(const QString &folder, const QString &file_name);
    bool write();
 
    // File I/O dialog windows
    bool showOpenDialog(QString file_path = QString(), const bool read_data = true);
    bool showOpenDialog(settings::FolderPath &path, const bool read_data = true);
    bool showSaveDialog(const QString &file_name = "output.csv", QString file_path = QString());
    bool showSaveDialog(settings::FolderPath &path);
 
    // Get data - cells
    QVariant cell(const qint32 row, const qint32 col, const bool return_as_date = false) const;
    std::span<const QVariant> cells(const qint32 row,
                                    const qint32 col,
                                    const qint32 col_count) const;
    bool columnContainsData(const qint32 column) const;
    qint32 columnCount(const qint32 row) const;
    std::span<const QVariant> row(const qint32 row) const;
    inline qint32 rowCount() const { return static_cast<qint32>(cell_data_.size()); }
 
    // Get data - prefix cells
    QVariant prefix(const qint32 row) const;
    inline bool hasPrefixData() const { return prefixCount() > 0; }
    inline qint32 prefixCount() const { return static_cast<qint32>(prefix_cell_data_.size()); }
 
    // Get data - header
    std::span<const QVariant> header(const qint32 row) const;
    QVariant headerCell(const qint32 row, const quint16 col) const;
    inline qint32 headerCount() const
    {
        return std::max(static_cast<qint32>(header_data_.size()), header_count_);
    }
 
    // Get data - header
    QVariant prefixHeader(const qint32 row) const;
    inline bool hasPrefixHeaderData() const { return prefixHeaderCount() > 0; }
    inline qint32 prefixHeaderCount() const
    {
        return static_cast<qint32>(prefix_header_data_.size());
    }
 
    // Get settings
    static QString exportPath();
    static QString importPath();
 
    // Row data: add data
    void addNewHeaderRow();
    void addNewRow();
 
    // Set header data
    void setHeaderCount(const qint32 header_row_count);
 
    // Spreadsheet file
    std::unique_ptr<SpreadsheetFile> newSpreadsheet(QFile &f);
 
private:
    // Data
    std::vector<std::vector<QVariant>> cell_data_;
    std::vector<std::vector<QVariant>> header_data_;
    std::vector<QVariant> prefix_cell_data_;
    std::vector<QVariant> prefix_header_data_;
 
    // Add data - cells/rows: Private model data methods
    /*void addFromDualTableModels(QAbstractTableModel *lhs_model,
                                const std::vector<qint32> &lhs_column_index_list,
                                QAbstractTableModel *rhs_model,
                                const std::vector<qint32> &rhs_column_index_list,
                                const Qt::ItemDataRole role = Qt::DisplayRole);
    void addFromDualTableModels(QAbstractTableModel *lhs_model,
                                const qint32 lhs_row,
                                const std::vector<qint32> &lhs_column_index_list,
                                QAbstractTableModel *rhs_model,
                                const qint32 rhs_row,
                                const std::vector<qint32> &rhs_column_index_list,
                                const Qt::ItemDataRole role = Qt::DisplayRole);*/
    void addFromTableModel(const column_data::ColumnIndexList &columns,
                           const Qt::ItemDataRole role = Qt::DisplayRole);
    void addFromTableModel(QAbstractTableModel *model,
                           const qint32 row,
                           const qint32 column_count,
                           const Qt::ItemDataRole role = Qt::DisplayRole);
    void addFromTreeModel(QAbstractTableModel *model,
                          const qint32 parent_row,
                          const qint32 column_count,
                          const Qt::ItemDataRole role = Qt::DisplayRole);
 
    // Column data
    std::vector<qint32> columnList(const qint32 column_count) const;
 
    // Convert value
    QDate toDate(const QVariant &value) const;
 
    // Date format
    static QString date_format_;
 
    // File data
    quint8 file_extension_;
    QString file_name_;
    QString path_;
 
    // File extensions (functions)
    static QHash<QString, quint8> fileExtensions();
    static QString filterText(const qint32 type);
 
    // File extensions (members)
    enum ENUM_FILE_EXTENSIONS { CSV, XLSX, FILE_EXTENSION_COUNT };
 
    // Header
    qint32 header_count_{2};
 
    // Progress display
    bool hide_progress_{false};
 
    // Row data: get data
    std::vector<QVariant> *currentHeaderRow();
    std::vector<QVariant> *currentRow();
};
} // namespace ehm_dal::spreadsheet