/*
    QAD - Qt ADvanced

    Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef SQL_TABLE_WIDGET_H
#define SQL_TABLE_WIDGET_H

#include "qad_sql_table_export.h"
#include "qpiconfig.h"

#include <QAction>
#include <QActionGroup>
#include <QBoxLayout>
#include <QCheckBox>
#include <QComboBox>
#include <QDateTimeEdit>
#include <QDebug>
#include <QDoubleSpinBox>
#include <QElapsedTimer>
#include <QHeaderView>
#include <QLabel>
#include <QLineEdit>
#include <QMenu>
#include <QMouseEvent>
#include <QScrollBar>
#include <QSqlDatabase>
#include <QSqlError>
#include <QSqlField>
#include <QSqlIndex>
#include <QSqlQuery>
#include <QSqlQueryModel>
#include <QSqlRecord>
#include <QSqlTableModel>
#include <QStyledItemDelegate>
#include <QTableView>
#include <QToolButton>


struct QAD_SQL_TABLE_EXPORT ColumnProperties {
	enum DataType {
		Unknown,
		Int,
		Float,
		Chars,
		Text,
		Binary,
		Date,
		Time,
		DateTime
	};
	ColumnProperties(const QString & table_,
	                 const QString & type_,
	                 const QString & name_,
	                 const QString & def_,
	                 bool auto_,
	                 bool prim_,
	                 bool option_);
	bool isRelation() const { return (!relation_key.isEmpty() && !relation_column.isEmpty()); }
	QString shortName() const {
		if (!isRelation()) return name;
		return relation_column;
	}
	QString fullName() const {
		if (!isRelation()) return table + "." + name;
		return (relation_table.isEmpty() ? "" : relation_table + ".") + relation_column;
	}
	DataType getType() const {
		if (!isRelation()) return type;
		return relation_type;
	}
	static DataType typeFromString(const QString & n);

	DataType type;
	int size;
	bool auto_increment;
	bool primary;
	bool optional;
	bool visible;
	bool is_text;
	QString table;
	QString name;
	QString relation_table;
	QString relation_key;
	QString relation_column;
	QList<QPair<QString, QString>> relation_list; // <id, relation_column>
	DataType relation_type;
	int key_column;
	QString def;
};


struct QAD_SQL_TABLE_EXPORT TableColumns {
	int mapColumn(int abs_ind) const {
		if (abs_ind <= 0 || abs_ind >= column_indexes.size() + 1) return 0;
		return column_indexes[abs_ind - 1];
	}
	QVector<int> column_indexes;
	QList<ColumnProperties> columns;
};


class QAD_SQL_TABLE_EXPORT SQLQueryModel: public QSqlQueryModel {
	Q_OBJECT

public:
	explicit SQLQueryModel(QString & t, QString & conn, QList<ColumnProperties> & cp, QVector<int> & ci, QObject * parent = 0)
		: QSqlQueryModel(parent)
		, table_(t)
		, column_props(cp)
		, column_indexes(ci)
		, conn_name(conn) {
		;
	}
	virtual QVariant data(const QModelIndex & item, int role = Qt::DisplayRole) const;

protected:
	virtual Qt::ItemFlags flags(const QModelIndex &) const { return (Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable); }
	virtual bool setData(const QModelIndex & index, const QVariant & value, int role = Qt::EditRole);
	int mapColumn(int abs_ind) const {
		if (abs_ind <= 0 || abs_ind >= column_indexes.size() + 1) return 0;
		return column_indexes[abs_ind - 1];
	}
	QString & table_;
	QList<ColumnProperties> & column_props;
	QVector<int> & column_indexes;
	QString & conn_name;
signals:
	void updateTable(bool save_selection);
	void tableChanged();
};


class QAD_SQL_TABLE_EXPORT SQLUniEdit: public QWidget {
	Q_OBJECT

public:
	explicit SQLUniEdit(const ColumnProperties & prop, const QString & conn_name, QWidget * parent = 0);
	~SQLUniEdit() {
		for (int i = 0; i < w_.size(); ++i)
			deleteW(*w_[i]);
	}
	void setProp(const ColumnProperties & p);
	QString value(bool for_insert = false);
	void clear() { setValue(QVariant()); }

private:
	void deleteW(QWidget * w) {
		if (w != 0) delete w;
	}
	void resizeW(QWidget * w) {
		if (w != 0) w->setGeometry(QRect(0, 0, width(), height()));
	}
	void resizeEvent(QResizeEvent *) {
		for (int i = 0; i < w_.size(); ++i)
			resizeW(*w_[i]);
	}
	bool eventFilter(QObject * o, QEvent * e);
	QLineEdit * wtext;
	QSpinBox * wint;
	QDoubleSpinBox * wfloat;
	QDateEdit * wdate;
	QTimeEdit * wtime;
	QDateTimeEdit * wdatetime;
	QComboBox * wrelation;
	QList<QWidget **> w_;
	ColumnProperties prop_;
	QString connection_name;
private slots:
	void value_text(QString value) { valueChanged(value); }
	void value_int(int value) { valueChanged(value); }
	void value_float(double value) { valueChanged(value); }
	void value_date(QDate value) { valueChanged(value); }
	void value_time(QTime value) { valueChanged(value); }
	void value_datetime(QDateTime value) { valueChanged(value); }
public slots:
	void setValue(const QVariant & value);
	void updateRelation();
signals:
	void valueChanged(const QVariant &);
};


class QAD_SQL_TABLE_EXPORT SQLNewEdit: public QWidget {
	Q_OBJECT
	friend class SQLTableWidget;

public:
	explicit SQLNewEdit(const ColumnProperties & prop, const QString & conn_name, QWidget * parent = 0);
	~SQLNewEdit() {
		delete line;
		delete check;
	}
	void setProp(const ColumnProperties & p);
	bool isEnabled() const { return check->isChecked(); }
	QString value() const { return line->value(true); }
	void clear() { line->clear(); }

private:
	ColumnProperties prop_;
	SQLUniEdit * line;
	QCheckBox * check;
};


class QAD_SQL_TABLE_EXPORT SQLFilterEdit: public QWidget {
	Q_OBJECT
	friend class SQLTableWidget;

public:
	explicit SQLFilterEdit(const ColumnProperties & prop, const QString & conn_name, QWidget * parent = 0);
	~SQLFilterEdit() {
		delete line;
		delete combo;
	}
	void setProp(const ColumnProperties & p) {
		prop_ = p;
		line->setProp(p);
	}
	QString filter() const;
	bool isEmpty() const { return line->value().isEmpty() || combo->currentIndex() == 0; }
	void clear();

private:
	ColumnProperties prop_;
	SQLUniEdit * line;
	QComboBox * combo;
private slots:
	void value_changed() {
		if (combo->currentIndex() == 0) combo->setCurrentIndex(prop_.is_text ? 2 : 1);
	}
public slots:
signals:
	void filterChanged();
};


class QAD_SQL_TABLE_EXPORT SQLItemDelegate: public QStyledItemDelegate {
	Q_OBJECT

public:
	explicit SQLItemDelegate(QList<ColumnProperties> & cp, QVector<int> & ci, bool & ro, const QString & conn_name, QObject * parent = 0);
	~SQLItemDelegate() { ; }

private:
	QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const;
	QString displayText(const QVariant & value, const QLocale & locale) const;
	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const;
	int mapColumn(int abs_ind) const {
		if (abs_ind <= 0 || abs_ind >= column_indexes.size() + 1) return 0;
		return column_indexes[abs_ind - 1];
	}
	void setConnectionName(const QString & conn_name) { connection_name = conn_name; }
	QList<ColumnProperties> & column_props;
	QVector<int> & column_indexes;
	bool & read_only;
	QString connection_name;
private slots:
public slots:
signals:
};


namespace Ui {
class SQLTableWidget;
}


class QAD_SQL_TABLE_EXPORT SQLTableWidget: public QWidget {
	Q_OBJECT
	Q_PROPERTY(QString tableName READ tableName WRITE setTableName)
	Q_PROPERTY(QString connectionName READ connectionName WRITE setConnectionName)
	Q_PROPERTY(bool lineNewVisible READ lineNewVisible WRITE setLineNewVisible)
	Q_PROPERTY(bool lineFilterVisible READ lineFilterVisible WRITE setLineFilterVisible)
	Q_PROPERTY(bool readOnly READ readOnly WRITE setReadOnly)
	Q_PROPERTY(bool debugEnabled READ isDebugEnabled WRITE setDebugEnabled)
	friend class SQLItemDelegate;
	friend class SQLUniEdit;

public:
	SQLTableWidget(QWidget * parent = 0);
	virtual ~SQLTableWidget();

	bool isTableExists() const { return table_opened; }
	const QString & tableName() const { return table_; }

	QTableView * tableView();
	bool readOnly() const { return read_only; }

	void setDebugEnabled(bool on) { debug = on; }
	bool isDebugEnabled() const { return debug; }

	const ColumnProperties * columnProperty(int index) const {
		if (index < 0 || index >= column_props.count()) return 0;
		return &(column_props[index]);
	}
	const ColumnProperties * columnProperty(const QString & name) const { return columnProperty(columnByName(name)); }
	const QList<ColumnProperties> & columnProperties() const { return column_props; }
	QStringList columnNames() const {
		QStringList sl;
		foreach(const ColumnProperties & i, column_props)
			sl << i.name;
		return sl;
	}
	int columnsCount() const { return column_props.size(); }
	bool isColumnVisible(int ind) {
		if (!columnExists(ind)) return false;
		return column_props[ind].visible;
	}
	bool isColumnVisible(const QString & name) {
		if (!columnExists(name)) return false;
		return column_props[columnByName(name)].visible;
	}
	bool isColumnHidden(int ind) {
		if (!columnExists(ind)) return true;
		return !column_props[ind].visible;
	}
	bool isColumnHidden(const QString & name) {
		if (!columnExists(name)) return true;
		return !column_props[columnByName(name)].visible;
	}
	void setColumnVisible(int ind, bool visible);
	void setColumnVisible(const QString & name, bool visible) {
		col_vis[name] = visible;
		setColumnVisible(columnByName(name), visible);
	}
	void setColumnHidden(int ind, bool hidden) { setColumnVisible(ind, !hidden); }
	void setColumnHidden(const QString & name, bool hidden) {
		col_vis[name] = !hidden;
		setColumnVisible(columnByName(name), !hidden);
	}

	bool lineNewVisible() const;
	bool lineFilterVisible() const;
	bool addRelation(const QString & this_column, const QString & other_table, const QString & other_key, const QString & other_column);
	void addTranslation(const QString & file);
	void addFixedColumnTranslation(const QString & col_name, const QString & col_tr, const QString & col_tt = QString());
	void fetchMore() {
		if (model) model->fetchMore();
	}
	void fetchAll() {
		if (model)
			while (model->canFetchMore())
				model->fetchMore();
	}
	void selectId(int id);

	void setAdditionalActions(QList<QAction *> a);

	QSqlRecord headerRecord() const {
		if (model) return model->record();
		return QSqlRecord();
	}
	QSqlRecord currentRecord() const;

	void setCustomQuery(const QString & q);
	void setCustomColumnNames(const QStringList & cn) {
		custom_col_names = cn;
		updateTable();
	}

	static bool isTableExists(const QString & table, const QString & conn_name = QLatin1String(QSqlDatabase::defaultConnection)) {
		return QSqlDatabase::database(conn_name).tables().contains(table, Qt::CaseInsensitive);
	}

	static bool
	executeScript(const QString & text, QSqlDatabase db = QSqlDatabase::database(), bool skip_errors = false, bool sqlite = false);
	static bool
	executeScriptFile(const QString & file, QSqlDatabase db = QSqlDatabase::database(), bool skip_errors = false, bool sqlite = false);

	static bool isConnectedToDatabase(const QString & conn_name = QLatin1String(QSqlDatabase::defaultConnection)) {
		return QSqlDatabase::database(conn_name, false).isOpen();
	}
	static bool connectToDatabase(const QString & config, const QString & conn_name = QLatin1String(QSqlDatabase::defaultConnection));

	QString connectionName() const { return connection_name; }

private:
	static QString preprocessScript(QString text);

	bool eventFilter(QObject * o, QEvent * e);
	void timerEvent(QTimerEvent *);
	void changeEvent(QEvent * e);
	void stopTimer() {
		if (timer != 0) killTimer(timer);
		timer = 0;
	}
	bool checkTable();
	QStringList getTableColumns(const QString & t);
	QString getColumnType(const QString & t, const QString & c);
	static QList<QPair<QString, QString>>
	getColumnValues(const QString & t, const QString & k, const QString & c, const QString & conn_name);
	void setTableVisible(bool on);
	int mapColumn(int abs_ind) const {
		if (abs_ind <= 0 || abs_ind >= column_indexes.size() + 1) return 0;
		return column_indexes[abs_ind - 1];
	}
	int columnByName(const QString & name) const {
		for (int i = 0; i < column_props.size(); ++i)
			if (column_props[i].name == name) return i;
		return -1;
	}
	bool columnExists(int index) const { return (index >= 0 && index < column_props.size()); }
	bool columnExists(const QString & name) const {
		for (int i = 0; i < column_props.size(); ++i)
			if (column_props[i].name == name) return true;
		return false;
	}
	QPair<QString, QString> trColumn(const QString & n);
	QString tableNames();
	QString columnNames();
	QString columnFilters();
	QString columnRelations();

	Ui::SQLTableWidget * ui;
	QString table_, cquery, custom_query;
	QStringList custom_col_names;
	SQLQueryModel * model;
	// QAction act_add, act_del;
	QList<ColumnProperties> column_props;
	QList<SQLNewEdit *> column_news;
	QList<SQLFilterEdit *> column_filters;
	QVector<int> column_indexes;
	QStringList wait_rels;
	QMenu popup_menu, popup_col, popup_filter;
	QElapsedTimer tm;
	QActionGroup filters_group;
	QAction * action_del;
	QList<QAction *> add_actions;
	QMap<QString, QPair<QString, QString>> translates, fixed_translates;
	QMap<QString, bool> col_vis;
	int timer;
	bool filters_active, table_opened, read_only, first_update, debug;
	static QString _dir;
	QPoint pp;
	QString connection_name;


public slots:
	void setTableName(const QString & t);
	void setLineNewVisible(bool on);
	void setLineFilterVisible(bool on);
	void setReadOnly(bool yes);
	void updateTable(bool save_selection = false);
	void setConnectionName(const QString & conn_name);

private slots:
	void on_buttonAdd_clicked();
	void on_actionFiltersClear_triggered();
	void on_view_clicked(const QModelIndex & index);
	void header_sectionResized(int logicalIndex, int oldSize, int newSize);
	void header_sortIndicatorChanged(int logicalIndex, Qt::SortOrder order);
	void scrolled(int value);
	void del_triggered();
	void column_triggered(bool on);

signals:
	void rowClicked(int row);
	void recordClicked(QSqlRecord rec);
	void selectionChanged();
	void tableChanged();
};


#endif // MYSQLTABLE_H