// NOTE: removing a screen after the OpApp was started results in an invisible screen
// NOTE: adding and removing a screen after the OpApp was started in tablet mode will make mmm do weird things

#include "lts_multi_monitor.h"
#include "lts_multi_monitor_selector_normal.h"
#include "lts_multi_monitor_selector_wide.h"
#include "lts_screen_normal.h"
#include "lts_screen_wide.h"
#include "lts_dummy_widget.h"
#include "lts_screen_container.h"

#include <LtsWidgets/lts_message_dialog.h>
#include <LtsWidgets/lts_base_layout_widget.h>
#include <LtsSession/lts_session_data.h>

#include <QGuiApplication>
#include <QScreen>
#include <QPointer>
#include <QWidget>
#include <QRect>
#include <QMessageBox>
#include <QDebug>
#ifdef Q_OS_WIN
#include <QtPlatformHeaders/qwindowswindowfunctions.h>
#endif


namespace LtsMultiMonitor
{
static LtsMultiMonitor *s_ltsMultiMonitor = nullptr;


LtsMultiMonitor *LtsMultiMonitor::getInstance()
{
  if (!s_ltsMultiMonitor)
  {
    s_ltsMultiMonitor = new LtsMultiMonitor;
    qAddPostRoutine(&cleanupLtsMultiMonitor);
  }
  return s_ltsMultiMonitor;
}

void LtsMultiMonitor::cleanupLtsMultiMonitor()
{
  delete s_ltsMultiMonitor;
  s_ltsMultiMonitor = nullptr;
}


LtsMultiMonitor::LtsMultiMonitor()
    : QObject(nullptr)
    , m_mainScreen(nullptr)
    , m_active(false)
    , m_initialized(false)
    , m_skipScreenId(-1)
    , m_subSkipScreenId(-1)
    //  , m_dummy(new QWidget())
    , m_overlapBaseLayouts(false)
    , m_debugMargins(false)
{}


LtsMultiMonitor::~LtsMultiMonitor()
{
  //  if (m_superParent)
  //    m_superParent->deleteLater();

  for (auto i = m_screens.begin(); i != m_screens.end(); ++i)
  {
    LtsScreenBase *screen = *i;
    disconnect(screen, &QObject::destroyed, this, &LtsMultiMonitor::screenDied);
    screen->deleteLater();
  }

  //qDeleteAll(m_screens);
  //delete m_dummy;
  //m_dummy->deleteLater();
}


void LtsMultiMonitor::screenDied()
{
  // qWarning() << "whoops! a screen died!";
  Q_ASSERT(false);
}


void LtsMultiMonitor::init()
{
  // TODO: reinit if device is a tablet, to refresh screen count for attaching screens live
  if (LtsSessionData::LtsSessionData::getInstance()->isTablet())
  {
    m_overlapBaseLayouts = true;
    m_initialized = true;
    return;
  }

  if (m_initialized || !m_active)
    return;

  QList<QScreen *> screenList = QGuiApplication::screens();
  const QScreen &mainScreen = *QGuiApplication::primaryScreen();

  // qWarning() << "skip screen" << m_skipScreenId << "part" << m_subSkipScreenId;

  //for (int i = 0; i < screenList.count(); i++)
  for (auto i = screenList.constBegin(); i != screenList.constEnd(); ++i)
  {
    const QScreen &screen = **i;//screenList.at(i);

    // only add screen if it was not already added, by its serial number
    bool found = false;

    for (LtsScreenBase *ltsScreen : qAsConst(m_screens))
    {
      if (ltsScreen->serialNumber() == screen.name())
      {
        found = true;
        break;
      }
    }

    if (found)
      continue;

    // more like "possible" screen id as there can be some continues, etc.
    int screenId = m_nextScreenId++;
    //    qWarning() << "screen id" << screenId;

    QRect screenGeo(screen.geometry());

    if (screenId == m_skipScreenId) // do not create LtsScreenBase where AVM is (or at least limit the "sub screens")
    {
      if (m_subSkipScreenId == 0)
      {
        // left left side of screen empty
        QRect newScreenGeo(screenGeo);

        newScreenGeo.moveLeft(screenGeo.x() + (screenGeo.width() / 2)/* + 1*/);
        newScreenGeo.setWidth(screenGeo.width() / 2);

        screenGeo = newScreenGeo;
      }
      else if (m_subSkipScreenId == 1)
      {
        // left right side of screen empty
        QRect newScreenGeo(screenGeo);

        newScreenGeo.setWidth(screenGeo.width() / 2); // starts to malfunction in old gnome starting from 1.78 ...

        screenGeo = newScreenGeo;
      }
      else // completely skip LtsScreenBase creation if no sub screen is set
      {
        //   qWarning() << "skipping" << screenId;
        continue;
      }
    }

    //  qWarning() << "screenGeo" << screenGeo;

    bool isUltraWideView = (screenGeo.width() > 3000);

    LtsScreenBase *newScreen;
    if (isUltraWideView)
    {
      newScreen = new LtsScreenWide(screenGeo, screenId, m_debugMargins, screen.name());
    }
    else
    {
      auto *newScreenNormal = new LtsScreenNormal(std::move(screenGeo), screenId, m_debugMargins, screen.name());
      newScreen = newScreenNormal;

      // see https://devhub.defence-elec.de/confluence/x/yLjeDg 13.1
      connect(newScreenNormal, &LtsScreenNormal::signalMakeAllSwole,
              this, &LtsMultiMonitor::signalMakeAllSwole);
      connect(this, &LtsMultiMonitor::signalMakeAllSwole,
              newScreenNormal, &LtsScreenNormal::signalMakeSwole);
    }

    connect(newScreen, &QObject::destroyed, this, &LtsMultiMonitor::screenDied);

    if ((&mainScreen) == (&screen))
      m_mainScreen = newScreen;

    m_screens.append(newScreen);
  }
  if (m_screens.isEmpty())
  {
    QMessageBox::critical(nullptr, QString(), tr("No screens found - cannot start application."));
    abort();
  }

  if (m_mainScreen == nullptr)
    m_mainScreen = m_screens.first();

  m_initialized = true;
  emit signalScreenCountChanged(screenCount());
}


int LtsMultiMonitor::screenCount() const
{
  return m_screens.count();
}


bool LtsMultiMonitor::cancelAndProcessIfInactive(QWidget *widget) const
{
  if (m_active)
    return false;

  widget->activateWindow(); // no mmm => show as discrete window
  widget->show();

  place(widget);

  return true;
}


void LtsMultiMonitor::place(QWidget *widget)
{
  /* tell the blw that it was now sucessfully placed and is shown / ready to use
   * e.g. for autostarting a replay only if it is already visible, so the user
   * doesn't miss out on the replay's beginning
   *
   * -- as this method returns here, we have to emit 'successfullyPlaced' here,
   * as the widget is now visible as its own widget
   */
  auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
  if (blw != nullptr)
    emit blw->signalSuccessfullyPlaced();
}


bool LtsMultiMonitor::putScreen(QWidget *widget, int screenId, int screenPart)
{
  Q_ASSERT(widget != nullptr);
  if (widget == nullptr)
    return false; // fail-safe

  if (cancelAndProcessIfInactive(widget))
    return true;

  init();

  if (overlapBaseLayouts(widget)) // NOTE: call 'init' before 'overlapBaseLayouts'
    return true;


  bool isSecondary = isWidgetSecondary(widget);
  qWarning() << "putScreen: isSecondary" << isSecondary;

  for (LtsScreenBase *screen : qAsConst(m_screens))
  {
    if (screen->screenId() != screenId)
      continue;

    screen->switchToTemp(isSecondary ? LtsScreenBase::WidgetType::SecondaryWidget : LtsScreenBase::WidgetType::MainWidget);

    try
    {
      screen->putWidget(widget, screenPart);      
    }
    catch (...)
    {
      screen->revertSwitch();
      //   qWarning() << "LtsMultiMonitor:::putScreen: cannot put widget on screen "<<screenId<<" at part "<<screenPart<<"! Using selectScreen()!";
      return selectScreen(widget);
    }

    screen->check();
    // qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
    place(widget);
    screen->finalizeSwitch();
    return true;
  }

  // qWarning() << "LtsMultiMonitor:::putScreen: screen"<<screenId<<"not available! Using selectScreen()!";
  return selectScreen(widget);
}

bool LtsMultiMonitor::putScreenAutomatically(QWidget *widget)
{
  if (widget == nullptr)
    return false;

  if (cancelAndProcessIfInactive(widget))
    return true;

  init();

  if (overlapBaseLayouts(widget)) // NOTE: call 'init' before 'overlapBaseLayouts'
    return true;

  for (LtsScreenBase *screen : qAsConst(m_screens))
  {
    if (screen->screenId() == m_skipScreenId || !screen->isEmpty())
      continue;

    screen->switchToTemp(LtsScreenBase::WidgetType::SecondaryWidget);

    try //first try on part 1
    {
      screen->putWidget(widget, 1);      
    }
    catch (...)
    {
      try //if part 1 failed, try part 2
      {
        screen->putWidget(widget, 2);
      }
      catch (...) //if part 2 failed, try next screen
      {
        screen->revertSwitch();
        continue;
      }
    }

    screen->check();
    place(widget);
    screen->finalizeSwitch();

    return true;
  }

  return false;
}


bool LtsMultiMonitor::isOverlapBaseLayouts() const
{
  return (m_overlapBaseLayouts /*&& m_screens.count() == 1*/); // TODO: reactivate if mmm works with external monitors on a tablet
}


void LtsMultiMonitor::freezeMagicCorner(int screenId)
{

  for (auto *screen : qAsConst(m_screens))
  {

    if (screen->screenId() == screenId)
    {
      LtsScreenNormal* normalScreen = qobject_cast<LtsScreenNormal*>(screen);
      if(normalScreen->child()->hasMainWidget() && normalScreen->child()->hasSecondaryWidget())
      {
        normalScreen->hideMagicCorner(true);
        if(normalScreen->child()->activeWidgetType() == LtsScreenBase::WidgetType::MainWidget)
          normalScreen->child()->toggle();
      }
    }
  }
}

void LtsMultiMonitor::unfreezeMagicCorner(int screenId)
{

  for (auto *screen : qAsConst(m_screens))
  {

    if (screen->screenId() == screenId)
    {
      LtsScreenNormal* normalScreen = qobject_cast<LtsScreenNormal*>(screen);
      if(normalScreen->child()->hasMainWidget() && normalScreen->child()->hasSecondaryWidget())
        normalScreen->hideMagicCorner(false);
    }
  }
}


bool LtsMultiMonitor::overlapBaseLayouts(QWidget *widget)
{
  if (!isOverlapBaseLayouts())
    return false;

  /* only overlap base layouts if the main screen is the only screen - if
   * another screen is connected to the tablet, the new screen should be
   * selectable, too */

  Q_ASSERT(qobject_cast<FullscreenVideoDummyWidget *>(widget) == nullptr);
  if (qobject_cast<FullscreenVideoDummyWidget *>(widget) != nullptr)
  {
    //  qWarning() << "tried to put a dummy widget on a tablet device... - ignore";
    return false;
  }


//  FullscreenVideoDummyWidget *dummy = qobject_cast<FullscreenVideoDummyWidget *>(widget);
//  if (dummy != nullptr)
//  {
//    widget->setParent(m_dummy);
//    emit dummy->signalWidgetPlaced(QRect());
//  }
//  else
//  {
//    widget->show(); // as discrete window
//    place(widget);
//  }


#ifdef Q_OS_WIN
  widget->winId();  // make sure windowHandle() is not a nullptr
  QWindowsWindowFunctions::setHasBorderInFullScreen(widget->windowHandle(), true);
#endif

  widget->activateWindow();
  widget->showFullScreen();

  place(widget);

  return true;
}


bool LtsMultiMonitor::selectAndSwap(QWidget *widget)
{
  if (!m_active)
    return false; // no swap if mmm not active

  Q_ASSERT(!isOverlapBaseLayouts()); // swap button not allowed on tablet
  if (isOverlapBaseLayouts())
    return false; // don't allow swap if overlay mode is active (as that would make no sense)


  // look for the screen which contains the widget
  LtsScreenContainer *oldContainer = nullptr; // TODO C++17: std::optional
  for (LtsScreenBase *_screen : qAsConst(m_screens))
  {
    try
    {
      oldContainer = _screen->containerOfWidget(widget);
    }
    catch (...){}
  }

  if (oldContainer == nullptr)
  {
    //   qWarning() << "!!! mep" << __FILE__ << __LINE__;
    LtsWidgets::LtsMessageDialog::showMessage(widget, tr("Could not determine screen id for this swap!<br>Swapping not possible, please try again later."));
    return false;
  }

  // qWarning() << "oldContainer" << (quintptr)oldContainer;


  return selectScreen(widget, oldContainer); // NOTE: the screen later TAKES the widget from the clicked container and puts it into the OLD container given
}


LtsScreenBase *LtsMultiMonitor::widgetsScreen(QWidget *widget)
{
  for (LtsScreenBase *screen : qAsConst(m_screens))
    if (screen->hasWidget(widget))
      return screen;
  return nullptr;
}


bool LtsMultiMonitor::isWidgetSecondary(QWidget *widget)
{
#ifndef GUEZ_MODE
  return false;
#endif

  auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
  auto *secondaryWidget = qobject_cast<SecondaryWidget *>(widget); // full screen video & script editor's screen widget

  bool isSecondaryWidget = ((blw != nullptr && blw->isSecondaryWidget()) || secondaryWidget != nullptr);

  // if (isSec)

  return isSecondaryWidget;
}


class StupidDeleter
{
public:
  explicit StupidDeleter(LtsScreenBase *screen)
      : m_screen(screen)
  {}

