//=============================================================================
//
//   File : ActionEditor.cpp
//   Creation date : Tue 29 Dec 2004 02:45:59 2002 GMT by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2004-2010 Szymon Stefanek (pragma at kvirc dot net)
//
//   This program is FREE software. You can redistribute it and/or
//   modify it under the terms of the GNU General Public License
//   as published by the Free Software Foundation; either version 2
//   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 General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program. If not, write to the Free Software Foundation,
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================
#include "ActionEditor.h"

#include "KviIconManager.h"
#include "KviOptions.h"
#include "KviLocale.h"
#include "KviImageDialog.h"
#include "KviConfigurationFile.h"
#include "KviFileUtils.h"
#include "KviScriptEditor.h"
#include "kvi_debug.h"
#include "KviApplication.h"
#include "KviKvsAliasManager.h"
#include "KviFileDialog.h"
#include "KviActionManager.h"
#include "KviAction.h"
#include "KviKvsUserAction.h"
#include "KviCustomToolBarManager.h"
#include "KviTalVBox.h"
#include "KviTalGroupBox.h"
#include "KviTalIconAndRichTextItemDelegate.h"
#include "kvi_fileextensions.h"

#include <QList>
#include <QSplitter>
#include <QLayout>
#include <QToolTip>
#include <QPushButton>
#include <QDir>
#include <QMessageBox>
#include <QLineEdit>
#include <QComboBox>
#include <QPainter>
#include <QTabWidget>
#include <QLabel>

extern ActionEditorWindow * g_pActionEditorWindow;

static QString g_szLastEditedAction;

#define LVI_ICON_SIZE 32
#define LVI_BORDER 4
#define LVI_SPACING 8
#define LVI_MINIMUM_CELL_WIDTH (LVI_MINIMUM_TEXT_WIDTH + LVI_BORDER + LVI_ICON_SIZE + LVI_SPACING + LVI_BORDER)

ActionEditorTreeWidgetItem::ActionEditorTreeWidgetItem(QTreeWidget * v, ActionData * a)
    : QTreeWidgetItem(v)
{
	m_pActionData = a;
	m_pTreeWidget = v;
	//setFlags(Qt::ItemIsUserSelectable);
	QString t = "<b>" + m_pActionData->m_szName + "</b>";
	t += R"(<br><font color="#454545" size="-1">)" + m_pActionData->m_szVisibleName + "</font>";
	m_szKey = m_pActionData->m_szName.toUpper();
	setText(0, t);
	QPixmap * p = g_pIconManager->getBigIcon(m_pActionData->m_szBigIcon);
	if(p)
		setIcon(0, *p);
}

ActionEditorTreeWidgetItem::~ActionEditorTreeWidgetItem()
{
	delete m_pActionData;
}

QString ActionEditorTreeWidgetItem::key(int, bool) const
{
	return m_szKey;
}

