#include "EditIndexDialog.h"
#include "ui_EditIndexDialog.h"
#include "sqlitedb.h"

#include <QMessageBox>
#include <QPushButton>

EditIndexDialog::EditIndexDialog(DBBrowserDB& db, const sqlb::ObjectIdentifier& indexName, bool createIndex, QWidget* parent)
 : QDialog(parent),
 pdb(db),
 curIndex(indexName),
 index(indexName.name()),
 newIndex(createIndex),
 ui(new Ui::EditIndexDialog),
 m_sRestorePointName(pdb.generateSavepointName("editindex"))
{
 // Create UI
 ui->setupUi(this);
 ui->sqlTextEdit->setReadOnly(true);

 // Get list of tables, sort it alphabetically and fill the combobox
 std::map<std::string, sqlb::ObjectIdentifier> dbobjs; // Map from display name to full object identifier
 if(newIndex) // If this is a new index, offer all tables of all database schemata
 {
 for(const auto& it : pdb.schemata)
 {
 auto tables = it.second.equal_range("table");
 for(auto jt=tables.first;jt!=tables.second;++jt)
 {
 // Only show the schema name for non-main schemata
 sqlb::ObjectIdentifier obj(it.first, jt->second->name());
 dbobjs.insert({obj.toDisplayString(), obj});
 }
 }
 } else { // If this is an existing index, only offer tables of the current database schema
 auto tables = pdb.schemata[curIndex.schema()].equal_range("table");
 for(auto it=tables.first;it!=tables.second;++it)
 {
 // Only show the schema name for non-main schemata
 sqlb::ObjectIdentifier obj(curIndex.schema(), it->second->name());
 dbobjs.insert({obj.toDisplayString(), obj});
 }
 }
 ui->comboTableName->blockSignals(true);
 for(auto it=dbobjs.cbegin();it!=dbobjs.cend();++it)
 ui->comboTableName->addItem(QIcon(QString(":icons/table")), QString::fromStdString(it->first), QString::fromStdString(it->second.toSerialised()));
 ui->comboTableName->blockSignals(false);

 QHeaderView *tableHeaderView = ui->tableIndexColumns->horizontalHeader();
 tableHeaderView->setSectionResizeMode(0, QHeaderView::Stretch);

 // Editing an existing index?
 if(!newIndex)
 {
 // Load the current layout and fill in the dialog fields
 index = *(pdb.getObjectByName<sqlb::Index>(curIndex));

 ui->editIndexName->blockSignals(true);
 ui->editIndexName->setText(QString::fromStdString(index.name()));
 ui->editIndexName->blockSignals(false);
 ui->checkIndexUnique->blockSignals(true);
 ui->checkIndexUnique->setChecked(index.unique());
 ui->checkIndexUnique->blockSignals(false);
 ui->comboTableName->blockSignals(true);
 ui->comboTableName->setCurrentText(QString::fromStdString(index.table()));
 ui->comboTableName->blockSignals(false);
 ui->editPartialClause->blockSignals(true);
 ui->editPartialClause->setText(QString::fromStdString(index.whereExpr()));
 ui->editPartialClause->blockSignals(false);

 tableChanged(QString::fromStdString(index.table()), true);
 } else {
 tableChanged(ui->comboTableName->currentText(), false);
 }

 // Add event handler for index column name changes. These are only allowed for expression columns, though.
 connect(ui->tableIndexColumns, &QTableWidget::itemChanged,
 [=](QTableWidgetItem* item)
 {
 index.fields[static_cast<size_t>(item->row())].setName(item->text().toStdString());
 updateSqlText();
 });

 // Create a savepoint to revert back to
 pdb.setSavepoint(m_sRestorePointName);
}

EditIndexDialog::~EditIndexDialog()
{
 delete ui;
}

void EditIndexDialog::tableChanged(const QString& new_table, bool initialLoad)
{
 // Set the table name and clear all index columns
 if(!initialLoad)
 {
 index.setTable(sqlb::ObjectIdentifier(ui->comboTableName->currentData().toString().toStdString()).name());
 index.fields.clear();
 }

 // Stop here if table name is empty
 if(new_table.isEmpty())
 {
 // Call checkInput() before to make sure the OK button is disabled
 checkInput();
 return;
 }

 updateColumnLists();
}

