/*
 * Bittorrent Client using Qt4 and libtorrent.
 * Copyright (C) 2006  Christophe Dumez
 *
 * 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.
 *
 * In addition, as a special exception, the copyright holders give permission to
 * link this program with the OpenSSL project's "OpenSSL" library (or with
 * modified versions of it that use the same license as the "OpenSSL" library),
 * and distribute the linked executables. You must obey the GNU General Public
 * License in all respects for all of the code used other than "OpenSSL".  If you
 * modify file(s), you may extend this exception to your version of the file(s),
 * but you are not obligated to do so. If you do not wish to do so, delete this
 * exception statement from your version.
 *
 * Contact : chris@qbittorrent.org
 */

#include "trackerlist.h"

#include <QAction>
#include <QApplication>
#include <QColor>
#include <QDebug>
#include <QHash>
#include <QHeaderView>
#include <QMenu>
#include <QMessageBox>
#include <QStringList>
#include <QTableView>
#include <QTreeWidgetItem>
#include <QUrl>

#include "base/bittorrent/peerinfo.h"
#include "base/bittorrent/session.h"
#include "base/bittorrent/torrenthandle.h"
#include "base/bittorrent/trackerentry.h"
#include "base/preferences.h"
#include "base/utils/misc.h"
#include "autoexpandabledialog.h"
#include "guiiconprovider.h"
#include "propertieswidget.h"
#include "trackersadditiondlg.h"

TrackerList::TrackerList(PropertiesWidget *properties)
    : QTreeWidget()
    , properties(properties)
{
  // Set header
  // Must be set before calling loadSettings() otherwise the header is reset on restart
  setHeaderLabels(headerLabels());
  // Load settings
  loadSettings();
  // Graphical settings
  setRootIsDecorated(false);
  setAllColumnsShowFocus(true);
  setItemsExpandable(false);
  setSelectionMode(QAbstractItemView::ExtendedSelection);
  header()->setStretchLastSection(false); // Must be set after loadSettings() in order to work
  // Ensure that at least one column is visible at all times
  if (visibleColumnsCount() == 0)
      setColumnHidden(COL_URL, false);
  // To also mitigate the above issue, we have to resize each column when
  // its size is 0, because explicitly 'showing' the column isn't enough
  // in the above scenario.
  for (unsigned int i = 0; i < COL_COUNT; ++i)
      if ((columnWidth(i) <= 0) && !isColumnHidden(i))
          resizeColumnToContents(i);
  // Context menu
  setContextMenuPolicy(Qt::CustomContextMenu);
  connect(this, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showTrackerListMenu(QPoint)));
  // Header context menu
  header()->setContextMenuPolicy(Qt::CustomContextMenu);
  connect(header(), SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(displayToggleColumnsMenu(const QPoint&)));
  // Set DHT, PeX, LSD items
  dht_item = new QTreeWidgetItem({ "",  "** [DHT] **", "", "0", "", "", "0" });
  insertTopLevelItem(0, dht_item);
  setRowColor(0, QColor("grey"));
  pex_item = new QTreeWidgetItem({ "",  "** [PeX] **", "", "0", "", "", "0" });
  insertTopLevelItem(1, pex_item);
  setRowColor(1, QColor("grey"));
  lsd_item = new QTreeWidgetItem({ "",  "** [LSD] **", "", "0", "", "", "0" });
  insertTopLevelItem(2, lsd_item);
  setRowColor(2, QColor("grey"));
  // Set static items alignment
  dht_item->setTextAlignment(COL_RECEIVED, (Qt::AlignRight | Qt::AlignVCenter));
  pex_item->setTextAlignment(COL_RECEIVED, (Qt::AlignRight | Qt::AlignVCenter));
  lsd_item->setTextAlignment(COL_RECEIVED, (Qt::AlignRight | Qt::AlignVCenter));
  dht_item->setTextAlignment(COL_SEEDS, (Qt::AlignRight | Qt::AlignVCenter));
  pex_item->setTextAlignment(COL_SEEDS, (Qt::AlignRight | Qt::AlignVCenter));
  lsd_item->setTextAlignment(COL_SEEDS, (Qt::AlignRight | Qt::AlignVCenter));
  dht_item->setTextAlignment(COL_PEERS, (Qt::AlignRight | Qt::AlignVCenter));
  pex_item->setTextAlignment(COL_PEERS, (Qt::AlignRight | Qt::AlignVCenter));
  lsd_item->setTextAlignment(COL_PEERS, (Qt::AlignRight | Qt::AlignVCenter));
  dht_item->setTextAlignment(COL_DOWNLOADED, (Qt::AlignRight | Qt::AlignVCenter));
  pex_item->setTextAlignment(COL_DOWNLOADED, (Qt::AlignRight | Qt::AlignVCenter));
  lsd_item->setTextAlignment(COL_DOWNLOADED, (Qt::AlignRight | Qt::AlignVCenter));
  // Set header alignment
  headerItem()->setTextAlignment(COL_TIER, (Qt::AlignRight | Qt::AlignVCenter));
  headerItem()->setTextAlignment(COL_RECEIVED, (Qt::AlignRight | Qt::AlignVCenter));
  headerItem()->setTextAlignment(COL_SEEDS, (Qt::AlignRight | Qt::AlignVCenter));
  headerItem()->setTextAlignment(COL_PEERS, (Qt::AlignRight | Qt::AlignVCenter));
  headerItem()->setTextAlignment(COL_DOWNLOADED, (Qt::AlignRight | Qt::AlignVCenter));
  // Set hotkeys
  editHotkey = new QShortcut(Qt::Key_F2, this, SLOT(editSelectedTracker()), 0, Qt::WidgetShortcut);
  connect(this, SIGNAL(doubleClicked(QModelIndex)), SLOT(editSelectedTracker()));
  deleteHotkey = new QShortcut(QKeySequence::Delete, this, SLOT(deleteSelectedTrackers()), 0, Qt::WidgetShortcut);
  copyHotkey = new QShortcut(QKeySequence::Copy, this, SLOT(copyTrackerUrl()), 0, Qt::WidgetShortcut);

    // This hack fixes reordering of first column with Qt5.
    // https://github.com/qtproject/qtbase/commit/e0fc088c0c8bc61dbcaf5928b24986cd61a22777
    QTableView unused;
    unused.setVerticalHeader(header());
    header()->setParent(this);
    unused.setVerticalHeader(new QHeaderView(Qt::Horizontal));
}