SingleActionEditor::SingleActionEditor(QWidget * par, ActionEditor * ed)
    : QWidget(par)
{
	m_pActionEditor = ed;
	m_pActionData = nullptr;

	QGridLayout * g = new QGridLayout(this);

	QLabel * l = new QLabel(__tr2qs_ctx("Name:", "editor"), this);
	g->addWidget(l, 0, 0);
	m_pNameEdit = new QLineEdit(this);
	g->addWidget(m_pNameEdit, 0, 1);
	m_pNameEdit->setToolTip(__tr2qs_ctx("Internal unique name for the action", "editor"));

	l = new QLabel(__tr2qs_ctx("Label:", "editor"), this);
	g->addWidget(l, 1, 0);
	m_pVisibleNameEdit = new QLineEdit(this);
	g->addWidget(m_pVisibleNameEdit, 1, 1);
	m_pVisibleNameEdit->setToolTip(__tr2qs_ctx("Visible name for this action.<br>This string will be displayed to the user so it is a good idea to use $tr() here", "editor"));

	QTabWidget * tw = new QTabWidget(this);
	g->addWidget(tw, 2, 0, 1, 2);

	// code tab
	QWidget * tab = new QWidget(tw);
	QGridLayout * gl = new QGridLayout(tab);

	m_pScriptEditor = KviScriptEditor::createInstance(tab);
	gl->addWidget(m_pScriptEditor, 0, 0);
	m_pScriptEditor->setToolTip(__tr2qs_ctx("Action code", "editor"));

	tw->addTab(tab, __tr2qs_ctx("Code", "editor"));

	// properties tab
	tab = new QWidget(tw);
	gl = new QGridLayout(tab);

	l = new QLabel(__tr2qs_ctx("Category:", "editor"), tab);
	gl->addWidget(l, 0, 0);
	m_pCategoryCombo = new QComboBox(tab);
	gl->addWidget(m_pCategoryCombo, 0, 1, 1, 3);
	m_pCategoryCombo->setToolTip(__tr2qs_ctx("Choose the category that best fits for this action", "editor"));

	l = new QLabel(__tr2qs_ctx("Description:", "editor"), tab);
	gl->addWidget(l, 1, 0);
	m_pDescriptionEdit = new QLineEdit(tab);
	gl->addWidget(m_pDescriptionEdit, 1, 1, 1, 3);
	m_pDescriptionEdit->setToolTip(__tr2qs_ctx("Visible short description for this action.<br>This string will be displayed to the user so it is a good idea to use $tr() here", "editor"));

	l = new QLabel(__tr2qs_ctx("Small icon:", "editor"), tab);
	gl->addWidget(l, 2, 0);
	m_pSmallIconEdit = new QLineEdit(tab);
	gl->addWidget(m_pSmallIconEdit, 2, 1);
	m_pSmallIconButton = new QToolButton(tab);
	m_pSmallIconButton->setMinimumSize(QSize(20, 20));
	connect(m_pSmallIconButton, SIGNAL(clicked()), this, SLOT(chooseSmallIcon()));
	gl->addWidget(m_pSmallIconButton, 2, 2);
	QString s = __tr2qs_ctx("The small icon associated to this action.<br>"
	                        "It will appear at least in the popup menus when this action is inserted.<br>"
	                        "It has to be 16x16 pixels.", "editor");

	m_pSmallIconEdit->setToolTip(s);
	m_pSmallIconButton->setToolTip(s);

	l = new QLabel(__tr2qs_ctx("Big icon:", "editor"), tab);
	gl->addWidget(l, 3, 0);
	m_pBigIconEdit = new QLineEdit(tab);
	gl->addWidget(m_pBigIconEdit, 3, 1);
	m_pBigIconButton = new QToolButton(tab);
	m_pBigIconButton->setMinimumSize(QSize(48, 48));
	m_pBigIconButton->setIconSize(QSize(32, 32));
	connect(m_pBigIconButton, SIGNAL(clicked()), this, SLOT(chooseBigIcon()));
	gl->addWidget(m_pBigIconButton, 3, 2, 2, 2);
	s = __tr2qs_ctx("The big icon associated to this action.<br>"
	                "It will appear at least in the toolbar buttons when this action is inserted.<br>"
	                "It has to be 32x32 pixels.", "editor");

	m_pBigIconEdit->setToolTip(s);
	m_pBigIconButton->setToolTip(s);

	l = new QLabel(__tr2qs_ctx("Key sequence:", "editor"), tab);
	gl->addWidget(l, 4, 0, 2, 1);
	m_pKeySequenceEdit = new QLineEdit(tab);
	gl->addWidget(m_pKeySequenceEdit, 4, 1, 2, 1);
	m_pKeySequenceEdit->setToolTip(__tr2qs_ctx("Optional keyboard sequence that will activate this action.<br>"
	                                           "The sequence has to be expressed as a string of up to four key codes separated by commas "
	                                           "eventually combined with the modifiers \"Ctrl\", \"Shift\", \"Alt\" and \"Meta\".<br>"
	                                           "Examples of such sequences are \"Ctrl+X\", \"Ctrl+Alt+Z\", \"Ctrl+X,Ctrl+C\".", "editor"));
	l = new QLabel(tab);
	gl->addWidget(l, 6, 0, 1, 4);

	gl->setColumnStretch(1, 1);
	gl->setRowStretch(6, 1);

	tw->addTab(tab, __tr2qs_ctx("Properties", "editor"));

	// flags tab
	tab = new QWidget(tw);
	gl = new QGridLayout(tab);

	m_pNeedsContextCheck = new QCheckBox(__tr2qs_ctx("Needs IRC context", "editor"), tab);
	connect(m_pNeedsContextCheck, SIGNAL(toggled(bool)), this, SLOT(needsContextCheckToggled(bool)));
	m_pNeedsContextCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled only when "
	                                             "the active window belongs to an IRC context", "editor"));

	gl->addWidget(m_pNeedsContextCheck, 0, 0, 1, 4);

	l = new QLabel(tab);
	l->setMinimumWidth(40);
	gl->addWidget(l, 1, 0);

	m_pNeedsConnectionCheck = new QCheckBox(__tr2qs_ctx("Needs IRC connection", "editor"), tab);
	connect(m_pNeedsConnectionCheck, SIGNAL(toggled(bool)), this, SLOT(needsConnectionCheckToggled(bool)));
	m_pNeedsConnectionCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled only when "
	                                                "the active window has an active IRC connection", "editor"));

	gl->addWidget(m_pNeedsConnectionCheck, 1, 0, 1, 4);

	l = new QLabel(tab);
	l->setMinimumWidth(40);
	gl->addWidget(l, 2, 1);

	m_pEnableAtLoginCheck = new QCheckBox(__tr2qs_ctx("Enable at login", "editor"), tab);
	m_pEnableAtLoginCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled also during the login operations. "
	                                              "i.e. when the logical IRC connection hasn't been established yet.", "editor"));

	gl->addWidget(m_pEnableAtLoginCheck, 2, 0, 1, 4);

	m_pSpecificWindowsCheck = new QCheckBox(__tr2qs_ctx("Enable only in specified windows", "editor"), tab);
	connect(m_pSpecificWindowsCheck, SIGNAL(toggled(bool)), this, SLOT(specificWindowsCheckToggled(bool)));
	m_pSpecificWindowsCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled only when "
	                                                "the active window is of a specified type", "editor"));

	gl->addWidget(m_pSpecificWindowsCheck, 3, 0, 1, 4);

	m_pWindowConsoleCheck = new QCheckBox(__tr2qs_ctx("Enable in console windows", "editor"), tab);
	m_pWindowConsoleCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled only when "
	                                              "the active window is a console", "editor"));

	connect(m_pWindowConsoleCheck, SIGNAL(toggled(bool)), this, SLOT(consoleWindowsCheckToggled(bool)));
	gl->addWidget(m_pWindowConsoleCheck, 4, 1, 1, 4);

	m_pConsoleOnlyIfUsersSelectedCheck = new QCheckBox(__tr2qs_ctx("Only if there are selected users", "editor"), tab);
	m_pConsoleOnlyIfUsersSelectedCheck->setToolTip(__tr2qs_ctx("This will enable the action only if there are "
	                                                           "selected users in the active window", "editor"));

	gl->addWidget(m_pConsoleOnlyIfUsersSelectedCheck, 5, 1, 1, 4);

	m_pWindowChannelCheck = new QCheckBox(__tr2qs_ctx("Enable in channel windows", "editor"), tab);
	m_pWindowChannelCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled only when "
	                                              "the active window is a channel", "editor"));

	connect(m_pWindowChannelCheck, SIGNAL(toggled(bool)), this, SLOT(channelWindowsCheckToggled(bool)));
	gl->addWidget(m_pWindowChannelCheck, 6, 1, 1, 4);

	m_pChannelOnlyIfUsersSelectedCheck = new QCheckBox(__tr2qs_ctx("Only if there are selected users", "editor"), tab);
	m_pChannelOnlyIfUsersSelectedCheck->setToolTip(__tr2qs_ctx("This will enable the action only if there are "
	                                                           "selected users in the active window", "editor"));

	gl->addWidget(m_pChannelOnlyIfUsersSelectedCheck, 7, 1, 1, 4);

	m_pWindowQueryCheck = new QCheckBox(__tr2qs_ctx("Enable in query windows", "editor"), tab);
	m_pWindowQueryCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled only when "
	                                            "the active window is a query", "editor"));

	connect(m_pWindowQueryCheck, SIGNAL(toggled(bool)), this, SLOT(queryWindowsCheckToggled(bool)));
	gl->addWidget(m_pWindowQueryCheck, 8, 1, 1, 4);

	m_pQueryOnlyIfUsersSelectedCheck = new QCheckBox(__tr2qs_ctx("Only if there are selected users", "editor"), tab);
	m_pQueryOnlyIfUsersSelectedCheck->setToolTip(__tr2qs_ctx("This will enable the action only if there are "
	                                                         "selected users in the active window", "editor"));

	gl->addWidget(m_pQueryOnlyIfUsersSelectedCheck, 9, 1, 1, 4);

	m_pWindowDccChatCheck = new QCheckBox(__tr2qs_ctx("Enable in DCC chat windows", "editor"), tab);
	m_pWindowDccChatCheck->setToolTip(__tr2qs_ctx("Check this option if this action should be enabled only when "
	                                              "the active window is a DCC chat", "editor"));

	gl->addWidget(m_pWindowDccChatCheck, 10, 1, 1, 4);

	l = new QLabel(tab);
	gl->addWidget(l, 11, 0, 1, 4);
	gl->setColumnStretch(3, 1);
	gl->setRowStretch(11, 1);

	tw->addTab(tab, __tr2qs_ctx("Flags", "editor"));
	tw->setCurrentIndex(0);

	g->setRowStretch(2, 1);
	g->setColumnStretch(1, 1);

	KviPointerHashTableIterator<QString, KviActionCategory> it(*(KviActionManager::instance()->categories()));
	while(KviActionCategory * ac = it.current())
	{
		m_pCategoryCombo->addItem(ac->visibleName() + " (" + ac->name() + ")");
		++it;
	}
}

