/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014 Pavel Strakhov
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */
#include "ToolWindowManager.h"
#include "ToolWindowManagerArea.h"
#include "ToolWindowManagerSplitter.h"
#include "ToolWindowManagerWrapper.h"
#include <QVBoxLayout>
#include <QDebug>
#include <QEvent>
#include <QApplication>
#include <QDrag>
#include <QMetaMethod>
#include <QMimeData>
#include <QMouseEvent>
#include <QPainter>
#include <QDesktopWidget>
#include <QScreen>
#include <QSplitter>
#include <QTabBar>

template<class T>
T findClosestParent(QWidget* widget) {
  while(widget) {
    if (qobject_cast<T>(widget)) {
      return static_cast<T>(widget);
    }
    widget = widget->parentWidget();
  }
  return 0;
}

ToolWindowManager::ToolWindowManager(QWidget *parent) :
  QWidget(parent)
{
  QVBoxLayout* mainLayout = new QVBoxLayout(this);
  mainLayout->setContentsMargins(0, 0, 0, 0);
  ToolWindowManagerWrapper* wrapper = new ToolWindowManagerWrapper(this, false);
  wrapper->setWindowFlags(wrapper->windowFlags() & ~Qt::Tool);
  mainLayout->addWidget(wrapper);
  m_allowFloatingWindow = true;
  m_createCallback = NULL;
  m_lastUsedArea = NULL;

  m_draggedWrapper = NULL;
  m_hoverArea = NULL;

  QPalette pal = palette();
  pal.setColor(QPalette::Background, pal.color(QPalette::Highlight));

  m_previewOverlay = new QWidget(NULL);
  m_previewOverlay->setAutoFillBackground(true);
  m_previewOverlay->setPalette(pal);
  m_previewOverlay->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint);
  m_previewOverlay->setWindowOpacity(0.3);
  m_previewOverlay->setAttribute(Qt::WA_ShowWithoutActivating);
  m_previewOverlay->setAttribute(Qt::WA_AlwaysStackOnTop);
  m_previewOverlay->hide();

  m_previewTabOverlay = new QWidget(NULL);
  m_previewTabOverlay->setAutoFillBackground(true);
  m_previewTabOverlay->setPalette(pal);
  m_previewTabOverlay->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint);
  m_previewTabOverlay->setWindowOpacity(0.3);
  m_previewTabOverlay->setAttribute(Qt::WA_ShowWithoutActivating);
  m_previewTabOverlay->setAttribute(Qt::WA_AlwaysStackOnTop);
  m_previewTabOverlay->hide();


  for (int i=0; i < NumReferenceTypes; i++)
    m_dropHotspots[i] = NULL;

  m_dropHotspotDimension = 32;
  m_dropHotspotMargin = 4;

  drawHotspotPixmaps();

  for (AreaReferenceType type : { AddTo,
                                  TopOf, LeftOf,
                                  RightOf, BottomOf,
                                  TopWindowSide, LeftWindowSide,
                                  RightWindowSide, BottomWindowSide }) {
    m_dropHotspots[type] = new QLabel(NULL);
    m_dropHotspots[type]->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint);
    m_dropHotspots[type]->setAttribute(Qt::WA_ShowWithoutActivating);
    m_dropHotspots[type]->setAttribute(Qt::WA_AlwaysStackOnTop);
    m_dropHotspots[type]->setPixmap(m_pixmaps[type]);
    m_dropHotspots[type]->setFixedSize(m_dropHotspotDimension, m_dropHotspotDimension);
  }
}

ToolWindowManager::~ToolWindowManager() {
  delete m_previewOverlay;
  delete m_previewTabOverlay;
  for(QWidget *hotspot : m_dropHotspots)
    delete hotspot;
  while(!m_areas.isEmpty()) {
    delete m_areas.first();
  }
  while(!m_wrappers.isEmpty()) {
    delete m_wrappers.first();
  }
}

void ToolWindowManager::setToolWindowProperties(QWidget* toolWindow, ToolWindowManager::ToolWindowProperty properties) {
  m_toolWindowProperties[toolWindow] = properties;
  ToolWindowManagerArea *area = areaOf(toolWindow);
  if(area)
    area->updateToolWindow(toolWindow);
}

ToolWindowManager::ToolWindowProperty ToolWindowManager::toolWindowProperties(QWidget* toolWindow) {
  return m_toolWindowProperties[toolWindow];
}

void ToolWindowManager::addToolWindow(QWidget *toolWindow, const AreaReference &area) {
  addToolWindows(QList<QWidget*>() << toolWindow, area);
}

void ToolWindowManager::addToolWindows(QList<QWidget *> toolWindows, const ToolWindowManager::AreaReference &area) {
  foreach(QWidget* toolWindow, toolWindows) {
    if (!toolWindow) {
      qWarning("cannot add null widget");
      continue;
    }
    if (m_toolWindows.contains(toolWindow)) {
      qWarning("this tool window has already been added");
      continue;
    }
    toolWindow->hide();
    toolWindow->setParent(0);
    m_toolWindows << toolWindow;
    m_toolWindowProperties[toolWindow] = ToolWindowProperty(0);
    QObject::connect(toolWindow, &QWidget::windowTitleChanged, this, &ToolWindowManager::windowTitleChanged);
  }
  moveToolWindows(toolWindows, area);
}

ToolWindowManagerArea *ToolWindowManager::areaOf(QWidget *toolWindow) {
  return findClosestParent<ToolWindowManagerArea*>(toolWindow);
}

ToolWindowManagerWrapper *ToolWindowManager::wrapperOf(QWidget *toolWindow) {
  return findClosestParent<ToolWindowManagerWrapper*>(toolWindow);
}