TrackerList::~TrackerList()
{
    saveSettings();
}

QList<QTreeWidgetItem*> TrackerList::getSelectedTrackerItems() const {
  const QList<QTreeWidgetItem*> selected_items = selectedItems();
  QList<QTreeWidgetItem*> selected_trackers;
  foreach (QTreeWidgetItem *item, selected_items) {
    if (indexOfTopLevelItem(item) >= NB_STICKY_ITEM) { // Ignore STICKY ITEMS
      selected_trackers << item;
    }
  }
  return selected_trackers;
}

void TrackerList::setRowColor(int row, QColor color) {
  unsigned int nbColumns = columnCount();
  QTreeWidgetItem *item = topLevelItem(row);
  for (unsigned int i=0; i<nbColumns; ++i) {
    item->setData(i, Qt::ForegroundRole, color);
  }
}

void TrackerList::moveSelectionUp() {
  BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
  if (!torrent) {
    clear();
    return;
  }
  QList<QTreeWidgetItem *> selected_items = getSelectedTrackerItems();
  if (selected_items.isEmpty()) return;
  bool change = false;
  foreach (QTreeWidgetItem *item, selected_items) {
    int index = indexOfTopLevelItem(item);
    if (index > NB_STICKY_ITEM) {
      insertTopLevelItem(index-1, takeTopLevelItem(index));
      change = true;
    }
  }
  if (!change) return;
  // Restore selection
  QItemSelectionModel *selection = selectionModel();
  foreach (QTreeWidgetItem *item, selected_items) {
    selection->select(indexFromItem(item), QItemSelectionModel::Rows|QItemSelectionModel::Select);
  }
  setSelectionModel(selection);
  // Update torrent trackers
  QList<BitTorrent::TrackerEntry> trackers;
  for (int i = NB_STICKY_ITEM; i < topLevelItemCount(); ++i) {
    QString tracker_url = topLevelItem(i)->data(COL_URL, Qt::DisplayRole).toString();
    BitTorrent::TrackerEntry e(tracker_url);
    e.setTier(i - NB_STICKY_ITEM);
    trackers.append(e);
  }

  torrent->replaceTrackers(trackers);
  // Reannounce
  if (!torrent->isPaused())
    torrent->forceReannounce();
}