SingleActionEditor::~SingleActionEditor()
    = default;

void SingleActionEditor::channelWindowsCheckToggled(bool)
{
	m_pChannelOnlyIfUsersSelectedCheck->setEnabled(m_pWindowChannelCheck->isChecked());
	m_pChannelOnlyIfUsersSelectedCheck->setChecked(false);
}

void SingleActionEditor::consoleWindowsCheckToggled(bool)
{
	m_pConsoleOnlyIfUsersSelectedCheck->setEnabled(m_pWindowConsoleCheck->isChecked());
	m_pConsoleOnlyIfUsersSelectedCheck->setChecked(false);
}

void SingleActionEditor::queryWindowsCheckToggled(bool)
{
	m_pQueryOnlyIfUsersSelectedCheck->setEnabled(m_pWindowQueryCheck->isChecked());
	m_pQueryOnlyIfUsersSelectedCheck->setChecked(false);
}

void SingleActionEditor::needsContextCheckToggled(bool)
{
	m_pEnableAtLoginCheck->setChecked(false);
	m_pEnableAtLoginCheck->setEnabled(false);
	m_pNeedsConnectionCheck->setChecked(false);
	m_pNeedsConnectionCheck->setEnabled(m_pNeedsContextCheck->isChecked());
}

void SingleActionEditor::needsConnectionCheckToggled(bool)
{
	m_pEnableAtLoginCheck->setChecked(false);
	m_pEnableAtLoginCheck->setEnabled(m_pNeedsConnectionCheck->isChecked());
}

