/*
    This file is part of the KDE games lskat program
    SPDX-FileCopyrightText: 2006 Martin Heni <kde@heni-online.de>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "mainwindow.h"

// Include files for Qt
#include <QAction>
#include <QDir>
#include <QKeySequence>
#include <QPointer>
#include <QRandomGenerator>
#include <QStatusBar>
#include <QStandardPaths>

// KF includes
#include <KActionCollection>
#include <KConfigGroup>
#include <KMessageBox>
#include <KSharedConfig>
#include <KGameStandardAction>
#include <KLocalizedString>
#include <KSelectAction>
// Application specific includes
#include "lskat_debug.h"
#include "lskatglobal.h"
#include "gameview.h"
#include "abstractengine.h"
#include "engine_two.h"
#include "display_two.h"
#include "config_two.h"
#include "display_intro.h"
#include "deck.h"
#include "player.h"
#include "mouseinput.h"
#include "aiinput.h"
#include "namedialogwidget.h"
#include "fromlibkdegames/kcarddialog.h"
#include "fromlibkdegames/carddeckinfo.h"

// Configuration file
#include <config-src.h>

// Forward declarations
const int ADVANCE_PERIOD =  20;

// Shortcut to access the actions
#define ACTION(x)   (actionCollection()->action(x))

using namespace InputDevice;

// Construct the main application window
Mainwindow::Mainwindow(QWidget *parent)
          : KXmlGuiWindow(parent)
{
    // Reset stuff
    mDeck        = nullptr;
    mEngine      = nullptr;
    mDisplay     = nullptr;
    mView        = nullptr;
    mLSkatConfig = nullptr;
    mCanvas      = nullptr;
    mTheme       = nullptr;

    // Read theme files
    QStringList themeList;
    const QStringList dirs = QStandardPaths::locateAll(QStandardPaths::AppDataLocation, QStringLiteral("themes"), QStandardPaths::LocateDirectory);
    for (const QString& dir : dirs) {
        const QStringList fileNames = QDir(dir).entryList({QStringLiteral("*.desktop")});
        themeList.reserve(themeList.size() + fileNames.size());
        for (const QString& file : fileNames) {
            themeList.append(dir + QLatin1Char('/') + file);
        }
    }
    if (themeList.isEmpty())
    {
        KMessageBox::error(this, i18n("Installation error: No theme list found."));
        QTimer::singleShot(0, this, &QWidget::close);
        return;
    }

    // Read theme files
    for (const QString &themePath : std::as_const(themeList)) {
        KConfig themeInfo(themePath, KConfig::SimpleConfig);
        KConfigGroup themeGroup(&themeInfo, QStringLiteral("Theme"));
        QString name = themeGroup.readEntry("Name", QString());
        QString file = themeGroup.readEntry("File", QString());
        bool isDefault = themeGroup.readEntry("Default", false);
        mThemeFiles[name] = file;
        if (mThemeDefault.isEmpty()) mThemeDefault = name;
        if (isDefault) mThemeDefault = name;

        if (global_debug > 0) qCDebug(LSKAT_LOG) << "Found theme: " << themePath << " Name(i18n)=" << name << " File=" << file << " default=" << isDefault;
    }
    mThemeIndexNo = themeIdxFromName(mThemeDefault);

    // Create menus etc
    initGUI();

    // The LSkat config
    mLSkatConfig = new ConfigTwo(this);
    connect(mLSkatConfig, &ConfigTwo::signalInputType, this, &Mainwindow::setInputType);
    mLSkatConfig->reset();

    // Read game properties and set default values (after config)
    readProperties();

    // TODO: Bugfix: Needs to be here if initGUI is before readProperties
    if (global_debug > 0) qCDebug(LSKAT_LOG) << "Setting current theme item to " << mThemeIndexNo;
    ((KSelectAction *)ACTION(QStringLiteral("theme")))->setCurrentItem(mThemeIndexNo);

    // Get the card deck
    const quint32 seed = QRandomGenerator::global()->generate();
    if (global_debug > 0) qCDebug(LSKAT_LOG) << "Random seed" << seed;
    mDeck = new Deck(seed, this);

    // Theme manager
    QString themeFile = themefileFromIdx(mThemeIndexNo);
    if (global_debug > 0) qCDebug(LSKAT_LOG) << "Load theme" << themeFile << " no=" << mThemeIndexNo;
    mTheme  = new ThemeManager(mCardTheme, themeFile, this, this->width());
    if (mTheme->checkTheme() != 0)
    {
        KMessageBox::error(this, i18n("Installation error: Theme file error."));
        QTimer::singleShot(0, this, &QWidget::close);
        return;
    }

    // Overall view
    mCanvas        = new QGraphicsScene(this);
    mView          = new GameView(QSize(880, 675), ADVANCE_PERIOD, mCanvas, mTheme, this);

    // Create intro
    mGameMode      = Intro;
    mDisplay       = new DisplayIntro(mDeck, mCanvas, mTheme, ADVANCE_PERIOD, mView);
    setCentralWidget(mView);
    connect(mView, &GameView::signalLeftMousePress, this, &Mainwindow::menuNewLSkatGame);

    // Create GUI
    setupGUI();

    statusBar()->showMessage(i18n("Welcome to Skat! Please start a new game."));

    // Skip intro?
    if (global_skip_intro)
    {
        menuNewLSkatGame();
    }
    // Start game automatically in demo mode
    else if (global_demo_mode)
    {
        // Start intro
        mDisplay->start();
        QTimer::singleShot(12500, this, &Mainwindow::menuNewLSkatGame);
    }
    else
    {
        // Start intro
        mDisplay->start();
    }
    if (global_debug > 0) qCDebug(LSKAT_LOG) << "Mainwindow setup constructor done";
}

// Destructor
Mainwindow::~Mainwindow()
{
    saveProperties();
    delete mEngine;
    delete mDisplay;
    delete mLSkatConfig;
    delete mDeck;
    delete mView;
    delete mCanvas;
    delete mTheme;
}

// Called by KMainWindow when the last window of the application is
void Mainwindow::closeEvent(QCloseEvent *event)
{
    if (mEngine)
    {
        mEngine->stopGame();
    }
    saveProperties();
    KXmlGuiWindow::closeEvent(event);
}

// Retrieve a theme file name from the menu index number
QString Mainwindow::themefileFromIdx(int idx)
{
    QStringList list(mThemeFiles.keys());
    list.sort();
    QString themeFile = mThemeFiles[list.at(idx)];
    return themeFile;
}

// Retrieve a theme idx from a theme name
int Mainwindow::themeIdxFromName(const QString &name)
{
    QStringList list(mThemeFiles.keys());
    list.sort();
    for (int i = 0; i < list.size(); ++i)
    {
        if (list[i] == name) return i;
    }
    qCCritical(LSKAT_LOG) << "Theme index lookup failed for " << name;
    return 0;
}

// Save properties
void Mainwindow::saveProperties()
{
    KConfig *config = KSharedConfig::openConfig().data();

    // Program data
    KConfigGroup cfg = config->group(QStringLiteral("ProgramData"));
    cfg.writeEntry("startplayer", mStartPlayer);
    cfg.writeEntry("ThemeIndexNo", mThemeIndexNo);

    // LSkat data
    mLSkatConfig->save(config);
    config->sync();
}

// Load properties
void Mainwindow::readProperties()
{
    KConfig *config = KSharedConfig::openConfig().data();

    // Program data
    KConfigGroup cfg = config->group(QStringLiteral("ProgramData"));

    // Theme number
    mThemeIndexNo = cfg.readEntry("ThemeIndexNo", themeIdxFromName(mThemeDefault));
    if (mThemeIndexNo >= mThemeFiles.size()) mThemeIndexNo = 0;

    // Read card path
    mCardTheme  = CardDeckInfo::deckName(cfg);

    int no = cfg.readEntry("startplayer", 0);
    setStartPlayer(no);
    mLSkatConfig->load(config);
}

// Create a input with the given type
AbstractInput *Mainwindow::createInput(
                                 InputDeviceType inputType,
                                 AbstractDisplay *display,
                                 AbstractEngine *engine)
{
    AbstractInput *input = nullptr;

    // Always use AI input in demo mode
    if (global_demo_mode)
    {
        inputType = TypeAiInput;
    }

    // Create the player input
    if (inputType == TypeMouseInput)
    {
        MouseInput *mouseInput = new MouseInput(this);
        connect(mView, &GameView::signalLeftMousePress,
                mouseInput, &MouseInput::mousePress);
        connect(mouseInput, &MouseInput::signalConvertMousePress,
                display, &AbstractDisplay::convertMousePress);
        connect(mouseInput, &MouseInput::signalPlayerInput,
                engine, &AbstractEngine::playerInput);
        input = mouseInput;
        if (global_debug > 0) qCDebug(LSKAT_LOG) << "Create MOUSE INPUT";
    }
    else if (inputType == TypeAiInput)
    {
        AiInput *aiInput = new AiInput((EngineTwo *)engine, this);
        connect(aiInput, &AiInput::signalPlayerInput,
                engine, &AbstractEngine::playerInput);
        input = aiInput;
        if (global_debug > 0) qCDebug(LSKAT_LOG) << "Create AI INPUT";
    }
    else
    {
        qCCritical(LSKAT_LOG) << "Unsupported input device type" << inputType;
    }

    return input;
}

// Start a new game
void Mainwindow::startGame()
{
    // Enable game action
    const QString endName(KGameStandardAction::name(KGameStandardAction::End));
    ACTION(endName)->setEnabled(true);

    // Deal cards to player - Shuffle card deck and reset pile
    mDeck->shuffle();

    // Draw Trump
    Suite trump = mDeck->randomTrump();

    // Loop all players in the game
    QHashIterator<int,Player *> it = mLSkatConfig->playerIterator();
    while (it.hasNext())
    {
        it.next();
        Player *player = it.value();
        player->setDeck(mDeck);
        // Deal cards
        player->deal(16);
        // Store trump
        player->setTrump(trump);
    }

    // Start display
    mDisplay->start();

    // Start the game engine
    mEngine->startGame(trump, mStartPlayer);

    // Start player for next game
    setStartPlayer(1-mStartPlayer);

    //  statusBar()->clearMessage();
}

// Here a game over is signalled
void Mainwindow::gameOver(int /*winner*/)
{
    const QString endName(KGameStandardAction::name(KGameStandardAction::End));
    ACTION(endName)->setEnabled(false);
    statusBar()->showMessage(i18n("Game Over. Please start a new game."));

    // Automatically restart game in demo mode
    if (global_demo_mode)
    {
        QTimer::singleShot(10000, this, &Mainwindow::menuNewLSkatGame);
    }
}

