#pragma once

#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>

#include <QApplication>
#include <QCloseEvent>
#include <QDialog>
#include <QDialogButtonBox>
#include <QFileDialog>
#include <QIcon>
#include <QMainWindow>
#include <QMdiSubWindow>
#include <QMessageBox>

#include "../ui/ui_about.h"
#include "../ui/ui_license.h"
#include "../ui/ui_mapprops.h"
#include "../ui/ui_mapview.h"
#include "../ui/ui_menu.h"
#include "../ui/ui_project.h"

#include "bindings.h"

#ifdef TYCHO_DEBUG_ASSERTIONS
#define dbgPrint(...) qDebug(__VA_ARGS__)
#else
#define dbgPrint(...)
#endif

#define dbgPrintFunc() dbgPrint("%s", __func__)

// TODO: namespace Tycho {

class MapModel;
class MapProps;
class MapView;
class Menu;
class Project;
class ProjectModel;

class MapProps : public QDialog, private Ui::MapProps
{
   Q_OBJECT

public:
   explicit MapProps(MapModel *mapModel, QWidget *parent = nullptr);
   ~MapProps();

private:
   MapModel *mapModel;
};

class MapView : public QWidget, private Ui::MapView
{
   Q_OBJECT

public:
   explicit MapView(MapModel *mapModel, QWidget *parent = nullptr);
   ~MapView();
};

class Project : public QMdiSubWindow, private Ui::Project
{
   Q_OBJECT

public:
   explicit Project(ProjectModel *model, QWidget *parent = nullptr);
   ~Project();

   QSharedPointer<ProjectModel> model;

protected:
   void closeEvent(QCloseEvent *event) override;
};

class ProjectModel
{
public:
   enum Type
   {
      Invalid,
      Map,
   };

   virtual ~ProjectModel() {}

   virtual Type type() const = 0;

   virtual QAbstractItemModel const *getAbstract() const = 0;
   virtual QAbstractItemModel       *getAbstract()       = 0;
   virtual MapModel const *getMap() const = 0;
   virtual MapModel       *getMap()       = 0;

   virtual bool isDirty() const = 0;
   virtual bool open(QString const &path) = 0;
   virtual bool save() const = 0;
   virtual bool saveAs(QString const &path) const = 0;
};

class MapModel final : private AbstractMapModel, public ProjectModel
{
   Q_OBJECT

public:
   explicit MapModel(QObject *parent = nullptr);
   ~MapModel() override;

   ProjectModel::Type type() const override;

   QAbstractItemModel const *getAbstract() const override;
   QAbstractItemModel       *getAbstract()       override;
   MapModel const *getMap() const override;
   MapModel       *getMap()       override;

   bool isDirty() const override;
   bool open(QString const &path) override;
   bool save() const override;
   bool saveAs(QString const &path) const override;

private:
   QVariant data(const QModelIndex &index, int role = Qt::DisplayRole)
      const override;
};

class Menu : public QMainWindow, private Ui::Menu
{
   Q_OBJECT

public:
   explicit Menu(QWidget *parent = nullptr);
   ~Menu();

public slots:
   void mapNew();
   void mapOpen();
   void openAbout();
   void openAboutQt();
   void openMapProperties();
   void updateActions();

protected:
   void closeEvent(QCloseEvent *event) override;
   void openLicense(QWidget *parent);

private:
   Project *activeProject() const;
   QMdiSubWindow *activeSubWindow() const;
   void addProject(Project *proj);
};

constexpr std::uint32_t fourCC(std::uint8_t a,
                               std::uint8_t b,
                               std::uint8_t c,
                               std::uint8_t d)
{
   return (a << 24) | (b << 16) | (c << 8) | d;
}

extern "C" {
   char const *tychoAuthors();
   char const *tychoHomepage();
   char const *tychoLicenseText();
   char const *tychoRepository();
   char const *tychoVersion();
}

// }

// EOF