void SingleActionEditor::specificWindowsCheckToggled(bool)
{
	m_pWindowConsoleCheck->setChecked(false);
	m_pWindowChannelCheck->setChecked(false);
	m_pWindowQueryCheck->setChecked(false);
	m_pWindowDccChatCheck->setChecked(false);
	m_pQueryOnlyIfUsersSelectedCheck->setChecked(false);
	m_pChannelOnlyIfUsersSelectedCheck->setChecked(false);
	m_pConsoleOnlyIfUsersSelectedCheck->setChecked(false);
	m_pQueryOnlyIfUsersSelectedCheck->setEnabled(false);
	m_pChannelOnlyIfUsersSelectedCheck->setEnabled(false);
	m_pConsoleOnlyIfUsersSelectedCheck->setEnabled(false);
	bool b = m_pSpecificWindowsCheck->isChecked();
	m_pWindowConsoleCheck->setEnabled(b);
	m_pWindowChannelCheck->setEnabled(b);
	m_pWindowQueryCheck->setEnabled(b);
	m_pWindowDccChatCheck->setEnabled(b);
}

void SingleActionEditor::displaySmallIcon(const QString & szIconId)
{
	QPixmap * pix = g_pIconManager->getImage(szIconId);

	if(pix)
	{
		m_pSmallIconEdit->setText(szIconId);
		m_pSmallIconButton->setIcon(QIcon(*pix));
	}
	else
	{
		m_pSmallIconEdit->setText(QString());
		m_pSmallIconButton->setIcon(QIcon());
	}
}

void SingleActionEditor::displayBigIcon(const QString & szIconId)
{
	QPixmap * pix = g_pIconManager->getImage(szIconId);

	if(pix)
	{
		m_pBigIconEdit->setText(szIconId);
		m_pBigIconButton->setIcon(QIcon(*pix));
	}
	else
	{
		m_pBigIconEdit->setText(QString());
		m_pBigIconButton->setIcon(QIcon());
	}
}

void SingleActionEditor::chooseSmallIcon()
{
	if(!m_pActionData)
		return;
	KviImageDialog * d = new KviImageDialog(this);
	int ret = d->exec();
	QString s = d->selectedImage();
	delete d;
	if(ret != QDialog::Accepted)
		return;

	displaySmallIcon(s);
}

void SingleActionEditor::chooseBigIcon()
{
	if(!m_pActionData)
		return;
	KviImageDialog * d = new KviImageDialog(this, QString(), KID_TYPE_ALL, KID_TYPE_FULL_PATH);
	int ret = d->exec();
	QString s = d->selectedImage();
	delete d;
	if(ret != QDialog::Accepted)
		return;

	displayBigIcon(s);
}