void ToolWindowManager::moveToolWindow(QWidget *toolWindow, AreaReference area) {
  moveToolWindows(QList<QWidget*>() << toolWindow, area);
}

void ToolWindowManager::moveToolWindows(QList<QWidget *> toolWindows,
                                        ToolWindowManager::AreaReference area) {
  QList<ToolWindowManagerWrapper*> wrappersToUpdate;
  foreach(QWidget* toolWindow, toolWindows) {
    if (!m_toolWindows.contains(toolWindow)) {
      qWarning("unknown tool window");
      return;
    }
    ToolWindowManagerWrapper *oldWrapper = wrapperOf(toolWindow);
    if (toolWindow->parentWidget() != 0) {
      releaseToolWindow(toolWindow);
    }
    if (oldWrapper && !wrappersToUpdate.contains(oldWrapper))
      wrappersToUpdate.push_back(oldWrapper);
  }
  if (area.type() == LastUsedArea && !m_lastUsedArea) {
    ToolWindowManagerArea* foundArea = findChild<ToolWindowManagerArea*>();
    if (foundArea) {
      area = AreaReference(AddTo, foundArea);
    } else {
      area = EmptySpace;
    }
  }

  if (area.type() == NoArea) {
    //do nothing
  } else if (area.type() == NewFloatingArea) {
    ToolWindowManagerArea* floatArea = createArea();
    floatArea->addToolWindows(toolWindows);
    ToolWindowManagerWrapper* wrapper = new ToolWindowManagerWrapper(this, true);
    wrapper->layout()->addWidget(floatArea);
    wrapper->move(QCursor::pos());
    wrapper->updateTitle();
    wrapper->show();
  } else if (area.type() == AddTo) {
    int idx = -1;
    if (area.dragResult) {
      idx = area.area()->tabBar()->tabAt(area.area()->tabBar()->mapFromGlobal(QCursor::pos()));
    }
    area.area()->addToolWindows(toolWindows, idx);
  } else if (area.type() == LeftWindowSide || area.type() == RightWindowSide ||
             area.type() == TopWindowSide || area.type() == BottomWindowSide) {
    ToolWindowManagerWrapper* wrapper = findClosestParent<ToolWindowManagerWrapper*>(area.area());
    if (!wrapper) {
      qWarning("couldn't find wrapper");
      return;
    }

    if (wrapper->layout()->count() > 1)
    {
      qWarning("wrapper has multiple direct children");
      return;
    }

    QLayoutItem* item = wrapper->layout()->takeAt(0);

    QSplitter* splitter = createSplitter();
    if (area.type() == TopWindowSide || area.type() == BottomWindowSide) {
      splitter->setOrientation(Qt::Vertical);
    } else {
      splitter->setOrientation(Qt::Horizontal);
    }

    splitter->addWidget(item->widget());
    area.widget()->show();

    delete item;

    ToolWindowManagerArea* newArea = createArea();
    newArea->addToolWindows(toolWindows);

    if (area.type() == TopWindowSide || area.type() == LeftWindowSide) {
      splitter->insertWidget(0, newArea);
    } else {
      splitter->addWidget(newArea);
    }

    wrapper->layout()->addWidget(splitter);
  } else if (area.type() == LeftOf || area.type() == RightOf ||
             area.type() == TopOf || area.type() == BottomOf) {
    QSplitter* parentSplitter = qobject_cast<QSplitter*>(area.widget()->parentWidget());
    ToolWindowManagerWrapper* wrapper = qobject_cast<ToolWindowManagerWrapper*>(area.widget()->parentWidget());
    if (!parentSplitter && !wrapper) {
      qWarning("unknown parent type");
      return;
    }
    bool useParentSplitter = false;
    int indexInParentSplitter = 0;
    QList<int> parentSplitterSizes;
    if (parentSplitter) {
      indexInParentSplitter = parentSplitter->indexOf(area.widget());
      parentSplitterSizes = parentSplitter->sizes();
      if (parentSplitter->orientation() == Qt::Vertical) {
        useParentSplitter = area.type() == TopOf || area.type() == BottomOf;
      } else {
        useParentSplitter = area.type() == LeftOf || area.type() == RightOf;
      }
    }
    if (useParentSplitter) {
      int insertIndex = indexInParentSplitter;
      if (area.type() == BottomOf || area.type() == RightOf) {
        insertIndex++;
      }
      ToolWindowManagerArea* newArea = createArea();
      newArea->addToolWindows(toolWindows);
      parentSplitter->insertWidget(insertIndex, newArea);

      if(parentSplitterSizes.count() > indexInParentSplitter && parentSplitterSizes[0] != 0) {
        int availSize = parentSplitterSizes[indexInParentSplitter];

        parentSplitterSizes[indexInParentSplitter] = int(availSize * (1.0f - area.percentage()));
        parentSplitterSizes.insert(indexInParentSplitter, int(availSize * area.percentage()));

        parentSplitter->setSizes(parentSplitterSizes);
      }
    } else {
      area.widget()->hide();
      area.widget()->setParent(0);
      QSplitter* splitter = createSplitter();
      if (area.type() == TopOf || area.type() == BottomOf) {
        splitter->setOrientation(Qt::Vertical);
      } else {
        splitter->setOrientation(Qt::Horizontal);
      }

      ToolWindowManagerArea* newArea = createArea();

      // inherit the size policy from the widget we are wrapping
      splitter->setSizePolicy(area.widget()->sizePolicy());

      // store old geometries so we can restore them
      QRect areaGeometry = area.widget()->geometry();
      QRect newGeometry = newArea->geometry();

      splitter->addWidget(area.widget());
      area.widget()->show();

      if (area.type() == TopOf || area.type() == LeftOf) {
        splitter->insertWidget(0, newArea);
      } else {
        splitter->addWidget(newArea);
      }

      if (parentSplitter) {
        parentSplitter->insertWidget(indexInParentSplitter, splitter);

        if (parentSplitterSizes.count() > 0 && parentSplitterSizes[0] != 0) {
          parentSplitter->setSizes(parentSplitterSizes);
        }

      } else {
        wrapper->layout()->addWidget(splitter);
      }

      newArea->addToolWindows(toolWindows);

      area.widget()->setGeometry(areaGeometry);
      newArea->setGeometry(newGeometry);

      // Convert area percentage desired to relative sizes.
      const int totalStretch =
        (area.type() == TopOf || area.type() == BottomOf)
        ? areaGeometry.height() : areaGeometry.width();
      int pct = int(totalStretch*area.percentage());

      int a = pct;
      int b = totalStretch-pct;

      if (area.type() == BottomOf || area.type() == RightOf)
        std::swap(a, b);

      splitter->setSizes({a, b});
    }
  } else if (area.type() == EmptySpace) {
    ToolWindowManagerArea* newArea = createArea();
    findChild<ToolWindowManagerWrapper*>()->layout()->addWidget(newArea);
    newArea->addToolWindows(toolWindows);
  } else if (area.type() == LastUsedArea) {
    m_lastUsedArea->addToolWindows(toolWindows);
  } else {
    qWarning("invalid type");
  }
  simplifyLayout();
  foreach(QWidget* toolWindow, toolWindows) {
    emit toolWindowVisibilityChanged(toolWindow, toolWindow->parent() != 0);
    ToolWindowManagerWrapper* wrapper = wrapperOf(toolWindow);
    if (wrapper && !wrappersToUpdate.contains(wrapper))
      wrappersToUpdate.push_back(wrapper);
  }
  foreach(ToolWindowManagerWrapper* wrapper, wrappersToUpdate) {
    wrapper->updateTitle();
  }
}