void TrackerList::moveSelectionDown() {
  BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
  if (!torrent) {
    clear();
    return;
  }
  QList<QTreeWidgetItem *> selected_items = getSelectedTrackerItems();
  if (selected_items.isEmpty()) return;
  bool change = false;
  for (int i=selectedItems().size()-1; i>= 0; --i) {
    int index = indexOfTopLevelItem(selected_items.at(i));
    if (index < topLevelItemCount()-1) {
      insertTopLevelItem(index+1, takeTopLevelItem(index));
      change = true;
    }
  }
  if (!change) return;
  // Restore selection
  QItemSelectionModel *selection = selectionModel();
  foreach (QTreeWidgetItem *item, selected_items) {
    selection->select(indexFromItem(item), QItemSelectionModel::Rows|QItemSelectionModel::Select);
  }
  setSelectionModel(selection);
  // Update torrent trackers
  QList<BitTorrent::TrackerEntry> trackers;
  for (int i = NB_STICKY_ITEM; i < topLevelItemCount(); ++i) {
    QString tracker_url = topLevelItem(i)->data(COL_URL, Qt::DisplayRole).toString();
    BitTorrent::TrackerEntry e(tracker_url);
    e.setTier(i - NB_STICKY_ITEM);
    trackers.append(e);
  }

  torrent->replaceTrackers(trackers);
  // Reannounce
  if (!torrent->isPaused())
    torrent->forceReannounce();
}

void TrackerList::clear()
{
    qDeleteAll(tracker_items.values());
    tracker_items.clear();
    dht_item->setText(COL_STATUS, "");
    dht_item->setText(COL_SEEDS, "");
    dht_item->setText(COL_PEERS, "");
    dht_item->setText(COL_MSG, "");
    pex_item->setText(COL_STATUS, "");
    pex_item->setText(COL_SEEDS, "");
    pex_item->setText(COL_PEERS, "");
    pex_item->setText(COL_MSG, "");
    lsd_item->setText(COL_STATUS, "");
    lsd_item->setText(COL_SEEDS, "");
    lsd_item->setText(COL_PEERS, "");
    lsd_item->setText(COL_MSG, "");
}

void TrackerList::loadStickyItems(BitTorrent::TorrentHandle *const torrent) {
  QString working = tr("Working");
  QString disabled = tr("Disabled");

  // load DHT information
  if (BitTorrent::Session::instance()->isDHTEnabled() && !torrent->isPrivate())
    dht_item->setText(COL_STATUS, working);
  else
    dht_item->setText(COL_STATUS, disabled);

  // Load PeX Information
  if (BitTorrent::Session::instance()->isPeXEnabled() && !torrent->isPrivate())
    pex_item->setText(COL_STATUS, working);
  else
    pex_item->setText(COL_STATUS, disabled);

  // Load LSD Information
  if (BitTorrent::Session::instance()->isLSDEnabled() && !torrent->isPrivate())
    lsd_item->setText(COL_STATUS, working);
  else
    lsd_item->setText(COL_STATUS, disabled);

  if (torrent->isPrivate()) {
    QString privateMsg = tr("This torrent is private");
    dht_item->setText(COL_MSG, privateMsg);
    pex_item->setText(COL_MSG, privateMsg);
    lsd_item->setText(COL_MSG, privateMsg);
  }

    // XXX: libtorrent should provide this info...
    // Count peers from DHT, PeX, LSD
    uint seedsDHT = 0, seedsPeX = 0, seedsLSD = 0, peersDHT = 0, peersPeX = 0, peersLSD = 0;
    foreach (const BitTorrent::PeerInfo &peer, torrent->peers()) {
        if (peer.isConnecting()) continue;

        if (peer.fromDHT()) {
            if (peer.isSeed())
                ++seedsDHT;
            else
                ++peersDHT;
        }
        if (peer.fromPeX()) {
            if (peer.isSeed())
                ++seedsPeX;
            else
                ++peersPeX;
        }
        if (peer.fromLSD()) {
            if (peer.isSeed())
                ++seedsLSD;
            else
                ++peersLSD;
        }
    }

    dht_item->setText(COL_SEEDS, QString::number(seedsDHT));
    dht_item->setText(COL_PEERS, QString::number(peersDHT));
    pex_item->setText(COL_SEEDS, QString::number(seedsPeX));
    pex_item->setText(COL_PEERS, QString::number(peersPeX));
    lsd_item->setText(COL_SEEDS, QString::number(seedsLSD));
    lsd_item->setText(COL_PEERS, QString::number(peersLSD));
}