void SingleActionEditor::setActionData(ActionData * d)
{
	m_pActionData = d;

	if(d)
	{
		unsigned int uOldFlags = d->m_uFlags;
		d->m_uFlags = KviAction::validateFlags(d->m_uFlags);
		if(d->m_uFlags != uOldFlags)
			qDebug("invalid action flags in SingleActionEditor::setActionData(): %d fixed to %d", uOldFlags, d->m_uFlags);

		m_pNameEdit->setText(d->m_szName);
		m_pNameEdit->setEnabled(true);
		m_pVisibleNameEdit->setText(d->m_szVisibleName);
		m_pVisibleNameEdit->setEnabled(true);
		m_pCategoryCombo->setEnabled(true);
		int i;
		for(i = 0; i < m_pCategoryCombo->count(); i++)
		{
			QString t = m_pCategoryCombo->itemText(i);
			int idx = t.lastIndexOf('(');
			QString r = t.right(t.length() - (idx + 1));
			QString r2 = r.left(r.length() - 1).trimmed();
			if(r2 == d->m_szCategory)
			{
				m_pCategoryCombo->setCurrentIndex(i);
				break;
			}
		}
		if(i == m_pCategoryCombo->count())
		{
			m_pCategoryCombo->setCurrentIndex(0);
		}
		m_pScriptEditor->setText(d->m_szScriptCode);
		m_pScriptEditor->setEnabled(true);
		m_pKeySequenceEdit->setText(d->m_szKeySequence);
		m_pKeySequenceEdit->setEnabled(true);
		m_pDescriptionEdit->setText(d->m_szDescription);
		m_pDescriptionEdit->setEnabled(true);
		m_pSmallIconEdit->setEnabled(true);
		m_pBigIconEdit->setEnabled(true);
		displaySmallIcon(d->m_szSmallIcon);
		displayBigIcon(d->m_szBigIcon);
		m_pSmallIconButton->setEnabled(true);
		m_pBigIconButton->setEnabled(true);
		m_pNeedsContextCheck->setEnabled(true);
		bool b = (d->m_uFlags & KviAction::NeedsContext) || (d->m_uFlags & KviAction::NeedsConnection);
		m_pNeedsContextCheck->setChecked(b);

		m_pNeedsConnectionCheck->setEnabled(b);
		b = (d->m_uFlags & KviAction::NeedsContext) && (d->m_uFlags & KviAction::NeedsConnection);
		m_pNeedsConnectionCheck->setChecked(b);

		m_pEnableAtLoginCheck->setEnabled(b);
		m_pEnableAtLoginCheck->setChecked(b && (d->m_uFlags & KviAction::EnableAtLogin));

		m_pSpecificWindowsCheck->setEnabled(true);
		b = d->m_uFlags & KviAction::InternalWindowMask;
		m_pSpecificWindowsCheck->setChecked(b);

		m_pWindowConsoleCheck->setEnabled(b);
		m_pWindowChannelCheck->setEnabled(b);
		m_pWindowQueryCheck->setEnabled(b);
		m_pWindowDccChatCheck->setEnabled(b);
		b = d->m_uFlags & KviAction::WindowConsole;
		m_pWindowConsoleCheck->setChecked(b);
		m_pConsoleOnlyIfUsersSelectedCheck->setEnabled(b);
		m_pConsoleOnlyIfUsersSelectedCheck->setChecked(b && (d->m_uFlags & KviAction::WindowOnlyIfUsersSelected));
		b = d->m_uFlags & KviAction::WindowChannel;
		m_pWindowChannelCheck->setChecked(b);
		m_pChannelOnlyIfUsersSelectedCheck->setEnabled(b);
		m_pChannelOnlyIfUsersSelectedCheck->setChecked(b && (d->m_uFlags & KviAction::WindowOnlyIfUsersSelected));
		b = d->m_uFlags & KviAction::WindowQuery;
		m_pWindowQueryCheck->setChecked(b);
		m_pQueryOnlyIfUsersSelectedCheck->setEnabled(b);
		m_pQueryOnlyIfUsersSelectedCheck->setChecked(b && (d->m_uFlags & KviAction::WindowOnlyIfUsersSelected));
		m_pWindowDccChatCheck->setChecked(d->m_uFlags & KviAction::WindowDccChat);
	}
	else
	{
		m_pNameEdit->setText("");
		m_pNameEdit->setEnabled(false);
		m_pVisibleNameEdit->setText("");
		m_pVisibleNameEdit->setEnabled(false);
		m_pCategoryCombo->setEnabled(false);
		m_pScriptEditor->setText("");
		m_pScriptEditor->setEnabled(false);
		m_pKeySequenceEdit->setText("");
		m_pKeySequenceEdit->setEnabled(false);
		m_pDescriptionEdit->setText("");
		m_pDescriptionEdit->setEnabled(false);
		m_pSmallIconEdit->setText("");
		m_pSmallIconEdit->setEnabled(false);
		m_pBigIconEdit->setText("");
		m_pBigIconEdit->setEnabled(false);
		m_pSmallIconButton->setIcon(QIcon());
		m_pSmallIconButton->setEnabled(false);
		m_pBigIconButton->setIcon(QPixmap());
		m_pBigIconButton->setEnabled(false);
		m_pNeedsContextCheck->setChecked(false);
		m_pNeedsContextCheck->setEnabled(false);
		m_pNeedsConnectionCheck->setChecked(false);
		m_pNeedsConnectionCheck->setEnabled(false);
		m_pEnableAtLoginCheck->setChecked(false);
		m_pEnableAtLoginCheck->setEnabled(false);
		m_pWindowConsoleCheck->setChecked(false);
		m_pWindowConsoleCheck->setEnabled(false);
		m_pWindowChannelCheck->setChecked(false);
		m_pWindowChannelCheck->setEnabled(false);
		m_pWindowQueryCheck->setChecked(false);
		m_pWindowQueryCheck->setEnabled(false);
		m_pWindowDccChatCheck->setChecked(false);
		m_pWindowDccChatCheck->setEnabled(false);
		m_pSpecificWindowsCheck->setChecked(false);
		m_pSpecificWindowsCheck->setEnabled(false);
		m_pQueryOnlyIfUsersSelectedCheck->setChecked(false);
		m_pChannelOnlyIfUsersSelectedCheck->setChecked(false);
		m_pConsoleOnlyIfUsersSelectedCheck->setChecked(false);
		m_pQueryOnlyIfUsersSelectedCheck->setEnabled(false);
		m_pChannelOnlyIfUsersSelectedCheck->setEnabled(false);
		m_pConsoleOnlyIfUsersSelectedCheck->setEnabled(false);
	}
}

