#ifndef CRUDMODEL_H
#define CRUDMODEL_H

#include <QAbstractTableModel>
#include "ASyncDBConnection.h"
#include "PgClass.h"
#include "PgConstraint.h"
#include "Pgsql_Connection.h"
#include <map>
#include <memory>
#include <vector>
#include <boost/optional.hpp>

class PgConstraint;
class OpenDatabase;
class ASyncWindow;

/**
 * @brief The CrudModel class
 *
 * Features
 * - order by one or more user selectable columns
 * - user filter condition
 * - user limit and offset
 * - hide columns (will not be retrieved can greatly speed up things when you disable wide columns)
 * - can use foreign keys to display dropdown
 *
 * How to load data?
 * - 2D array of QVariants won't be efficient
 * - 2D array of strings
 * - We do know the type of a single column is fixed
 * - Keep data in Result and only load data in replacement rows
 * std::string has short string optimization so this probably means
 *  that a two dimensional array of std::string objects could actually be quite efficient!
 */
class CrudModel: public QAbstractTableModel {
	Q_OBJECT
public:
	explicit CrudModel(ASyncWindow *async_win);
	~CrudModel();

	void setConfig(std::shared_ptr<OpenDatabase> db, const PgClass &table);


	QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;


	// Basic functionality:
	int rowCount(const QModelIndex &parent = QModelIndex()) const override;
	int columnCount(const QModelIndex &parent = QModelIndex()) const override;

	virtual QVariant data(const QModelIndex &index, int role) const override;
	virtual Qt::ItemFlags flags(const QModelIndex &) const override;

private:
	ASyncWindow * m_asyncWindow;
	std::shared_ptr<OpenDatabase> m_database;
	PgClass m_table;
	boost::optional<PgConstraint> m_primaryKey;
	ASyncDBConnection m_dbConn;
	bool callLoadData = false;


//	using RowData = std::vector<std::string>;
//	using RowDataPtr = std::unique_ptr<RowData>;
//	/** Choosen for a vector of pointers while vector is relatively slow with insertion and removal in the middle
//	 * I hope the small size of the elements will make this not much of an issue while the simple linear and sequential
//	 * nature of a vector will keep memory allocation fairly efficient.
//	 */
//	using RowList = std::vector<RowDataPtr>;

	std::shared_ptr<Pgsql::Result> m_roData;
	void loadData();
	void loadIntoModel(std::shared_ptr<Pgsql::Result> data);

//	std::shared_ptr<RowList> resultToRowList(std::shared_ptr<Pgsql::Result> result);

	using Value = boost::optional<std::string>;

	/** Remembers the values that have been applies to a row after the original result was retrieved.
	 */
	class ModifiedRow {
	public:

	private:
		std::vector<Value> m_values;
	};
	using ModifiedRowList = std::map<int, ModifiedRow>;

	/** Manages the changes for the current row
	 *
	 */
	class PendingChanges {
	public:

	private:
		int m_currentRow;
		std::vector<std::string> m_currentPKeyValues; ///< The values to use for updating the row, for new rows this list is empty
		std::map<int16_t, Value> m_values; ///< values that need to be applied
	};

	using DeletedList = std::vector<int>; // These are the original indexes before there were any modifications

	PendingChanges m_pendingChanges;
	/** Maintains a list of all modified rows.
	 *
	 * The key values are the indexes of the row before any rows were deleted.
	 */
	ModifiedRowList m_modifiedRowList;


	// Alternative, vector of rows
	class Row {
	public:
		int resultRow; ///< row index in original result, -1 for new rows
		std::vector<Value> currentValues; ///

	};


	QVariant getData(const QModelIndex &index) const;
	Oid getType(int column) const;

private slots:

	void connectionStateChanged(ASyncDBConnection::State state);
//	void queryResult(std::shared_ptr<Pgsql::Result> result);
//	void queryError();

//	void dataProcessingFutureFinished();
};

#endif // CRUDMODEL_H