void ToolWindowManager::removeToolWindow(QWidget *toolWindow) {
  if (!m_toolWindows.contains(toolWindow)) {
    qWarning("unknown tool window");
    return;
  }

  // search up to find the first parent manager
  ToolWindowManager *manager = findClosestParent<ToolWindowManager*>(toolWindow);

  if (!manager) {
    qWarning("unknown tool window");
    return;
  }

  if (!manager->allowClose(toolWindow))
    return;

  moveToolWindow(toolWindow, NoArea);
  m_toolWindows.removeOne(toolWindow);
  m_toolWindowProperties.remove(toolWindow);
  delete toolWindow;
}

ToolWindowManager* ToolWindowManager::managerOf(QWidget* toolWindow) {
  if (!toolWindow) {
    qWarning("NULL tool window");
    return NULL;
  }

  return findClosestParent<ToolWindowManager*>(toolWindow);
}

void ToolWindowManager::closeToolWindow(QWidget *toolWindow) {
  if (!toolWindow) {
    qWarning("NULL tool window");
    return;
  }

  // search up to find the first parent manager
  ToolWindowManager *manager = findClosestParent<ToolWindowManager*>(toolWindow);

  if(manager) {
    manager->removeToolWindow(toolWindow);
    return;
  }

  qWarning("window not child of any tool window");
}

void ToolWindowManager::raiseToolWindow(QWidget *toolWindow) {
  if (!toolWindow) {
    qWarning("NULL tool window");
    return;
  }

  // if the parent is a ToolWindowManagerArea, switch tabs
  QWidget *parent = toolWindow->parentWidget();
  ToolWindowManagerArea *area = qobject_cast<ToolWindowManagerArea*>(parent);
  if(area == NULL)
    parent = parent->parentWidget();

  area = qobject_cast<ToolWindowManagerArea*>(parent);

  if(area)
    area->setCurrentWidget(toolWindow);
  else
    qWarning("parent is not a tool window area");
}

QWidget* ToolWindowManager::createToolWindow(const QString& objectName)
{
  if (m_createCallback) {
    QWidget *toolWindow = m_createCallback(objectName);
    if(toolWindow) {
      m_toolWindows << toolWindow;
      m_toolWindowProperties[toolWindow] = ToolWindowProperty(0);
      QObject::connect(toolWindow, &QWidget::windowTitleChanged, this, &ToolWindowManager::windowTitleChanged);
      return toolWindow;
    }
  }

  return NULL;
}

void ToolWindowManager::setDropHotspotMargin(int pixels) {
  m_dropHotspotMargin = pixels;
  drawHotspotPixmaps();
}

void ToolWindowManager::setDropHotspotDimension(int pixels) {
  m_dropHotspotDimension = pixels;

  for (QLabel *hotspot : m_dropHotspots) {
    if(hotspot)
      hotspot->setFixedSize(m_dropHotspotDimension, m_dropHotspotDimension);
  }
}

void ToolWindowManager::setAllowFloatingWindow(bool allow) {
  m_allowFloatingWindow = allow;
}

QVariantMap ToolWindowManager::saveState() {
  QVariantMap result;
  result[QStringLiteral("toolWindowManagerStateFormat")] = 1;
  ToolWindowManagerWrapper* mainWrapper = findChild<ToolWindowManagerWrapper*>();
  if (!mainWrapper) {
    qWarning("can't find main wrapper");
    return QVariantMap();
  }
  result[QStringLiteral("mainWrapper")] = mainWrapper->saveState();
  QVariantList floatingWindowsData;
  foreach(ToolWindowManagerWrapper* wrapper, m_wrappers) {
    if (!wrapper->isWindow()) { continue; }
    floatingWindowsData << wrapper->saveState();
  }
  result[QStringLiteral("floatingWindows")] = floatingWindowsData;
  return result;
}