void SingleActionEditor::commit()
{
	if(!m_pActionData)
		return;

	QString tmp = m_pNameEdit->text();
	if(tmp != m_pActionData->m_szName)
	{
		int idx = 1;
		while(KviActionManager::instance()->coreActionExists(tmp) || m_pActionEditor->actionExists(tmp))
		{
			QString tmp2;
			tmp2.setNum(idx);
			tmp = m_pNameEdit->text();
			tmp.append(tmp2);
			idx++;
		}
	}

	m_pActionData->m_szName = tmp;
	m_pScriptEditor->getText(m_pActionData->m_szScriptCode);
	m_pActionData->m_szVisibleName = m_pVisibleNameEdit->text();
	m_pActionData->m_szDescription = m_pDescriptionEdit->text();
	m_pActionData->m_szBigIcon = m_pBigIconEdit->text();
	m_pActionData->m_szSmallIcon = m_pSmallIconEdit->text();
	m_pActionData->m_szKeySequence = m_pKeySequenceEdit->text();
	QString szCat = m_pCategoryCombo->currentText();
	int idx = szCat.lastIndexOf(')');
	if(idx != -1)
		m_pActionData->m_szCategory = szCat.left(idx);
	else
		m_pActionData->m_szCategory = szCat;
	idx = m_pActionData->m_szCategory.lastIndexOf('(');
	if(idx != -1)
		m_pActionData->m_szCategory.remove(0, idx + 1);
	m_pActionData->m_uFlags = 0;
	if(m_pNeedsContextCheck->isChecked())
	{
		m_pActionData->m_uFlags |= KviAction::NeedsContext;
		if(m_pNeedsConnectionCheck->isChecked())
		{
			m_pActionData->m_uFlags |= KviAction::NeedsConnection;
			if(m_pEnableAtLoginCheck->isChecked())
				m_pActionData->m_uFlags |= KviAction::EnableAtLogin;
		}
	}
	if(m_pSpecificWindowsCheck->isChecked())
	{
		if(m_pWindowConsoleCheck->isChecked())
			m_pActionData->m_uFlags |= KviAction::WindowConsole;
		if(m_pWindowChannelCheck->isChecked())
			m_pActionData->m_uFlags |= KviAction::WindowChannel;
		if(m_pWindowQueryCheck->isChecked())
			m_pActionData->m_uFlags |= KviAction::WindowQuery;
		if(m_pWindowDccChatCheck->isChecked())
			m_pActionData->m_uFlags |= KviAction::WindowDccChat;
		if(m_pActionData->m_uFlags & KviAction::InternalWindowMask)
		{
			if(m_pConsoleOnlyIfUsersSelectedCheck->isChecked() || m_pChannelOnlyIfUsersSelectedCheck->isChecked() || m_pQueryOnlyIfUsersSelectedCheck->isChecked())
			{
				m_pActionData->m_uFlags |= KviAction::WindowOnlyIfUsersSelected;
			}
		}
	}

	unsigned int uOldFlags = m_pActionData->m_uFlags;
	m_pActionData->m_uFlags = KviAction::validateFlags(m_pActionData->m_uFlags);
	if(m_pActionData->m_uFlags != uOldFlags)
		qDebug("invalid action flags in SingleActionEditor::commit(): %d fixed to %d", uOldFlags, m_pActionData->m_uFlags);
}

ActionEditorTreeView::ActionEditorTreeView(QWidget * pParent)
    : QTreeWidget(pParent)
{
	setColumnCount(1);
	setHeaderLabel(__tr2qs_ctx("Action", "editor"));
	setSelectionMode(QAbstractItemView::ExtendedSelection);
	setSortingEnabled(true);
	int iWidth = viewport()->width();
	if(iWidth < LVI_MINIMUM_CELL_WIDTH)
		iWidth = LVI_MINIMUM_CELL_WIDTH;
	setRootIsDecorated(false);
	setColumnWidth(0, iWidth);
}

ActionEditorTreeView::~ActionEditorTreeView()
    = default;

void ActionEditorTreeView::resizeEvent(QResizeEvent * e)
{
	QTreeWidget::resizeEvent(e);
	int iWidth = viewport()->width();
	if(iWidth < LVI_MINIMUM_CELL_WIDTH)
		iWidth = LVI_MINIMUM_CELL_WIDTH;
	setColumnWidth(0, iWidth);
}