void EditIndexDialog::updateColumnLists()
{
 // Fill the table column list
 sqlb::TablePtr table = pdb.getObjectByName<sqlb::Table>(sqlb::ObjectIdentifier(ui->comboTableName->currentData().toString().toStdString()));
 if(!table)
 return;
 sqlb::FieldInfoList tableFields = table->fieldInformation();
 ui->tableTableColumns->setRowCount(static_cast<int>(tableFields.size()));
 int tableRows = 0;
 for(size_t i=0;i<tableFields.size();++i)
 {
 // When we're doing the initial loading and this field already is in the index to edit, then don't add it to the
 // list of table columns. It will be added to the list of index columns in the next step. When this is not the initial
 // loading, the index column list is empty, so this check will always be true.
 if(sqlb::findField(index, tableFields.at(i).name) == index.fields.end())
 {
 // Put the name of the field in the first column
 QTableWidgetItem* name = new QTableWidgetItem(QString::fromStdString(tableFields.at(i).name));
 name->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 ui->tableTableColumns->setItem(tableRows, 0, name);

 // Put the data type in the second column
 QTableWidgetItem* type = new QTableWidgetItem(QString::fromStdString(tableFields.at(i).type));
 type->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 ui->tableTableColumns->setItem(tableRows, 1, type);

 tableRows++;
 }
 }

 // Set row count to actual count. This is needed for the intial loading, when some rows might have been omitted because they were used in the index
 ui->tableTableColumns->setRowCount(tableRows);

 // Fill the index column list. This is done separately from the table column to include expression columns (these are not found in the original
 // table) and to preserve the order of the index columns
 auto indexFields = index.fields;
 ui->tableIndexColumns->blockSignals(true);
 ui->tableIndexColumns->setRowCount(static_cast<int>(indexFields.size()));
 for(size_t i=0;i<indexFields.size();++i)
 {
 // Put the name of the field in the first column
 QTableWidgetItem* name = new QTableWidgetItem(QString::fromStdString(indexFields.at(i).name()));
 Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 if(indexFields.at(i).expression())
 flags |= Qt::ItemIsEditable;
 name->setFlags(flags);
 ui->tableIndexColumns->setItem(static_cast<int>(i), 0, name);

 // And put a combobox to select the order in which to index the field in the last column
 QComboBox* order = new QComboBox(this);
 order->addItem("");
 order->addItem("ASC");
 order->addItem("DESC");
 order->setCurrentText(QString::fromStdString(indexFields.at(i).order()).toUpper());
 ui->tableIndexColumns->setCellWidget(static_cast<int>(i), 1, order);
 connect(order, &QComboBox::currentTextChanged,
 [=](QString new_order)
 {
 auto colnum = sqlb::findField(index, indexFields.at(i).name());
 if(colnum != index.fields.end())
 {
 colnum->setOrder(new_order.toStdString());
 updateSqlText();
 }
 });
 }
 ui->tableIndexColumns->blockSignals(false);

 checkInput();
}

void EditIndexDialog::addToIndex(const QModelIndex& idx)
{
 // Get current row number
 int row;
 if(idx.isValid())
 row = idx.row();
 else
 row = ui->tableTableColumns->currentRow();

 // No row selected? Abort.
 if(row == -1)
 return;

 // Add field to index
 index.fields.emplace_back(
 ui->tableTableColumns->item(row, 0)->text().toStdString(), // Column name
 false, // Is expression
 ""); // Order

 // Update UI
 updateColumnLists();
}