void TrackerList::loadTrackers() {
  // Load trackers from torrent handle
  BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
  if (!torrent) return;

  loadStickyItems(torrent);
  // Load actual trackers information
  QHash<QString, BitTorrent::TrackerInfo> trackers_data = torrent->trackerInfos();
  QStringList old_trackers_urls = tracker_items.keys();
  foreach (const BitTorrent::TrackerEntry &entry, torrent->trackers()) {
    QString trackerUrl = entry.url();
    QTreeWidgetItem *item = tracker_items.value(trackerUrl, 0);
    if (!item) {
      item = new QTreeWidgetItem();
      item->setText(COL_URL, trackerUrl);
      addTopLevelItem(item);
      tracker_items[trackerUrl] = item;
    } else {
      old_trackers_urls.removeOne(trackerUrl);
    }
    item->setText(COL_TIER, QString::number(entry.tier()));
    BitTorrent::TrackerInfo data = trackers_data.value(trackerUrl);
    QString error_message = data.lastMessage.trimmed();
    switch (entry.status()) {
    case BitTorrent::TrackerEntry::Working:
        item->setText(COL_STATUS, tr("Working"));
        item->setText(COL_MSG, "");
        break;
    case BitTorrent::TrackerEntry::Updating:
        item->setText(COL_STATUS, tr("Updating..."));
        item->setText(COL_MSG, "");
        break;
    case BitTorrent::TrackerEntry::NotWorking:
        item->setText(COL_STATUS, tr("Not working"));
        item->setText(COL_MSG, error_message);
        break;
    case BitTorrent::TrackerEntry::NotContacted:
        item->setText(COL_STATUS, tr("Not contacted yet"));
        item->setText(COL_MSG, "");
        break;
    }
    item->setText(COL_RECEIVED, QString::number(data.numPeers));

#if LIBTORRENT_VERSION_NUM >= 10000
    item->setText(COL_SEEDS, QString::number(entry.nativeEntry().scrape_complete > 0 ? entry.nativeEntry().scrape_complete : 0));
    item->setText(COL_PEERS, QString::number(entry.nativeEntry().scrape_incomplete > 0 ? entry.nativeEntry().scrape_incomplete : 0));
    item->setText(COL_DOWNLOADED, QString::number(entry.nativeEntry().scrape_downloaded > 0 ? entry.nativeEntry().scrape_downloaded : 0));
#else
    item->setText(COL_SEEDS, "0");
    item->setText(COL_PEERS, "0");
    item->setText(COL_DOWNLOADED, "0");
#endif

    item->setTextAlignment(COL_TIER, (Qt::AlignRight | Qt::AlignVCenter));
    item->setTextAlignment(COL_RECEIVED, (Qt::AlignRight | Qt::AlignVCenter));
    item->setTextAlignment(COL_SEEDS, (Qt::AlignRight | Qt::AlignVCenter));
    item->setTextAlignment(COL_PEERS, (Qt::AlignRight | Qt::AlignVCenter));
    item->setTextAlignment(COL_DOWNLOADED, (Qt::AlignRight | Qt::AlignVCenter));
  }
  // Remove old trackers
  foreach (const QString &tracker, old_trackers_urls) {
    delete tracker_items.take(tracker);
  }
}