// Show next player
void Mainwindow::nextPlayer(Player *player)
{
    int no       = player->id() + 1;
    QString name = player->name();
    statusBar()->showMessage(i18nc("Player name and number", "Next move for %1 (player %2)", name, no));
}

// Setup the GUI
void Mainwindow::initGUI()
{
    QAction *action;

    // Start a new game
    action = KGameStandardAction::gameNew(this, &Mainwindow::menuNewLSkatGame, actionCollection());
    if (global_demo_mode) action->setEnabled(false);

    // Clear all time statistics
    action = KGameStandardAction::clearStatistics(this, &Mainwindow::menuClearStatistics, actionCollection());
    action->setWhatsThis(i18n("Clears the all time statistics which is kept in all sessions."));
    if (global_demo_mode) action->setEnabled(false);

    // End a game
    action = KGameStandardAction::end(this, &Mainwindow::menuEndGame, actionCollection());
    action->setWhatsThis(i18n("Ends a currently played game. No winner will be declared."));
    action->setEnabled(false);

    // Quit the program
    action = KGameStandardAction::quit(this, &QWidget::close, actionCollection());
    action->setWhatsThis(i18n("Quits the program."));

    // Determine start player
    KSelectAction *startPlayerAct = new KSelectAction(i18nc("@title:menu", "Starting Player"), this);
    actionCollection()->addAction(QStringLiteral("startplayer"), startPlayerAct);
    connect(startPlayerAct, &KSelectAction::indexTriggered, this, &Mainwindow::menuStartplayer);
    startPlayerAct->setToolTip(i18nc("@info:tooltip", "Change starting player"));
    startPlayerAct->setWhatsThis(i18n("Chooses which player begins the next game."));
    startPlayerAct->setItems({
        i18nc("@item:inmenu", "Player &1"),
        i18nc("@item:inmenu", "Player &2"),
    });
    if (global_demo_mode) startPlayerAct->setEnabled(false);

    // Determine who plays player 1
    KSelectAction *player1Act = new KSelectAction(i18nc("@title:menu", "Player &1 Played By"), this);
    actionCollection()->addAction(QStringLiteral("player1"), player1Act);
    connect(player1Act, &KSelectAction::indexTriggered, this, &Mainwindow::menuPlayer1By);
    player1Act->setToolTip(i18nc("@info:tooltip", "Change who plays player 1"));
    player1Act->setWhatsThis(i18n("Changing who plays player 1."));
    const QStringList inputDevices {
        i18nc("@item:inmenu", "&Mouse"),
        i18nc("@item:inmenu", "&Computer"),
    };
    player1Act->setItems(inputDevices);
    if (global_demo_mode) player1Act->setEnabled(false);

    // Determine who plays player 2
    KSelectAction *player2Act = new KSelectAction(i18nc("@title:menu", "Player &2 Played By"), this);
    actionCollection()->addAction(QStringLiteral("player2"), player2Act);
    connect(player2Act, &KSelectAction::indexTriggered, this, &Mainwindow::menuPlayer2By);
    player2Act->setToolTip(i18nc("@info:tooltip", "Change who plays player 2"));
    player2Act->setWhatsThis(i18n("Changing who plays player 2."));
    player2Act->setItems(inputDevices);
    if (global_demo_mode) player2Act->setEnabled(false);

    // Add all theme files to the menu
    QStringList themes(mThemeFiles.keys());
    themes.sort();

    KSelectAction *themeAct = new KSelectAction(i18nc("@title:menu", "&Theme"), this);
    actionCollection()->addAction(QStringLiteral("theme"), themeAct);
    themeAct->setItems(themes);
    connect(themeAct, &KSelectAction::indexTriggered, this, &Mainwindow::changeTheme);
    if (global_debug > 0) qCDebug(LSKAT_LOG) << "Setting current theme item to " << mThemeIndexNo;
    themeAct->setCurrentItem(mThemeIndexNo);
    themeAct->setToolTip(i18nc("@info:tooltip", "Change theme"));
    themeAct->setWhatsThis(i18n("Changing theme."));

    // Choose card deck
    QAction *action1 = actionCollection()->addAction(QStringLiteral("select_carddeck"));
    action1->setText(i18nc("@action", "Select &Card Deck…"));
    connect(action1, &QAction::triggered, this, &Mainwindow::menuCardDeck);
    action1->setToolTip(i18nc("@info:tooltip", "Configure card decks"));
    action1->setWhatsThis(i18n("Choose how the cards should look."));

    // Change player names
    action = actionCollection()->addAction(QStringLiteral("change_names"));
    action->setText(i18nc("@action", "&Change Player Names…"));
    connect(action, &QAction::triggered, this, &Mainwindow::menuPlayerNames);
    if (global_demo_mode) action->setEnabled(false);
}