void ToolWindowManager::restoreState(const QVariantMap &dataMap) {
  if (dataMap.isEmpty()) { return; }
  if (dataMap[QStringLiteral("toolWindowManagerStateFormat")].toInt() != 1) {
    qWarning("state format is not recognized");
    return;
  }
  moveToolWindows(m_toolWindows, NoArea);
  ToolWindowManagerWrapper* mainWrapper = findChild<ToolWindowManagerWrapper*>();
  if (!mainWrapper) {
    qWarning("can't find main wrapper");
    return;
  }
  mainWrapper->restoreState(dataMap[QStringLiteral("mainWrapper")].toMap());
  QVariantList floatWins = dataMap[QStringLiteral("floatingWindows")].toList();
  foreach(QVariant windowData, floatWins) {
    ToolWindowManagerWrapper* wrapper = new ToolWindowManagerWrapper(this, true);
    wrapper->restoreState(windowData.toMap());
    wrapper->updateTitle();
    wrapper->show();
    if(wrapper->windowState() & Qt::WindowMaximized)
    {
      wrapper->setWindowState(0);
      wrapper->setWindowState(Qt::WindowMaximized);
    }
  }
  simplifyLayout();
  foreach(QWidget* toolWindow, m_toolWindows) {
    emit toolWindowVisibilityChanged(toolWindow, toolWindow->parentWidget() != 0);
  }
}

ToolWindowManagerArea *ToolWindowManager::createArea() {
  ToolWindowManagerArea* area = new ToolWindowManagerArea(this, 0);
  connect(area, SIGNAL(tabCloseRequested(int)),
          this, SLOT(tabCloseRequested(int)));
  return area;
}

void ToolWindowManager::releaseToolWindow(QWidget *toolWindow) {
  ToolWindowManagerArea* previousTabWidget = findClosestParent<ToolWindowManagerArea*>(toolWindow);
  if (!previousTabWidget) {
    qWarning("cannot find tab widget for tool window");
    return;
  }
  previousTabWidget->removeTab(previousTabWidget->indexOf(toolWindow));
  toolWindow->hide();
  toolWindow->setParent(0);

}

void ToolWindowManager::simplifyLayout() {
  foreach(ToolWindowManagerArea* area, m_areas) {
    if (area->parentWidget() == 0) {
      if (area->count() == 0) {
        if (area == m_lastUsedArea) { m_lastUsedArea = 0; }
        //QTimer::singleShot(1000, area, SLOT(deleteLater()));
        area->deleteLater();
      }
      continue;
    }
    QSplitter* splitter = qobject_cast<QSplitter*>(area->parentWidget());
    QSplitter* validSplitter = 0; // least top level splitter that should remain
    QSplitter* invalidSplitter = 0; //most top level splitter that should be deleted
    while(splitter) {
      if (splitter->count() > 1) {
        validSplitter = splitter;
        break;
      } else {
        invalidSplitter = splitter;
        splitter = qobject_cast<QSplitter*>(splitter->parentWidget());
      }
    }
    if (!validSplitter) {
      ToolWindowManagerWrapper* wrapper = findClosestParent<ToolWindowManagerWrapper*>(area);
      if (!wrapper) {
        qWarning("can't find wrapper");
        return;
      }
      if (area->count() == 0 && wrapper->isWindow()) {
        wrapper->hide();
        // can't deleteLater immediately (strange MacOS bug)
        //QTimer::singleShot(1000, wrapper, SLOT(deleteLater()));
        wrapper->deleteLater();
      } else if (area->parent() != wrapper) {
        wrapper->layout()->addWidget(area);
      }
    } else {
      if (area->count() > 0) {
        if (validSplitter && area->parent() != validSplitter) {
          int index = validSplitter->indexOf(invalidSplitter);
          validSplitter->insertWidget(index, area);
        }
      }
    }
    if (invalidSplitter) {
      invalidSplitter->hide();
      invalidSplitter->setParent(0);
      //QTimer::singleShot(1000, invalidSplitter, SLOT(deleteLater()));
      invalidSplitter->deleteLater();
    }
    if (area->count() == 0) {
      area->hide();
      area->setParent(0);
      if (area == m_lastUsedArea) { m_lastUsedArea = 0; }
      //QTimer::singleShot(1000, area, SLOT(deleteLater()));
      area->deleteLater();
    }
  }
}

void ToolWindowManager::startDrag(const QList<QWidget *> &toolWindows,
                                  ToolWindowManagerWrapper *wrapper) {
  if (dragInProgress()) {
    qWarning("ToolWindowManager::execDrag: drag is already in progress");
    return;
  }
  foreach(QWidget* toolWindow, toolWindows) {
    if(toolWindowProperties(toolWindow) & DisallowUserDocking) { return; }
  }
  if (toolWindows.isEmpty()) { return; }

  m_draggedWrapper = wrapper;
  m_draggedToolWindows = toolWindows;
  qApp->installEventFilter(this);
}

QVariantMap ToolWindowManager::saveSplitterState(QSplitter *splitter) {
  QVariantMap result;
  result[QStringLiteral("state")] = splitter->saveState().toBase64();
  result[QStringLiteral("type")] = QStringLiteral("splitter");
  QVariantList items;
  for(int i = 0; i < splitter->count(); i++) {
    QWidget* item = splitter->widget(i);
    QVariantMap itemValue;
    ToolWindowManagerArea* area = qobject_cast<ToolWindowManagerArea*>(item);
    if (area) {
      itemValue = area->saveState();
    } else {
      QSplitter* childSplitter = qobject_cast<QSplitter*>(item);
      if (childSplitter) {
        itemValue = saveSplitterState(childSplitter);
      } else {
        qWarning("unknown splitter item");
      }
    }
    items << itemValue;
  }
  result[QStringLiteral("items")] = items;
  return result;
}