// Ask the user for new trackers and add them to the torrent
void TrackerList::askForTrackers() {
  BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
  if (!torrent) return;

  QList<BitTorrent::TrackerEntry> trackers;
  foreach (const QString &tracker, TrackersAdditionDlg::askForTrackers(this, torrent))
      trackers << tracker;
  torrent->addTrackers(trackers);
}

void TrackerList::copyTrackerUrl() {
    QList<QTreeWidgetItem *> selected_items = getSelectedTrackerItems();
    if (selected_items.isEmpty()) return;
    QStringList urls_to_copy;
    foreach (QTreeWidgetItem *item, selected_items) {
      QString tracker_url = item->data(COL_URL, Qt::DisplayRole).toString();
      qDebug() << QString("Copy: ") + tracker_url;
      urls_to_copy << tracker_url;
    }
    QApplication::clipboard()->setText(urls_to_copy.join("\n"));
}


void TrackerList::deleteSelectedTrackers() {
  BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
  if (!torrent) {
    clear();
    return;
  }

  QList<QTreeWidgetItem *> selected_items = getSelectedTrackerItems();
  if (selected_items.isEmpty()) return;

  QStringList urls_to_remove;
  foreach (QTreeWidgetItem *item, selected_items) {
    QString tracker_url = item->data(COL_URL, Qt::DisplayRole).toString();
    urls_to_remove << tracker_url;
    tracker_items.remove(tracker_url);
    delete item;
  }

  // Iterate of trackers and remove selected ones
  QList<BitTorrent::TrackerEntry> remaining_trackers;
  QList<BitTorrent::TrackerEntry> trackers = torrent->trackers();
  foreach (const BitTorrent::TrackerEntry &entry, trackers) {
    if (!urls_to_remove.contains(entry.url())) {
      remaining_trackers.push_back(entry);
    }
  }

  torrent->replaceTrackers(remaining_trackers);
  if (!torrent->isPaused())
    torrent->forceReannounce();
}

void TrackerList::editSelectedTracker() {
    BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
    if (!torrent) return;

    QString hash = torrent->hash();

    QList<QTreeWidgetItem *> selected_items = getSelectedTrackerItems();
    if (selected_items.isEmpty())
      return;
    // During multi-select only process item selected last
    QUrl tracker_url = selected_items.last()->text(COL_URL);

    bool ok;
    QUrl new_tracker_url = AutoExpandableDialog::getText(this, tr("Tracker editing"), tr("Tracker URL:"),
                                                         QLineEdit::Normal, tracker_url.toString(), &ok).trimmed();
    if (!ok)
      return;

    if (!new_tracker_url.isValid()) {
      QMessageBox::warning(this, tr("Tracker editing failed"), tr("The tracker URL entered is invalid."));
      return;
    }
    if (new_tracker_url == tracker_url)
      return;

    QList<BitTorrent::TrackerEntry> trackers = torrent->trackers();
    bool match = false;
    for (int i = 0; i < trackers.size(); ++i) {
      BitTorrent::TrackerEntry &entry = trackers[i];
      if (new_tracker_url == QUrl(entry.url())) {
        QMessageBox::warning(this, tr("Tracker editing failed"), tr("The tracker URL already exists."));
        return;
      }

      if (tracker_url == QUrl(entry.url()) && !match) {
        BitTorrent::TrackerEntry new_entry(new_tracker_url.toString());
        new_entry.setTier(entry.tier());
        match = true;
        entry = new_entry;
      }
    }

    torrent->replaceTrackers(trackers);
    if (!torrent->isPaused()) {
      torrent->forceReannounce();
    }
}

void TrackerList::reannounceSelected() {
    QList<QTreeWidgetItem *> selected_items = selectedItems();
    if (selected_items.isEmpty()) return;

    BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
    if (!torrent) return;
    QList<BitTorrent::TrackerEntry> trackers = torrent->trackers();

    foreach (QTreeWidgetItem* item, selected_items) {
      // DHT case
      if (item == dht_item) {
        torrent->forceDHTAnnounce();
        continue;
      }

      // Trackers case
      for (int i = 0; i < trackers.size(); ++i) {
        if (item->text(COL_URL) == trackers[i].url()) {
          torrent->forceReannounce(i);
          break;
        }
      }
    }

    loadTrackers();
}