// Choose start player
void Mainwindow::menuStartplayer()
{
    int i = ((KSelectAction *)ACTION(QStringLiteral("startplayer")))->currentItem();
    setStartPlayer(i);
}

// Change the theme of the game
void Mainwindow::changeTheme(int idx)
{
    mThemeIndexNo = idx;
    QString themeFile = themefileFromIdx(idx);
    if (global_debug > 0) qCDebug(LSKAT_LOG) << "Select theme " << themeFile;
    mTheme->updateTheme(themeFile);
}

// Select input for player 1
void Mainwindow::menuPlayer1By()
{
    int i = ((KSelectAction *)ACTION(QStringLiteral("player1")))->currentItem();
    mLSkatConfig->setInputType(0, (InputDeviceType)i);
}

// Select input for player 2
void Mainwindow::menuPlayer2By()
{
    int i = ((KSelectAction *)ACTION(QStringLiteral("player2")))->currentItem();
    mLSkatConfig->setInputType(1, (InputDeviceType)i);
}

// Choose a card deck
void Mainwindow::menuCardDeck()
{
    QString front = mCardTheme;

    KConfigGroup grp = KSharedConfig::openConfig()->group(QStringLiteral("ProgramData"));
    KCardWidget *cardwidget = new KCardWidget();
    QPointer<KCardDialog> dlg;

    cardwidget->readSettings(grp);
    dlg = new KCardDialog(cardwidget);
    if (dlg->exec() == QDialog::Accepted)
    {
        // Always store the settings, other things than the deck may have changed
        cardwidget->saveSettings(grp);
        grp.sync();
        if (global_debug > 0) qCDebug(LSKAT_LOG) << "NEW CARDDECK: " << front;
        bool change = false; // Avoid unnecessary changes
        if (!cardwidget->deckName().isEmpty() && cardwidget->deckName() != mCardTheme)
        {
            mCardTheme    = cardwidget->deckName();
            change = true;
        }
        if (change)
        {
            mTheme->updateCardTheme(mCardTheme);
            mView->update(); // Be on the safe side and update
        }
    }
    delete dlg;
}

