dota_factory/src/ui/MainWindow.cpp

#include "MainWindow.h"

#include <map>
#include <random>
#include <set>

#include <QApplication>
#include <QCloseEvent>
#include <QFile>
#include <QMessageBox>
#include <QPushButton>
#include <QResizeEvent>
#include <QVBoxLayout>

#include "BlueprintPanel.h"
#include "BuildButtonGrid.h"
#include "BuildingBlocksChangedEvent.h"
#include "BuildingSystem.h"
#include "Command.h"
#include "CommandRequestedEvent.h"
#include "ConfigLoader.h"
#include "EventManager.h"
#include "GameWorldView.h"
#include "RecipeSelectionDialog.h"
#include "SchematicChoiceDialog.h"
#include "HeaderBar.h"
#include "SelectedBuildingPanel.h"
#include "ShipLayoutBlueprintSerializer.h"
#include "ShipLayoutDialog.h"
#include "Simulation.h"
#include "Tick.h"
#include "VisualsLoader.h"

MainWindow::MainWindow(Simulation* sim, const std::string& configDir, QWidget* parent)
    : QWidget(parent)
    , m_configDir(configDir)
    , m_visuals(VisualsLoader::load(configDir + "/visuals.toml"))
    , m_sim(sim)
{
    setWindowTitle(tr("Dota Factory"));
    resize(1280, 768);

    m_headerBar = new HeaderBar(this);

    m_gameWorldView = new GameWorldView(sim, &sim->config(), &m_visuals, m_configDir, this);

    m_sidePanel = new QWidget(this);
    QVBoxLayout* sideLayout = new QVBoxLayout(m_sidePanel);
    sideLayout->setContentsMargins(0, 0, 0, 0);
    sideLayout->setSpacing(0);

    m_selectedBuildingPanel = new SelectedBuildingPanel(sim, &sim->config(), m_sidePanel);
    m_buildButtonGrid       = new BuildButtonGrid(&sim->config(), m_sidePanel);
    m_blueprintPanel        = new BlueprintPanel(sim, &sim->config(), m_sidePanel);

    sideLayout->addWidget(m_selectedBuildingPanel, 1);
    sideLayout->addWidget(m_buildButtonGrid,       1);
    sideLayout->addWidget(m_blueprintPanel,        1);

    m_gameWorldView->setFocus();

    connect(qApp, &QApplication::focusChanged, this, [this](QWidget*, QWidget* newWidget) {
        if (newWidget && newWidget != m_gameWorldView && !QApplication::activeModalWidget())
        {
            m_gameWorldView->setFocus();
        }
    });

    // Load layout blueprints from disk. Missing file is silently ignored.
    const QString bpPath = QCoreApplication::applicationDirPath() + "/ship_layouts.toml";
    QFile bpFile(bpPath);
    if (bpFile.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        try
        {
            m_layoutBlueprints = ShipLayoutBlueprintSerializer::deserialize(
                bpFile.readAll().toStdString());
        }
        catch (const std::exception& e)
        {
            QMessageBox::critical(this, tr("Load Error"),
                tr("Failed to load ship_layouts.toml:\n%1").arg(e.what()));
            m_layoutBlueprints.clear();
        }
    }

    registerForEvents();
}

MainWindow::~MainWindow()
{
    unregisterForEvents();
}

void MainWindow::resizeEvent(QResizeEvent* event)
{
    QWidget::resizeEvent(event);
    layoutPanels();
}

void MainWindow::closeEvent(QCloseEvent* event)
{
    const QString path = QCoreApplication::applicationDirPath() + "/ship_layouts.toml";
    QFile file(path);
    if (file.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        try
        {
            const std::string content =
                ShipLayoutBlueprintSerializer::serialize(m_layoutBlueprints);
            file.write(QByteArray::fromStdString(content));
        }
        catch (...) {}
    }
    QWidget::closeEvent(event);
}

void MainWindow::layoutPanels()
{
    const int totalW  = width();
    const int totalH  = height();
    const int headerH = m_headerBar->sizeHint().height();
    if (headerH <= 0) { return; }
    const int mainW = totalW * 75 / 100;
    const int sideW = totalW - mainW;

    m_headerBar->setGeometry(0, 0, mainW, headerH);
    m_gameWorldView->setGeometry(0, headerH, mainW, totalH - headerH);
    m_sidePanel->setGeometry(mainW, 0, sideW, totalH);
}