  ~StupidDeleter()
  {
    //qWarning() << "####### Deleter";
    if (m_screen != nullptr)
    {
      //qWarning() << "####### REVERTED";
      m_screen->revertSwitch();
    }
    //else qWarning() << "####### NOT REVERTED !!!!";
  }

  void reset()
  {
    //qWarning() << "####### RESET";
    m_screen = nullptr;
  }


private:
  LtsScreenBase *m_screen;
};


bool LtsMultiMonitor::selectScreen(QWidget *widget, LtsScreenContainer *swap, bool putOnMainIfFree, bool ltsScreenNormalOnly, const QVector<QWidget *> &irreplacableWidgets)
{
  Q_ASSERT(widget != nullptr);
  if (widget == nullptr)
    return false; // fail-safe

  if (cancelAndProcessIfInactive(widget))
    return true;

  init();

  if (overlapBaseLayouts(widget)) // NOTE: call 'init' before 'overlapBaseLayouts'
    return true;

  bool isSecondary = isWidgetSecondary(widget);
  //qWarning() << "selectScreen: isSecondary" << isSecondary;

  if (!isSecondary) // the allEmpty stuff is only for main widgets!!
  {
    bool allEmpty = putOnMainIfFree; // initial value
    for (LtsScreenBase *screen : qAsConst(m_screens))
    {
      screen->switchToTemp(LtsScreenBase::WidgetType::MainWidget);
      bool isEmpty = screen->isEmpty();
      screen->revertSwitch();

      if (isEmpty)
        continue;

      allEmpty = false;
      break;
    }

    //qWarning() << "allEmpty" << allEmpty;

    if (allEmpty)
    {
      /* if ALL screens in the entire mmm are empty, then just put the widget on
       * the main screen */

      m_mainScreen->switchToTemp(LtsScreenBase::WidgetType::MainWidget);

      try
      {
        m_mainScreen->putWidget(widget);        
      }
      catch (...)
      {
        qWarning() << "failed - reverting";
        m_mainScreen->revertSwitch();

        Q_ASSERT_X(false, __FUNCTION__, "screen promised to be empty but 'putWidgetSomewhere' method failed regardless");
        //     qWarning() << "woopsie";

        auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
        if (blw != nullptr)
          emit blw->signalClose();
        else
          widget->deleteLater();

        return false; // fail-safe
      }

      m_mainScreen->check();
      place(widget);
      m_mainScreen->finalizeSwitch();
      return true;
    }
  }


  auto *selectionProcessWatcher = new QObject;

  // finally show selectors
  bool minOnce = false;

  for (auto i = m_screens.begin(); i != m_screens.end(); ++i)
  {
    LtsScreenBase *screen = *i;

    screen->switchToTemp(isSecondary ? LtsScreenBase::WidgetType::SecondaryWidget : LtsScreenBase::WidgetType::MainWidget);

    StupidDeleter _(screen);

    if (screen->isIrreplaceable()) // do not create mms for a screen that is fully irreplaceable
    {
      // qWarning() << "screen marked as irreplacable, skipping"<<screen;
      continue;
    }

    bool skip = false;
    for (QWidget *widget : qAsConst(irreplacableWidgets))
    {
      //  qWarning() << "does screen have" << widget<<screen;
      if (screen->hasWidget(widget))
      {
        //   qWarning() << "yes, skipping!";
        skip = true;
        continue;
      }

      //  qWarning() << "no, selection available";
    }

    if (skip)
      continue;

    MultiMonitorSelectorBase *mms;
    if (qobject_cast<LtsScreenNormal *>(screen) != nullptr)
    {
      auto *screenNormal = static_cast<LtsScreenNormal *>(screen);
      mms = new MultiMonitorSelectorNormal(screenNormal, isSecondary, irreplacableWidgets);
    }
    else if (qobject_cast<LtsScreenWide *>(screen) != nullptr && !ltsScreenNormalOnly)
    {
      auto *screenWide = static_cast<LtsScreenWide *>(screen);
      mms = new MultiMonitorSelectorWide(screenWide, nullptr, irreplacableWidgets);
    }
    else
      continue;


    QPointer<QWidget> widgetPtr(widget);


    connect(widget, &QWidget::destroyed,
            mms, &MultiMonitorSelectorBase::close);
    connect(mms, &MultiMonitorSelectorBase::rejected,//signalAbort,
            this, [widgetPtr, swap]()
            {
              // qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);

              if (!widgetPtr || swap != nullptr) // don't delete widget if it was a swap, just let it live where it currently is living
                return;

              //  qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);

              //qWarning() << "###### REJECTED!!!!";

              auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widgetPtr.data());
              if (blw != nullptr)
                emit blw->signalClose();
              else
                widgetPtr->deleteLater();
            });
    connect(mms, &MultiMonitorSelectorBase::signalSelected,
            this, [this, mms, widgetPtr]()
            {
              //  qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);

              for (LtsScreenBase *screen : qAsConst(m_screens))
                screen->check();

              //   qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);

              if (widgetPtr)
                place(widgetPtr.data());

              // qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);

              mms->deleteLater();
              emit signalSelected();

              //qWarning() << "mep" << QStringLiteral("%1:%2").arg(QString::fromUtf8(__FILE__).split(QStringLiteral("/")).last()).arg(__LINE__);
            });
    connect(mms, &MultiMonitorSelectorBase::destroyed,
            selectionProcessWatcher, &QObject::deleteLater);
    connect(selectionProcessWatcher, &QObject::destroyed,
            mms, &MultiMonitorSelectorBase::close);

    mms->setSwap(swap);
    mms->setWidget(widget);
    mms->show();
    _.reset();
    minOnce = true;
  }

  if (!minOnce)
  {
    selectionProcessWatcher->deleteLater();
    auto *blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget *>(widget);
    if (blw != nullptr)
      emit blw->signalClose();
    else
      widget->deleteLater();

    LtsWidgets::LtsMessageDialog::showMessage(m_mainScreen->screenDialog(), tr("There are no free screens available to select from."));
    return false;
  }

  return true;
}


} // namespace LtsMultiMonitor