QSplitter *ToolWindowManager::restoreSplitterState(const QVariantMap &savedData) {
  if (savedData[QStringLiteral("items")].toList().count() < 2) {
    qWarning("invalid splitter encountered");
  }
  QSplitter* splitter = createSplitter();

  QVariantList itemList = savedData[QStringLiteral("items")].toList();
  foreach(QVariant itemData, itemList) {
    QVariantMap itemValue = itemData.toMap();
    QString itemType = itemValue[QStringLiteral("type")].toString();
    if (itemType == QStringLiteral("splitter")) {
      splitter->addWidget(restoreSplitterState(itemValue));
    } else if (itemType == QStringLiteral("area")) {
      ToolWindowManagerArea* area = createArea();
      area->restoreState(itemValue);
      splitter->addWidget(area);
    } else {
      qWarning("unknown item type");
    }
  }
  splitter->restoreState(QByteArray::fromBase64(savedData[QStringLiteral("state")].toByteArray()));
  return splitter;
}

void ToolWindowManager::updateDragPosition() {
  if (!dragInProgress()) { return; }
  if (!(qApp->mouseButtons() & Qt::LeftButton)) {
    finishDrag();
    return;
  }

  QPoint pos = QCursor::pos();
  m_hoverArea = NULL;
  ToolWindowManagerWrapper* hoverWrapper = NULL;

  foreach(ToolWindowManagerArea* area, m_areas) {
    // don't allow dragging a whole wrapper into a subset of itself
    if (m_draggedWrapper && area->window() == m_draggedWrapper->window()) {
      continue;
    }
    if (area->rect().contains(area->mapFromGlobal(pos))) {
      m_hoverArea = area;
      break;
    }
  }

  if (m_hoverArea == NULL) {
    foreach(ToolWindowManagerWrapper* wrapper, m_wrappers) {
      // don't allow dragging a whole wrapper into a subset of itself
      if (wrapper == m_draggedWrapper) {
        continue;
      }
      if (wrapper->rect().contains(wrapper->mapFromGlobal(pos))) {
        hoverWrapper = wrapper;
        break;
      }
    }

    // if we found a wrapper and it's not empty, then we fill into a gap between two areas in a
    // splitter. Search down the hierarchy until we find a splitter whose handle intersects the
    // cursor and pick an area to map to.
    if (hoverWrapper) {
      QSplitter* splitter = qobject_cast<QSplitter *>(hoverWrapper->layout()->itemAt(0)->widget());

      while (splitter) {
        QSplitter* previous = splitter;

        for (int h=1; h < splitter->count(); h++) {
          QSplitterHandle* handle = splitter->handle(h);

          if (handle->rect().contains(handle->mapFromGlobal(pos))) {
            QWidget* a = splitter->widget(h);
            QWidget* b = splitter->widget(h+1);

            // try the first widget, if it's an area stop
            m_hoverArea = qobject_cast<ToolWindowManagerArea *>(a);
            if (m_hoverArea)
              break;

            // then the second widget
            m_hoverArea = qobject_cast<ToolWindowManagerArea *>(b);
            if (m_hoverArea)
              break;

            // neither widget is an area - let's search for a splitter to recurse to
            splitter = qobject_cast<QSplitter *>(a);
            if (splitter)
              break;

            splitter = qobject_cast<QSplitter *>(b);
            if (splitter)
              break;

            // neither side is an area or a splitter - should be impossible, but stop recursing
            // and treat this like a floating window
            qWarning("Couldn't find splitter or area at terminal side of splitter");
            splitter = NULL;
            hoverWrapper = NULL;
            break;
          }
        }

        // if we still have a splitter, and didn't find an area, find which widget contains the
        // cursor and recurse to that splitter
        if (previous == splitter && !m_hoverArea)
        {
          for (int w=0; w < splitter->count(); w++) {
            QWidget* widget = splitter->widget(w);

            if (widget->rect().contains(widget->mapFromGlobal(pos))) {
              splitter = qobject_cast<QSplitter *>(widget);
              if (splitter)
                break;

              // if this isn't a splitter, and it's not an area (since that would have been found
              // before any of this started) then bail out
              qWarning("cursor inside unknown child widget that isn't a splitter or area");
              splitter = NULL;
              hoverWrapper = NULL;
              break;
            }
          }
        }

        // we found an area to use! stop now
        if (m_hoverArea)
          break;

        // if we still haven't found anything, bail out
        if (previous == splitter)
        {
          qWarning("Couldn't find cursor inside any child of wrapper");
          splitter = NULL;
          hoverWrapper = NULL;
          break;
        }
      }
    }
  }

  if (m_hoverArea || hoverWrapper) {
    ToolWindowManagerWrapper* wrapper = hoverWrapper;
    if (m_hoverArea)
      wrapper = findClosestParent<ToolWindowManagerWrapper*>(m_hoverArea);
    QRect wrapperGeometry;
    wrapperGeometry.setSize(wrapper->rect().size());
    wrapperGeometry.moveTo(wrapper->mapToGlobal(QPoint(0,0)));

    const int margin = m_dropHotspotMargin;

    const int size = m_dropHotspotDimension;
    const int hsize = size / 2;

    if (m_hoverArea) {
      QRect areaClientRect;

      // calculate the rect of the area
      areaClientRect.setTopLeft(m_hoverArea->mapToGlobal(QPoint(0,0)));
      areaClientRect.setSize(m_hoverArea->rect().size());

      // subtract the rect for the tab bar.
      areaClientRect.adjust(0, m_hoverArea->tabBar()->rect().height(), 0, 0);

      QPoint c = areaClientRect.center();

      m_dropHotspots[AddTo]->move(c + QPoint(-hsize, -hsize));
      m_dropHotspots[AddTo]->show();

      m_dropHotspots[TopOf]->move(c + QPoint(-hsize, -hsize-margin-size));
      m_dropHotspots[TopOf]->show();

      m_dropHotspots[LeftOf]->move(c + QPoint(-hsize-margin-size, -hsize));
      m_dropHotspots[LeftOf]->show();

      m_dropHotspots[RightOf]->move(c + QPoint( hsize+margin, -hsize));
      m_dropHotspots[RightOf]->show();

      m_dropHotspots[BottomOf]->move(c + QPoint(-hsize, hsize+margin));
      m_dropHotspots[BottomOf]->show();

      c = wrapperGeometry.center();

      m_dropHotspots[TopWindowSide]->move(QPoint(c.x() - hsize, wrapperGeometry.y() + margin * 2));
      m_dropHotspots[TopWindowSide]->show();

      m_dropHotspots[LeftWindowSide]->move(QPoint(wrapperGeometry.x() + margin * 2, c.y() - hsize));
      m_dropHotspots[LeftWindowSide]->show();

      m_dropHotspots[RightWindowSide]->move(QPoint(wrapperGeometry.right() - size - margin * 2, c.y() - hsize));
      m_dropHotspots[RightWindowSide]->show();

      m_dropHotspots[BottomWindowSide]->move(QPoint(c.x() - hsize, wrapperGeometry.bottom() - size - margin * 2));
      m_dropHotspots[BottomWindowSide]->show();
    } else {
      m_dropHotspots[AddTo]->move(wrapperGeometry.center() + QPoint(-hsize, -hsize));
      m_dropHotspots[AddTo]->show();

      m_dropHotspots[TopOf]->hide();
      m_dropHotspots[LeftOf]->hide();
      m_dropHotspots[RightOf]->hide();
      m_dropHotspots[BottomOf]->hide();

      m_dropHotspots[TopWindowSide]->hide();
      m_dropHotspots[LeftWindowSide]->hide();
      m_dropHotspots[RightWindowSide]->hide();
      m_dropHotspots[BottomWindowSide]->hide();
    }

    for(QWidget *hotspot : m_dropHotspots)
      if(hotspot)
        hotspot->show();
  } else {
    for(QWidget *hotspot : m_dropHotspots)
      if(hotspot)
        hotspot->hide();
  }

  AreaReferenceType hotspot = currentHotspot();
  if ((m_hoverArea || hoverWrapper) &&
      (hotspot == AddTo ||
       hotspot == LeftOf || hotspot == RightOf ||
       hotspot == TopOf || hotspot == BottomOf)) {
    QWidget *parent = m_hoverArea;
    if(parent == NULL)
      parent = hoverWrapper;

    QRect g = parent->geometry();
    g.moveTopLeft(parent->parentWidget()->mapToGlobal(g.topLeft()));

    if (hotspot == LeftOf)
      g.adjust(0, 0, -g.width()/2, 0);
    else if (hotspot == RightOf)
      g.adjust(g.width()/2, 0, 0, 0);
    else if (hotspot == TopOf)
      g.adjust(0, 0, 0, -g.height()/2);
    else if (hotspot == BottomOf)
      g.adjust(0, g.height()/2, 0, 0);

    QRect tabGeom;

    if (hotspot == AddTo && m_hoverArea && m_hoverArea->count() > 1) {
      QTabBar* tb = m_hoverArea->tabBar();
      g.adjust(0, tb->rect().height(), 0, 0);

      int idx = tb->tabAt(tb->mapFromGlobal(pos));

      if (idx == -1) {
        tabGeom = tb->tabRect(m_hoverArea->count()-1);
        tabGeom.moveTo(tb->mapToGlobal(QPoint(0,0)) + tabGeom.topLeft());

        // move the tab one to the right, to indicate the tab is being added after the last one.
        tabGeom.moveLeft(tabGeom.left() + tabGeom.width());

        // clamp from the right, to ensure we don't display any tab off the end of the range
        if(tabGeom.right() > g.right())
          tabGeom.moveLeft(g.right() - tabGeom.width());
      } else {
        tabGeom = tb->tabRect(idx);
        tabGeom.moveTo(tb->mapToGlobal(QPoint(0,0)) + tabGeom.topLeft());
      }
    }

    m_previewOverlay->setGeometry(g);

    m_previewTabOverlay->setGeometry(tabGeom);
  } else if((m_hoverArea || hoverWrapper) &&
            (hotspot == LeftWindowSide || hotspot == RightWindowSide ||
             hotspot == TopWindowSide || hotspot == BottomWindowSide)) {
    ToolWindowManagerWrapper* wrapper = hoverWrapper;
    if (m_hoverArea)
      wrapper = findClosestParent<ToolWindowManagerWrapper*>(m_hoverArea);

    QRect g;
    g.moveTopLeft(wrapper->mapToGlobal(QPoint()));
    g.setSize(wrapper->rect().size());

    if(hotspot == LeftWindowSide)
      g.adjust(0, 0, -(g.width()*5)/6, 0);
    else if(hotspot == RightWindowSide)
      g.adjust((g.width()*5)/6, 0, 0, 0);
    else if(hotspot == TopWindowSide)
      g.adjust(0, 0, 0, -(g.height()*3)/4);
    else if(hotspot == BottomWindowSide)
      g.adjust(0, (g.height()*3)/4, 0, 0);

    m_previewOverlay->setGeometry(g);
    m_previewTabOverlay->setGeometry(QRect());
  } else {
    bool allowFloat = m_allowFloatingWindow;

    for (QWidget *w : m_draggedToolWindows)
      allowFloat &= !(toolWindowProperties(w) & DisallowFloatWindow);

    // no hotspot highlighted, draw geometry for a float window if previewing a tear-off, or draw
    // nothing if we're dragging a float window as it moves itself.
    // we also don't render any preview tear-off when floating windows are disallowed
    if (m_draggedWrapper || !allowFloat) {
      m_previewOverlay->setGeometry(QRect());
    } else {
      QRect r;
      for (QWidget *w : m_draggedToolWindows) {
        if (w->isVisible())
          r = r.united(w->rect());
      }
      m_previewOverlay->setGeometry(pos.x(), pos.y(), r.width(), r.height());
    }
    m_previewTabOverlay->setGeometry(QRect());
  }

  m_previewOverlay->show();
  m_previewTabOverlay->show();
  for(QWidget *h : m_dropHotspots)
    if(h && h->isVisible())
      h->raise();
}