ActionEditor::ActionEditor(QWidget * par)
    : QWidget(par)
{

	QGridLayout * l = new QGridLayout(this);
	m_pSplitter = new QSplitter(Qt::Horizontal, this);
	m_pSplitter->setChildrenCollapsible(false);
	l->addWidget(m_pSplitter, 0, 0);

	KviTalVBox * box = new KviTalVBox(m_pSplitter);
	m_pTreeWidget = new ActionEditorTreeView(box);
	KviTalIconAndRichTextItemDelegate * itemDelegate = new KviTalIconAndRichTextItemDelegate(m_pTreeWidget);
	m_pTreeWidget->setItemDelegate(itemDelegate);
	//m_pTreeWidget->setShowSortIndicator(true);
	m_pTreeWidget->setFocusPolicy(Qt::StrongFocus);
	connect(m_pTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)), this, SLOT(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)));

	m_pNewActionButton = new QPushButton(__tr2qs_ctx("New Action", "editor"), box);
	connect(m_pNewActionButton, SIGNAL(clicked()), this, SLOT(newAction()));

	m_pDeleteActionsButton = new QPushButton(__tr2qs_ctx("Delete Actions", "editor"), box);
	connect(m_pDeleteActionsButton, SIGNAL(clicked()), this, SLOT(deleteActions()));

	m_pExportActionsButton = new QPushButton(__tr2qs_ctx("Export Actions...", "editor"), box);
	connect(m_pExportActionsButton, SIGNAL(clicked()), this, SLOT(exportActions()));

	box->setSpacing(1);

	m_pSingleActionEditor = new SingleActionEditor(m_pSplitter, this);

	ActionEditorTreeWidgetItem * last = nullptr;
	ActionEditorTreeWidgetItem * first = nullptr;

	KviPointerHashTableIterator<QString, KviAction> it(*(KviActionManager::instance()->actions()));
	while(KviAction * a = it.current())
	{
		if(a->isKviUserActionNeverOverrideThis())
		{
			ActionData * ad = new ActionData(
			    a->name(),
			    ((KviKvsUserAction *)a)->scriptCode(),
			    ((KviKvsUserAction *)a)->visibleNameCode(),
			    ((KviKvsUserAction *)a)->descriptionCode(),
			    a->category() ? a->category()->name() : KviActionManager::categoryGeneric()->name(),
			    a->bigIconId(),
			    a->smallIconId(),
			    a->flags(),
			    a->keySequence(),
			    nullptr);
			ActionEditorTreeWidgetItem * lvi = new ActionEditorTreeWidgetItem(m_pTreeWidget, ad);
			ad->m_pItem = lvi;
			if(ad->m_szName == g_szLastEditedAction)
				last = lvi;
			if(!first)
				first = lvi;
		}
		++it;
	}

	if(!last)
		last = first; // try to sleect the first one then

	if(last)
	{
		m_pTreeWidget->setCurrentItem(last);
		currentItemChanged(last, last);
	}
	else
	{
		currentItemChanged(nullptr, nullptr);
	}
}

ActionEditor::~ActionEditor()
    = default;

void ActionEditor::exportActions()
{
	QString szName = QDir::homePath();
	if(!szName.endsWith(QString(KVI_PATH_SEPARATOR)))
		szName += KVI_PATH_SEPARATOR;
	szName += "myactions.kvs";

	QString szFile;

	if(!KviFileDialog::askForSaveFileName(
	       szFile,
	       __tr2qs_ctx("Choose a Filename - KVIrc", "editor"),
	       szName,
	       KVI_FILTER_SCRIPT,
	       true,
	       true,
	       true,
	       this))
		return;

	QString szCode;

	for(int i = 0; i < m_pTreeWidget->topLevelItemCount(); i++)
	{
		if(m_pTreeWidget->topLevelItem(i)->isSelected())
		{
			ActionData * a = ((ActionEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))->actionData();

			KviKvsUserAction::exportToKvs(
			    szCode,
			    a->m_szName,
			    a->m_szScriptCode,
			    a->m_szVisibleName,
			    a->m_szDescription,
			    a->m_szCategory,
			    a->m_szBigIcon,
			    a->m_szSmallIcon,
			    a->m_uFlags,
			    a->m_szKeySequence);
		}
	}

	if(!KviFileUtils::writeFile(szFile, szCode))
	{
		QMessageBox::warning(this, __tr2qs_ctx("Writing to File Failed - KVIrc", "editor"), __tr2qs_ctx("Unable to write to the actions file.", "editor"));
	}
}

void ActionEditor::deleteActions()
{
	KviPointerList<ActionEditorTreeWidgetItem> l;
	l.setAutoDelete(false);

	for(int i = 0; i < m_pTreeWidget->topLevelItemCount(); i++)
	{
		if(m_pTreeWidget->topLevelItem(i)->isSelected())
			l.append((ActionEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i));
	}

	if(l.isEmpty())
		return;

	//if(QMessageBox::question(this,__tr2qs_ctx("Confirm Actions Deletion - KVIrc","editor"),__tr2qs_ctx("Do you really want to delete the selected actions?","editor")) != QMessageBox::Yes)
	//	return;

	for(ActionEditorTreeWidgetItem * i = l.first(); i; i = l.next())
	{
		if(m_pSingleActionEditor->actionData() == i->actionData())
			m_pSingleActionEditor->setActionData(nullptr);
		delete i;
	}
}

QString ActionEditor::nameForAutomaticAction(const QString & szTemplate)
{
	QString szRet;
	QString szT = szTemplate;
	szT.replace(" ", "");
	szT.replace(".", "_");

	int i = 1;
	do
	{
		szRet = QString("%1%2").arg(szT).arg(i);
		i++;
	} while(actionExists(szRet));

	return szRet;
}

void ActionEditor::newAction()
{
	QString szName = nameForAutomaticAction(__tr2qs_ctx("My Action", "editor"));
	QString szVis = __tr2qs_ctx("My Action", "editor");
	QString szDes = __tr2qs_ctx("Put here a short description of your action", "editor");

	szVis.prepend("$tr(\"");
	szVis.append("\")");
	szDes.prepend("$tr(\"");
	szDes.append("\")");

	ActionData * ad = new ActionData(szName,
	    QString(),
	    szVis,
	    szDes,
	    KviActionManager::categoryGeneric()->name(),
	    KVI_BIGICON_USERACTION,
	    QString(),
	    0,
	    QString(),
	    nullptr);

	ActionEditorTreeWidgetItem * lvi = new ActionEditorTreeWidgetItem(m_pTreeWidget, ad);
	ad->m_pItem = lvi;
	m_pTreeWidget->setCurrentItem(lvi);
	currentItemChanged(lvi, lvi);
}