// Clear all time statistics
void Mainwindow::menuClearStatistics()
{
    QString message;
    message = i18n("Do you really want to clear the all time "
                    "statistical data?");

    if (KMessageBox::PrimaryAction == KMessageBox::questionTwoActions(this,
                                                       message,
                                                       QString(),
                                                       KStandardGuiItem::clear(),
                                                       KStandardGuiItem::cancel()))
    {
        QHashIterator<int,Player *> it = mLSkatConfig->playerIterator();
        while (it.hasNext())
        {
            it.next();
            Player *player = it.value();
            player->clear();
        }
    }
}

// Abort a game
void Mainwindow::menuEndGame()
{
    if (mEngine)
    {
        mEngine->stopGame();
    }
}

// Start a new game
void Mainwindow::menuNewLSkatGame()
{
    disconnect(mView, &GameView::signalLeftMousePress, this, &Mainwindow::menuNewLSkatGame);

    Player *p1 = mLSkatConfig->player(0);
    Player *p2 = mLSkatConfig->player(1);

    // Stop running games
    if (mEngine)
    {
        mEngine->stopGame();
    }

    // Get rid of old stuff?
    if (true || (mGameMode != LSkat)) // Yes! Fixes bugs 330308 and 228067.
    // Jenkins objected to the indentation if the above was simply commented out.
    {
        // Set new game mode
        mGameMode = LSkat;

        // Start deleting
        delete mDisplay;
        delete mEngine;

        auto *display = new DisplayTwo(mDeck, mCanvas, mTheme, ADVANCE_PERIOD, mView);
        mDisplay = display;
        mEngine = new EngineTwo(this, mDeck, (DisplayTwo *)mDisplay);
        connect(mEngine, &AbstractEngine::signalGameOver, this, &Mainwindow::gameOver);
        connect(mEngine, &AbstractEngine::signalNextPlayer, this, &Mainwindow::nextPlayer);

        // Connect player score widget updates
        connect(p1, &Player::signalUpdate, display, &DisplayTwo::updatePlayer);
        connect(p2, &Player::signalUpdate, display, &DisplayTwo::updatePlayer);

        mEngine->addPlayer(0, p1);
        mEngine->addPlayer(1, p2);
    }// end if

    // Create inputs and store in player
    AbstractInput *input1 = createInput(mLSkatConfig->inputType(0), mDisplay, mEngine);
    p1->setInput(input1);
    AbstractInput *input2 = createInput(mLSkatConfig->inputType(1), mDisplay, mEngine);
    p2->setInput(input2);

    statusBar()->showMessage(i18nc("@info", "Dealing cards…"));

    // Start game
    startGame();
}