void ToolWindowManager::abortDrag() {
  if (!dragInProgress())
    return;

  m_previewOverlay->hide();
  m_previewTabOverlay->hide();
  for(QWidget *hotspot : m_dropHotspots)
    if(hotspot)
      hotspot->hide();
  m_draggedToolWindows.clear();
  m_draggedWrapper = NULL;
  qApp->removeEventFilter(this);
}

void ToolWindowManager::finishDrag() {
  if (!dragInProgress()) {
    qWarning("unexpected finishDrag");
    return;
  }
  qApp->removeEventFilter(this);

  // move these locally to prevent re-entrancy
  QList<QWidget *> draggedToolWindows = m_draggedToolWindows;
  ToolWindowManagerWrapper* draggedWrapper = m_draggedWrapper;

  m_draggedToolWindows.clear();
  m_draggedWrapper = NULL;

  AreaReferenceType hotspot = currentHotspot();

  m_previewOverlay->hide();
  m_previewTabOverlay->hide();
  for(QWidget *h : m_dropHotspots)
    if(h)
      h->hide();

  if (hotspot == NewFloatingArea) {
    // check if we're dragging a whole float window, if so we don't do anything as it's already moved
    if (!draggedWrapper) {
      bool allowFloat = m_allowFloatingWindow;

      for (QWidget *w : draggedToolWindows)
        allowFloat &= !(toolWindowProperties(w) & DisallowFloatWindow);

      if (allowFloat)
      {
        QRect r;
        for (QWidget *w : draggedToolWindows) {
          if (w->isVisible())
            r = r.united(w->rect());
        }

        moveToolWindows(draggedToolWindows, NewFloatingArea);

        ToolWindowManagerArea *area = areaOf(draggedToolWindows[0]);

        area->parentWidget()->resize(r.size());
      }
    }
  } else {
    if (m_hoverArea) {
      AreaReference ref(hotspot, m_hoverArea);
      ref.dragResult = true;
      moveToolWindows(draggedToolWindows, ref);
    } else {
      moveToolWindows(draggedToolWindows, AreaReference(EmptySpace));
    }
  }
}