bool ActionEditor::actionExists(const QString & szName)
{
	for(int i = 0; i < m_pTreeWidget->topLevelItemCount(); i++)
	{
		if(((ActionEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))->actionData()->m_szName == szName)
			return true;
	}
	return false;
}

void ActionEditor::currentItemChanged(QTreeWidgetItem * i, QTreeWidgetItem *)
{
	if(m_pSingleActionEditor->actionData())
		m_pSingleActionEditor->commit();

	m_pTreeWidget->update();

	ActionEditorTreeWidgetItem * it = (ActionEditorTreeWidgetItem *)i;
	if(!it)
	{
		m_pSingleActionEditor->setActionData(nullptr);
		m_pDeleteActionsButton->setEnabled(false);
		m_pExportActionsButton->setEnabled(false);
		return;
	}
	m_pDeleteActionsButton->setEnabled(true);
	m_pExportActionsButton->setEnabled(true);

	//if(!it->isSelected())m_pTreeWidget->setSelected(it,true);

	m_pSingleActionEditor->setActionData(it->actionData());
	g_szLastEditedAction = it->actionData()->m_szName;
}

void ActionEditor::commit()
{
	m_pSingleActionEditor->commit();

	// the hard part: update the actions without destroying them...

	KviActionManager::instance()->killAllKvsUserActions();

	for(int i = 0; i < m_pTreeWidget->topLevelItemCount(); i++)
	{
		ActionEditorTreeWidgetItem * it = (ActionEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i);
		KviKvsUserAction * a = KviKvsUserAction::createInstance( // msvc workaround
		    KviActionManager::instance(),
		    it->actionData()->m_szName,
		    it->actionData()->m_szScriptCode,
		    it->actionData()->m_szVisibleName,
		    it->actionData()->m_szDescription,
		    it->actionData()->m_szCategory,
		    it->actionData()->m_szBigIcon,
		    it->actionData()->m_szSmallIcon,
		    it->actionData()->m_uFlags,
		    it->actionData()->m_szKeySequence);

		KviActionManager::instance()->registerAction(a);
	}

	KviCustomToolBarManager::instance()->updateVisibleToolBars();
}

ActionEditorWindow::ActionEditorWindow()
    : KviWindow(KviWindow::ScriptEditor, "actioneditor", nullptr)
{
	g_pActionEditorWindow = this;
	setFixedCaption(__tr2qs_ctx("Action Editor", "editor"));

	QGridLayout * g = new QGridLayout();

	m_pEditor = new ActionEditor(this);
	g->addWidget(m_pEditor, 0, 0, 1, 4);

	QPushButton * btn = new QPushButton(__tr2qs_ctx("OK", "editor"), this);
	connect(btn, SIGNAL(clicked()), this, SLOT(okClicked()));
	btn->setIcon(*(g_pIconManager->getSmallIcon(KviIconManager::Accept)));
	g->addWidget(btn, 1, 1);

	btn = new QPushButton(__tr2qs_ctx("Apply", "editor"), this);
	connect(btn, SIGNAL(clicked()), this, SLOT(applyClicked()));
	btn->setIcon(*(g_pIconManager->getSmallIcon(KviIconManager::Accept)));
	g->addWidget(btn, 1, 2);

	btn = new QPushButton(__tr2qs_ctx("Cancel", "editor"), this);
	connect(btn, SIGNAL(clicked()), this, SLOT(cancelClicked()));
	btn->setIcon(*(g_pIconManager->getSmallIcon(KviIconManager::Discard)));
	g->addWidget(btn, 1, 3);

	g->setRowStretch(0, 1);
	g->setColumnStretch(0, 1);
	setLayout(g);
}

ActionEditorWindow::~ActionEditorWindow()
{
	g_pActionEditorWindow = nullptr;
}

void ActionEditorWindow::okClicked()
{
	m_pEditor->commit();
	close();
}

void ActionEditorWindow::applyClicked()
{
	m_pEditor->commit();
}

void ActionEditorWindow::cancelClicked()
{
	close();
}

QPixmap * ActionEditorWindow::myIconPtr()
{
	return g_pIconManager->getSmallIcon(KviIconManager::ActionEditor);
}

void ActionEditorWindow::getConfigGroupName(QString & szName)
{
	szName = "actioneditor";
}

void ActionEditorWindow::saveProperties(KviConfigurationFile * cfg)
{
	KviWindow::saveProperties(cfg);
	cfg->writeEntry("Splitter", m_pEditor->m_pSplitter->sizes());
}

void ActionEditorWindow::loadProperties(KviConfigurationFile * cfg)
{
	int w = width();
	KviWindow::loadProperties(cfg);
	QList<int> def;
	def.append((w * 25) / 100);
	def.append((w * 75) / 100);
	m_pEditor->m_pSplitter->setSizes(cfg->readIntListEntry("Splitter", def));
}