// Change the player names in a dialog
void Mainwindow::menuPlayerNames()
{
    QPointer<NameDialogWidget> dlg = new NameDialogWidget(this);
    for (int i = 0; i < 2; i++)
    {
        Player *p = mLSkatConfig->player(i);
        dlg->setName(i, p->name());
    }

    if (dlg->exec() == QDialog::Accepted)
    {
        for (int i = 0; i < 2; i++)
        {
            Player *p = mLSkatConfig->player(i);
            p->setName(dlg->name(i));
        }
    }

    delete dlg;
}

// Set the start player.
void Mainwindow::setStartPlayer(int no)
{
    mStartPlayer = no;
    ((KSelectAction *)ACTION(QStringLiteral("startplayer")))->setCurrentItem(mStartPlayer);
}

// Set the input type for a given player number.
void Mainwindow::setInputType(int no, InputDeviceType type)
{
    Player *p = nullptr;
    // Player 1
    if (no == 0)
    {
        ((KSelectAction *)ACTION(QStringLiteral("player1")))->setCurrentItem((int)type);
        p = mLSkatConfig->player(0);
    }
    else if (no == 1)
    {
        ((KSelectAction *)ACTION(QStringLiteral("player2")))->setCurrentItem((int)type);
        p = mLSkatConfig->player(1);
    }

    // Exchange player input at runtime
    if (mEngine && p && mDisplay && mEngine->isGameRunning())
    {
        AbstractInput *input = createInput(type, mDisplay, mEngine);
        p->setInput(input);
    }
}

#include "moc_mainwindow.cpp"