void ToolWindowManager::drawHotspotPixmaps() {
  for (AreaReferenceType ref : { AddTo, LeftOf, TopOf, RightOf, BottomOf }) {
    m_pixmaps[ref] = QPixmap(m_dropHotspotDimension*devicePixelRatio(), m_dropHotspotDimension*devicePixelRatio());
    m_pixmaps[ref].setDevicePixelRatio(devicePixelRatioF());

    QPainter p(&m_pixmaps[ref]);
    p.setCompositionMode(QPainter::CompositionMode_Source);
    p.setRenderHint(QPainter::Antialiasing);
    p.setRenderHint(QPainter::HighQualityAntialiasing);

    QRectF rect(0, 0, m_dropHotspotDimension, m_dropHotspotDimension);

    p.fillRect(rect, Qt::transparent);

    rect = rect.marginsAdded(QMarginsF(-1, -1, -1, -1));

    p.setPen(QPen(QBrush(Qt::darkGray), 1.5));
    p.setBrush(QBrush(Qt::lightGray));
    p.drawRoundedRect(rect, 1.5, 1.5, Qt::AbsoluteSize);

    rect = rect.marginsAdded(QMarginsF(-4, -4, -4, -4));

    QRectF fullRect = rect;

    if (ref == LeftOf)
      rect = rect.marginsAdded(QMarginsF(0, 0, -12, 0));
    else if (ref == TopOf)
      rect = rect.marginsAdded(QMarginsF(0, 0, 0, -12));
    else if (ref == RightOf)
      rect = rect.marginsAdded(QMarginsF(-12, 0, 0, 0));
    else if (ref == BottomOf)
      rect = rect.marginsAdded(QMarginsF(0, -12, 0, 0));

    p.setPen(QPen(QBrush(Qt::black), 1.0));
    p.setBrush(QBrush(Qt::white));
    p.drawRect(rect);

    // add a little title bar
    rect.setHeight(3);
    p.fillRect(rect, Qt::SolidPattern);

    // for the sides, add an arrow.
    if (ref != AddTo) {
      QPainterPath path;

      if (ref == LeftOf) {
        QPointF tip = fullRect.center() + QPointF( 4,  0);

        path.addPolygon(QPolygonF({tip,
                                  tip + QPoint( 3,  3),
                                  tip + QPoint( 3, -3),
                                 }));
      } else if (ref == TopOf) {
        QPointF tip = fullRect.center() + QPointF( 0,  4);

        path.addPolygon(QPolygonF({tip,
                                  tip + QPointF(-3,  3),
                                  tip + QPointF( 3,  3),
                                 }));
      } else if (ref == RightOf) {
        QPointF tip = fullRect.center() + QPointF(-4,  0);

        path.addPolygon(QPolygonF({tip,
                                  tip + QPointF(-3,  3),
                                  tip + QPointF(-3, -3),
                                 }));
      } else if (ref == BottomOf) {
        QPointF tip = fullRect.center() + QPointF( 0, -4);

        path.addPolygon(QPolygonF({tip,
                                  tip + QPointF(-3, -3),
                                  tip + QPointF( 3, -3),
                                 }));
      }

      p.fillPath(path, QBrush(Qt::black));
    }
  }

  // duplicate these pixmaps by default
  m_pixmaps[LeftWindowSide] = m_pixmaps[LeftOf];
  m_pixmaps[RightWindowSide] = m_pixmaps[RightOf];
  m_pixmaps[TopWindowSide] = m_pixmaps[TopOf];
  m_pixmaps[BottomWindowSide] = m_pixmaps[BottomOf];
}