void MainWindow::handleEvent(std::shared_ptr<const BuildingBlocksChangedEvent> event)
{
    m_buildButtonGrid->updateAffordability(event->blocks);
}

void MainWindow::handleEvent(std::shared_ptr<const SchematicChoicesAvailableEvent> event)
{
    const double prevSpeed = m_gameWorldView->gameSpeed();
    m_gameWorldView->setGameSpeed(0.0);

    SchematicChoiceDialog dialog(event->choices, this);
    dialog.exec();

    std::shared_ptr<ApplySchematicChoiceCommand> command =
        std::make_shared<ApplySchematicChoiceCommand>();
    command->choiceIndex = dialog.getChosenIndex();
    EventManager::getInstance()->sendEventImmediately(
        std::make_shared<CommandRequestedEvent>(command));

    m_gameWorldView->setGameSpeed(prevSpeed);
    m_gameWorldView->resetFrameTimer();
}

void MainWindow::handleEvent(std::shared_ptr<const EscapeMenuRequestedEvent> /*event*/)
{
    const double prevSpeed = m_gameWorldView->gameSpeed();
    m_gameWorldView->setGameSpeed(0.0);

    QMessageBox box(this);
    box.setWindowTitle(tr("Paused"));
    QPushButton* continueBtn = box.addButton(tr("Continue"), QMessageBox::AcceptRole);
    QPushButton* restartBtn  = box.addButton(tr("Restart"),  QMessageBox::ResetRole);
    QPushButton* quitBtn     = box.addButton(tr("Quit"),     QMessageBox::DestructiveRole);
    box.setEscapeButton(continueBtn);
    box.exec();

    QAbstractButton* clicked = box.clickedButton();
    if (clicked == restartBtn)
    {
        std::shared_ptr<GameConfig> newConfig;
        try
        {
            newConfig = std::make_shared<GameConfig>(
                ConfigLoader::loadFromDirectory(m_configDir));
            VisualsConfig newVisuals = VisualsLoader::load(m_configDir + "/visuals.toml");
            m_visuals = std::move(newVisuals);
        }
        catch (const std::exception& e)
        {
            QMessageBox::critical(this, tr("Config Error"),
                tr("Failed to reload config:\n%1").arg(e.what()));
            m_gameWorldView->setGameSpeed(prevSpeed);
            m_gameWorldView->resetFrameTimer();
            return;
        }
        // Restart is a command boundary; the view resets when the drain applies
        // it (see GameWorldView::onFrame). A fresh random seed starts a new run.
        std::shared_ptr<ResetCommand> command = std::make_shared<ResetCommand>();
        command->config = std::move(newConfig);
        command->seed   = std::random_device{}();
        EventManager::getInstance()->sendEventImmediately(
            std::make_shared<CommandRequestedEvent>(command));
    }
    else if (clicked == quitBtn)
    {
        close();
    }
    else
    {
        m_gameWorldView->setGameSpeed(prevSpeed);
        m_gameWorldView->resetFrameTimer();
    }
}

void MainWindow::handleEvent(std::shared_ptr<const LayoutDialogRequestedEvent> event)
{
    const double prevSpeed = m_gameWorldView->gameSpeed();
    m_gameWorldView->setGameSpeed(0.0);

    // A construction site has no Building yet; fall back to its site record so
    // the shipyard layout can be configured before it is built (REQ-BLD-SITE-CONFIG).
    const Building* b = m_sim->buildings().findBuilding(event->shipyardId);
    const ConstructionSite* s =
        b ? nullptr : m_sim->buildings().findSite(event->shipyardId);
    if (!b && !s)
    {
        m_gameWorldView->setGameSpeed(prevSpeed);
        m_gameWorldView->resetFrameTimer();
        return;
    }

    const std::string& schematicId = b ? b->recipeId : s->recipeId;
    const std::optional<ShipLayoutConfig>& layoutOpt =
        b ? b->shipLayout : s->shipLayout;

    ShipLayoutConfig currentLayout;
    if (layoutOpt.has_value())
    {
        currentLayout = *layoutOpt;
    }

    std::set<std::string> unlockedModuleIds;
    std::map<std::string, int> moduleLevels;
    for (const ModuleDef& def : m_sim->config().modules.modules)
    {
        if (m_sim->isModuleSchematicUnlocked(def.id))
        {
            unlockedModuleIds.insert(def.id);
        }
        moduleLevels[def.id] = m_sim->moduleSchematicLevel(def.id);
    }

    ShipLayoutDialog dialog(&m_sim->config(), schematicId, currentLayout,
                            m_layoutBlueprints,
                            std::move(unlockedModuleIds),
                            std::move(moduleLevels),
                            m_gameWorldView->isDebugDrawEnabled(),
                            this);
    if (dialog.exec() == QDialog::Accepted && dialog.result().has_value())
    {
        std::shared_ptr<SetShipLayoutCommand> command =
            std::make_shared<SetShipLayoutCommand>();
        command->id     = event->shipyardId;
        command->layout = *dialog.result();
        EventManager::getInstance()->sendEventImmediately(
            std::make_shared<CommandRequestedEvent>(command));
    }

    m_gameWorldView->setGameSpeed(prevSpeed);
    m_gameWorldView->resetFrameTimer();
}

