#include "sqlitedb.h"
#include "ForeignKeyEditorDelegate.h"

#include <QComboBox>
#include <QLineEdit>
#include <QPushButton>
#include <QHBoxLayout>

class ForeignKeyEditor : public QWidget
{
 Q_OBJECT

public:
 explicit ForeignKeyEditor(QWidget* parent = nullptr)
 : QWidget(parent)
 , tablesComboBox(new QComboBox(this))
 , idsComboBox(new QComboBox(this))
 , clauseEdit(new QLineEdit(this))
 , m_btnReset(new QPushButton(tr("&Reset"), this))
 {
 idsComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 clauseEdit->setPlaceholderText(tr("Foreign key clauses (ON UPDATE, ON DELETE etc.)"));

 QHBoxLayout* layout = new QHBoxLayout(this);
 layout->addWidget(tablesComboBox);
 layout->addWidget(idsComboBox);
 layout->addWidget(clauseEdit);
 layout->addWidget(m_btnReset);
 layout->setSpacing(0);
 layout->setMargin(0);
 setLayout(layout);

 connect(m_btnReset, &QPushButton::clicked, [&]
 {
 tablesComboBox->setCurrentIndex(-1);
 idsComboBox->setCurrentIndex(-1);
 clauseEdit->clear();
 });

 connect(tablesComboBox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
 [=](int index)
 {
 // reset ids combo box
 idsComboBox->setCurrentIndex(-1);

 // disable clauses editor if none of tables is selected
 bool enableClausesEditor = (index!= -1);
 clauseEdit->setEnabled(enableClausesEditor);
 });
 }

 QString getSql() const
 {
 if (tablesComboBox->currentText().isEmpty())
 return QString();

 const QString table = sqlb::escapeIdentifier(tablesComboBox->currentText());
 const QString clauses = clauseEdit->text();

 QString id = idsComboBox->currentText();
 if (!id.isEmpty())
 id = QString("(%1)").arg(sqlb::escapeIdentifier(id));

 return QString("%1%2 %3")
 .arg(table)
 .arg(id)
 .arg(clauses)
 .trimmed();
 }

 QComboBox* tablesComboBox;
 QComboBox* idsComboBox;
 QLineEdit* clauseEdit; // for ON CASCADE and such

private:
 QPushButton* m_btnReset;
};

ForeignKeyEditorDelegate::ForeignKeyEditorDelegate(const DBBrowserDB& db, sqlb::Table& table, QObject* parent)
 : QStyledItemDelegate(parent)
 , m_db(db)
 , m_table(table)
{
 for(const auto& it : m_db.schemata)
 {
 for(const auto& jt : it.second)
 {
 if(jt.second->type() == sqlb::Object::Types::Table)
 m_tablesIds.insert({jt.second->name(), std::dynamic_pointer_cast<sqlb::Table>(jt.second)->fieldNames()});
 }
 }
}

QWidget* ForeignKeyEditorDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
 Q_UNUSED(option)
 Q_UNUSED(index)

 ForeignKeyEditor* editor = new ForeignKeyEditor(parent);
 editor->setAutoFillBackground(true);

 connect(editor->tablesComboBox, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged),
 [=](const QString& tableName)
 {
 QComboBox* box = editor->idsComboBox;
 box->clear();
 box->addItem(QString()); // for those heroes who don't like to specify key explicitly
 for(const auto& n : m_tablesIds[tableName.toStdString()])
 box->addItem(QString::fromStdString(n));
 box->setCurrentIndex(0);
 });

 editor->tablesComboBox->clear();
 for(const auto& i : m_tablesIds)
 editor->tablesComboBox->addItem(QString::fromStdString(i.first));

 return editor;
}

void ForeignKeyEditorDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
{
 ForeignKeyEditor* fkEditor = static_cast<ForeignKeyEditor*>(editor);

 size_t column = static_cast<size_t>(index.row()); // weird? I know right
 const sqlb::Field& field = m_table.fields.at(column);
 auto fk = std::dynamic_pointer_cast<sqlb::ForeignKeyClause>(m_table.constraint({field.name()}, sqlb::Constraint::ForeignKeyConstraintType));
 if (fk) {
 fkEditor->tablesComboBox->setCurrentText(QString::fromStdString(fk->table()));
 fkEditor->clauseEdit->setText(QString::fromStdString(fk->constraint()));
 if (!fk->columns().empty())
 fkEditor->idsComboBox->setCurrentText(QString::fromStdString(fk->columns().front()));
 } else {
 fkEditor->tablesComboBox->setCurrentIndex(-1);
 }
}

void ForeignKeyEditorDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
{
 ForeignKeyEditor* fkEditor = static_cast<ForeignKeyEditor*>(editor);
 QString sql = fkEditor->getSql();

 size_t column = static_cast<size_t>(index.row());
 const sqlb::Field& field = m_table.fields.at(column);
 if (sql.isEmpty()) {
 // Remove the foreign key
 m_table.removeConstraints({field.name()}, sqlb::Constraint::ConstraintTypes::ForeignKeyConstraintType);
 } else {
 // Set the foreign key
 sqlb::ForeignKeyClause* fk = new sqlb::ForeignKeyClause;

 const QString table = fkEditor->tablesComboBox->currentText();
 const std::string id = fkEditor->idsComboBox->currentText().toStdString();
 const QString clause = fkEditor->clauseEdit->text();

 fk->setTable(table.toStdString());
 fk->column_list = { field.name() };

 if (!id.empty())
 fk->setColumns({id});

 if (!clause.trimmed().isEmpty()) {
 fk->setConstraint(clause.toStdString());
 }

 m_table.setConstraint(sqlb::ConstraintPtr(fk));
 }

 model->setData(index, sql);
}

void ForeignKeyEditorDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
 Q_UNUSED(index)

 editor->setGeometry(option.rect);
}

void ForeignKeyEditorDelegate::updateTablesList(const std::string& oldTableName)
{
 // this is used for recursive table constraints when
 // table column references column within same table
 m_tablesIds.erase(oldTableName);
 m_tablesIds.insert({m_table.name(), m_table.fieldNames()});
}

#include "ForeignKeyEditorDelegate.moc"