ToolWindowManager::AreaReferenceType ToolWindowManager::currentHotspot() {
  QPoint pos = QCursor::pos();

  for (int i=0; i < NumReferenceTypes; i++) {
    if (m_dropHotspots[i] && m_dropHotspots[i]->isVisible() &&
        m_dropHotspots[i]->geometry().contains(pos)) {
      return (ToolWindowManager::AreaReferenceType)i;
    }
  }

  if (m_hoverArea) {
    QTabBar* tb = m_hoverArea->tabBar();
    if (tb->rect().contains(tb->mapFromGlobal(QCursor::pos())))
      return AddTo;
  }

  return NewFloatingArea;
}

bool ToolWindowManager::eventFilter(QObject *object, QEvent *event) {
  if (event->type() == QEvent::MouseButtonRelease) {
    // right clicking aborts any drag in progress
    if (static_cast<QMouseEvent*>(event)->button() == Qt::RightButton)
      abortDrag();
  } else if (event->type() == QEvent::KeyPress) {
    // pressing escape any drag in progress
    QKeyEvent *ke = (QKeyEvent *)event;
    if(ke->key() == Qt::Key_Escape) {
      abortDrag();
    }
  }
  return QWidget::eventFilter(object, event);
}

bool ToolWindowManager::allowClose(QWidget *toolWindow) {
  if (!m_toolWindows.contains(toolWindow)) {
    qWarning("unknown tool window");
    return true;
  }
  int methodIndex = toolWindow->metaObject()->indexOfMethod(QMetaObject::normalizedSignature("checkAllowClose()"));

  if(methodIndex >= 0) {
    bool ret = true;
    toolWindow->metaObject()->method(methodIndex).invoke(toolWindow, Qt::DirectConnection, Q_RETURN_ARG(bool, ret));

    return ret;
  }

  return true;
}

void ToolWindowManager::tabCloseRequested(int index) {
  ToolWindowManagerArea* tabWidget = qobject_cast<ToolWindowManagerArea*>(sender());
  if (!tabWidget) {
    qWarning("sender is not a ToolWindowManagerArea");
    return;
  }
  QWidget* toolWindow = tabWidget->widget(index);
  if (!m_toolWindows.contains(toolWindow)) {
    qWarning("unknown tab in tab widget");
    return;
  }

  if (!allowClose(toolWindow))
    return;

  if(toolWindowProperties(toolWindow) & ToolWindowManager::HideOnClose)
    hideToolWindow(toolWindow);
  else
    removeToolWindow(toolWindow);
}

void ToolWindowManager::windowTitleChanged(const QString &) {
  QWidget* toolWindow = qobject_cast<QWidget*>(sender());
  if(!toolWindow) {
    return;
  }
  ToolWindowManagerArea *area = areaOf(toolWindow);
  if(area) {
    area->updateToolWindow(toolWindow);
  }
}

QSplitter *ToolWindowManager::createSplitter() {
  QSplitter* splitter = new ToolWindowManagerSplitter();
  splitter->setChildrenCollapsible(false);
  return splitter;
}

ToolWindowManager::AreaReference::AreaReference(ToolWindowManager::AreaReferenceType type, ToolWindowManagerArea *area, float percentage) {
  m_type = type;
  m_percentage = percentage;
  dragResult = false;
  setWidget(area);
}

void ToolWindowManager::AreaReference::setWidget(QWidget *widget) {
  if (m_type == LastUsedArea || m_type == NewFloatingArea || m_type == NoArea || m_type == EmptySpace) {
    if (widget != 0) {
      qWarning("area parameter ignored for this type");
    }
    m_widget = 0;
  } else if (m_type == AddTo) {
    m_widget = qobject_cast<ToolWindowManagerArea*>(widget);
    if (!m_widget) {
      qWarning("only ToolWindowManagerArea can be used with this type");
    }
  } else {
    if (!qobject_cast<ToolWindowManagerArea*>(widget) &&
        !qobject_cast<QSplitter*>(widget)) {
      qWarning("only ToolWindowManagerArea or splitter can be used with this type");
      m_widget = 0;
    } else {
      m_widget = widget;
    }
  }
}

ToolWindowManagerArea *ToolWindowManager::AreaReference::area() const {
  return qobject_cast<ToolWindowManagerArea*>(m_widget);
}

ToolWindowManager::AreaReference::AreaReference(ToolWindowManager::AreaReferenceType type, QWidget *widget) {
  m_type = type;
  dragResult = false;
  setWidget(widget);
}