void MainWindow::handleEvent(std::shared_ptr<const RecipeSelectionRequestedEvent> event)
{
    const double prevSpeed = m_gameWorldView->gameSpeed();
    m_gameWorldView->setGameSpeed(0.0);

    // A construction site has no Building yet; fall back to its site record so
    // the recipe/schematic can be chosen before it is built (REQ-BLD-SITE-CONFIG).
    const Building* b = m_sim->buildings().findBuilding(event->buildingId);
    const ConstructionSite* s =
        b ? nullptr : m_sim->buildings().findSite(event->buildingId);
    if (!b && !s)
    {
        m_gameWorldView->setGameSpeed(prevSpeed);
        m_gameWorldView->resetFrameTimer();
        return;
    }

    const BuildingType type = b ? b->type : s->type;
    const std::vector<RecipeSelectionOption> options =
        buildRecipeSelectionOptions(type, *m_sim, m_sim->config());
    const QString title = (type == BuildingType::Shipyard)
        ? tr("Select Schematic")
        : tr("Select Recipe");

    RecipeSelectionDialog dialog(options, title, this);
    if (dialog.exec() == QDialog::Accepted && dialog.getChosenId().has_value())
    {
        std::shared_ptr<SetRecipeCommand> command = std::make_shared<SetRecipeCommand>();
        command->id       = event->buildingId;
        command->recipeId = *dialog.getChosenId();
        EventManager::getInstance()->sendEventImmediately(
            std::make_shared<CommandRequestedEvent>(command));
    }

    m_gameWorldView->setGameSpeed(prevSpeed);
    m_gameWorldView->resetFrameTimer();
}

void MainWindow::handleEvent(std::shared_ptr<const GameOverEvent> /*event*/)
{
    const Tick tick = m_sim->currentTick();
    const int totalSeconds = static_cast<int>(ticksToSeconds(tick));
    const int minutes = totalSeconds / 60;
    const int seconds = totalSeconds % 60;

    QMessageBox box(this);
    box.setWindowTitle(tr("Game Over"));
    box.setText(tr("HQ destroyed!\nSurvival time: %1:%2")
        .arg(minutes, 2, 10, QChar('0'))
        .arg(seconds, 2, 10, QChar('0')));
    QPushButton* restartBtn = box.addButton(tr("Restart"), QMessageBox::AcceptRole);
    box.addButton(tr("Quit"), QMessageBox::RejectRole);
    box.exec();

    if (box.clickedButton() == restartBtn)
    {
        std::shared_ptr<GameConfig> newConfig;
        try
        {
            newConfig = std::make_shared<GameConfig>(
                ConfigLoader::loadFromDirectory(m_configDir));
            VisualsConfig newVisuals = VisualsLoader::load(m_configDir + "/visuals.toml");
            m_visuals = std::move(newVisuals);
        }
        catch (const std::exception& e)
        {
            QMessageBox::critical(this, tr("Config Error"),
                tr("Failed to reload config:\n%1").arg(e.what()));
            return;
        }
        // Restart is a command boundary; the view resets when the drain applies it.
        std::shared_ptr<ResetCommand> command = std::make_shared<ResetCommand>();
        command->config = std::move(newConfig);
        command->seed   = std::random_device{}();
        EventManager::getInstance()->sendEventImmediately(
            std::make_shared<CommandRequestedEvent>(command));
    }
    else
    {
        close();
    }
}