void EditIndexDialog::removeFromIndex(const QModelIndex& idx)
{
 // Get current row number
 int row;
 if(idx.isValid())
 row = idx.row();
 else
 row = ui->tableIndexColumns->currentRow();

 // No row selected? Abort.
 if(row == -1)
 return;

 // If this is an expression column and the action was triggered by a double click event instead of a button click,
 // we won't remove the expression column because it's too likely that this was only done by accident by the user.
 // Instead just open the expression column for editing.
 if(index.fields[static_cast<size_t>(row)].expression() && sender() != ui->buttonFromIndex)
 {
 ui->tableIndexColumns->editItem(ui->tableIndexColumns->item(row, 0));
 return;
 }

 // Remove column from index
 sqlb::removeField(index, ui->tableIndexColumns->item(row, 0)->text().toStdString());

 // Update UI
 updateColumnLists();
}

void EditIndexDialog::checkInput()
{
 // Check if index name is set
 bool valid = true;
 if(ui->editIndexName->text().isEmpty())
 valid = false;

 // Check if a table is selected (this is especially important in the case where there are no tables in the database yet).
 if(ui->comboTableName->currentText().isNull())
 valid = false;

 // Check if index has any columns
 if(index.fields.size() == 0)
 valid = false;

 // Only activate OK button if index data is valid
 ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(valid);

 // Set the index name and the unique flag
 index.setName(ui->editIndexName->text().toStdString());
 index.setUnique(ui->checkIndexUnique->isChecked());
 index.setWhereExpr(ui->editPartialClause->text().toStdString());
 updateSqlText();
}

void EditIndexDialog::accept()
{
 // When editing an index, delete the old one first
 if(!newIndex)
 {
 if(!pdb.executeSQL(QString("DROP INDEX IF EXISTS %1;").arg(QString::fromStdString(curIndex.toString()))))
 {
 QMessageBox::warning(this, qApp->applicationName(), tr("Deleting the old index failed:\n%1").arg(pdb.lastError()));
 return;
 }
 }

 // Create the new index in the schema of the selected table
 if(pdb.executeSQL(QString::fromStdString(index.sql(sqlb::ObjectIdentifier(ui->comboTableName->currentData().toString().toStdString()).schema()))))
 QDialog::accept();
 else
 QMessageBox::warning(this, QApplication::applicationName(), tr("Creating the index failed:\n%1").arg(pdb.lastError()));
}

void EditIndexDialog::reject()
{
 // Rollback to our savepoint
 pdb.revertToSavepoint(m_sRestorePointName);

 QDialog::reject();
}

void EditIndexDialog::updateSqlText()
{
 ui->sqlTextEdit->setText(QString::fromStdString(index.sql(sqlb::ObjectIdentifier(ui->comboTableName->currentData().toString().toStdString()).schema())));
}

void EditIndexDialog::moveColumnUp()
{
 moveCurrentColumn(false);
}

void EditIndexDialog::moveColumnDown()
{
 moveCurrentColumn(true);
}

void EditIndexDialog::moveCurrentColumn(bool down)
{
 // Get current row number and calculate row number after the movement. Check the values
 int currentRow = ui->tableIndexColumns->currentRow();
 if(currentRow == -1)
 return;
 int newRow = currentRow + (down ? 1 : -1);
 if(newRow < 0)
 return;
 if(newRow >= ui->tableIndexColumns->rowCount())
 return;

 // Swap the columns
 std::swap(index.fields[static_cast<size_t>(currentRow)], index.fields[static_cast<size_t>(newRow)]);

 // Update UI
 updateColumnLists();

 // Select old row at new position
 ui->tableIndexColumns->selectRow(newRow);
}

void EditIndexDialog::addExpressionColumn()
{
 // Check if there already is an empty expression column
 auto field_it = sqlb::findField(index, "");
 int row = static_cast<int>(std::distance(index.fields.begin(), field_it));
 if(field_it == index.fields.end())
 {
 // There is no empty expression column yet, so add one.

 // Add new expression column to the index
 index.fields.emplace_back(
 "", // Column name
 true, // Is expression
 ""); // Order

 // Update UI
 updateColumnLists();

 // Get row number of new column
 row = ui->tableIndexColumns->rowCount() - 1;
 }

 // Now we should have the row number of the empty expression column, no matter if it was newly added or it already existed.
 // Select the row for editing
 ui->tableIndexColumns->editItem(ui->tableIndexColumns->item(row, 0));
}