void TrackerList::showTrackerListMenu(QPoint) {
  BitTorrent::TorrentHandle *const torrent = properties->getCurrentTorrent();
  if (!torrent) return;
  //QList<QTreeWidgetItem*> selected_items = getSelectedTrackerItems();
  QMenu menu;
  // Add actions
  QAction *addAct = menu.addAction(GuiIconProvider::instance()->getIcon("list-add"), tr("Add a new tracker..."));
  QAction *copyAct = nullptr;
  QAction *delAct = nullptr;
  QAction *editAct = nullptr;
  if (!getSelectedTrackerItems().isEmpty()) {
    delAct = menu.addAction(GuiIconProvider::instance()->getIcon("list-remove"), tr("Remove tracker"));
    copyAct = menu.addAction(GuiIconProvider::instance()->getIcon("edit-copy"), tr("Copy tracker URL"));
    editAct = menu.addAction(GuiIconProvider::instance()->getIcon("edit-rename"),tr("Edit selected tracker URL"));
  }
  QAction *reannounceSelAct = nullptr;
  QAction *reannounceAct = nullptr;
  if (!torrent->isPaused()) {
    reannounceSelAct = menu.addAction(GuiIconProvider::instance()->getIcon("view-refresh"), tr("Force reannounce to selected trackers"));
    menu.addSeparator();
    reannounceAct = menu.addAction(GuiIconProvider::instance()->getIcon("view-refresh"), tr("Force reannounce to all trackers"));
  }
  QAction *act = menu.exec(QCursor::pos());
  if (act == nullptr) return;
  if (act == addAct) {
    askForTrackers();
    return;
  }
  if (act == copyAct) {
    copyTrackerUrl();
    return;
  }
  if (act == delAct) {
    deleteSelectedTrackers();
    return;
  }
  if (act == reannounceSelAct) {
    reannounceSelected();
    return;
  }
  if (act == reannounceAct) {
    BitTorrent::TorrentHandle *h = properties->getCurrentTorrent();
    h->forceReannounce();
    h->forceDHTAnnounce();
    return;
  }
  if (act == editAct) {
    editSelectedTracker();
    return;
  }
}

void TrackerList::loadSettings()
{
    header()->restoreState(Preferences::instance()->getPropTrackerListState());
}

void TrackerList::saveSettings() const
{
    Preferences::instance()->setPropTrackerListState(header()->saveState());
}

QStringList TrackerList::headerLabels()
{
    static const QStringList header {
        "#"
        , tr("URL")
        , tr("Status")
        , tr("Received")
        , tr("Seeds")
        , tr("Peers")
        , tr("Downloaded")
        , tr("Message")
    };

    return header;
}

int TrackerList::visibleColumnsCount() const
{
    int visibleCols = 0;
    for (unsigned int i = 0; i < COL_COUNT; ++i) {
        if (!isColumnHidden(i))
            ++visibleCols;
    }

    return visibleCols;
}

void TrackerList::displayToggleColumnsMenu(const QPoint &)
{
    QMenu hideshowColumn(this);
    hideshowColumn.setTitle(tr("Column visibility"));
    for (int i = 0; i < COL_COUNT; ++i) {
        QAction *myAct = hideshowColumn.addAction(headerLabels().at(i));
        myAct->setCheckable(true);
        myAct->setChecked(!isColumnHidden(i));
        myAct->setData(i);
    }

    // Call menu
    QAction *act = hideshowColumn.exec(QCursor::pos());
    if (!act) return;

    int col = act->data().toInt();
    Q_ASSERT(visibleColumnsCount() > 0);
    if (!isColumnHidden(col) && (visibleColumnsCount() == 1))
        return;
    qDebug("Toggling column %d visibility", col);
    setColumnHidden(col, !isColumnHidden(col));
    if (!isColumnHidden(col) && (columnWidth(col) <= 5))
        setColumnWidth(col, 100);
    saveSettings();
}