tournament.h

/*
    This file is part of Cute Chess.

    Cute Chess is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Cute Chess is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cute Chess.  If not, see <http://www.gnu.org/licenses/>.
*/


#ifndef TOURNAMENT_H
#define TOURNAMENT_H

#include <QObject>
#include <QList>
#include <QVector>
#include <QMap>
#include <QFile>
#include <QTextStream>
#include "board/move.h"
#include "timecontrol.h"
#include "pgngame.h"
#include "gameadjudicator.h"
#include "tournamentplayer.h"
#include "tournamentpair.h"
class GameManager;
class PlayerBuilder;
class ChessGame;
class OpeningBook;
class OpeningSuite;
class Sprt;

class LIB_EXPORT Tournament : public QObject
{
    Q_OBJECT

    public:
        enum OpeningPolicy
        {
            DefaultPolicy,     
            EncounterPolicy,   
            RoundPolicy        
        };

        enum AuxResultType
        {
            RegularLoss = Chess::Result::ResultError + 1,
            RegularWin,
            OtherWin,
            Stalemate,
            InsufficientMaterial,
            MoveRepetiton,
            MovesRule,
            CountingRules,
            OtherDraw,
            InvalidResultClaim
        };
        constexpr static auto c_defaultFormat 
            = "Rank,Name,Elo,Error,Games,Score,DScore";

        Tournament(GameManager* gameManager, QObject *parent);
        virtual ~Tournament();

        virtual QString type() const = 0;
        GameManager* gameManager() const;
        bool isFinished() const;
        QString errorString() const;
        QString name() const;
        QString site() const;
        QString variant() const;
        int currentRound() const;
        int gamesPerEncounter() const;
        int roundMultiplier() const;
        int finishedGameCount() const;
        int finalGameCount() const;
        const TournamentPlayer& playerAt(int index) const;
        int playerCount() const;
        int seedCount() const;
        Sprt* sprt() const;

        void setName(const QString& name);
        void setSite(const QString& site);
        void setVariant(const QString& variant);
        void setGamesPerEncounter(int count);
        virtual bool canSetRoundMultiplier() const;
        void setRoundMultiplier(int factor);
        void setStartDelay(int delay);
        void setRecoveryMode(bool recover);
        void setAdjudicator(const GameAdjudicator& adjudicator);
        void setOpeningSuite(OpeningSuite* suite);
        void setOpeningDepth(int plies);
        void setPgnOutput(const QString& fileName,
                  PgnGame::PgnMode mode = PgnGame::Verbose);

        void setPgnWriteUnfinishedGames(bool enabled);

        void setPgnCleanupEnabled(bool enabled);

        void setEpdOutput(const QString& fileName);

        void setOpeningRepetitions(int count);
        void setOpeningPolicy(OpeningPolicy policy = DefaultPolicy);
        void setReverseSides(bool enabled);
        void setOpeningBookOwnership(bool enabled);
        void setSeedCount(int seedCount);
        void setSwapSides(bool enabled);
        void setResultFormat(const QString &format);
        QString resultFormat() const;
        const QMap<QString, QString>& namedResultFormats() const;
        const QList<QString> resultFieldTokens() const;
        const QMap<QString, QString>& resultFieldGroups() const;
        void addPlayer(PlayerBuilder* builder,
                   const TimeControl& timeControl,
                   const OpeningBook* book = nullptr,
                   int bookDepth = 256);
        virtual QString results() const;
        virtual QString outcomes() const;
        bool isStopping() const;

    public slots:
        void start();
        void stop();

    signals:
        void gameStarted(ChessGame* game,
                 int number,
                 int whiteIndex,
                 int blackIndex);
        void gameFinished(ChessGame* game,
                  int number,
                  int whiteIndex,
                  int blackIndex);
        void gameTerminated(int index,
                    Chess::Result result);
        void finished();

    protected:
        void setCurrentRound(int round);
        int gamesInProgress() const;
        TournamentPair* currentPair() const;
        TournamentPair* pair(int player1, int player2);
        void startGame(TournamentPair* pair);
        virtual void onGameAboutToStart(ChessGame* game,
                        const PlayerBuilder* white,
                        const PlayerBuilder* black);
        int playerIndex(ChessGame* game, Chess::Side side) const;
        virtual void initializePairing() = 0;
        virtual int gamesPerCycle() const = 0;
        virtual TournamentPair* nextPair(int gameNumber) = 0;
        virtual void onFinished();
        virtual void addScore(int player, Chess::Side side, int score);
        virtual void addOutcome(int iWhite,
                    int iBlack,
                    Chess::Result result);
        virtual bool areAllGamesFinished() const;
        virtual bool hasGauntletRatingsOrder() const;

    private slots:
        void startNextGame();
        bool writePgn(PgnGame* pgn, int gameNumber);
        bool writeEpd(ChessGame* game);
        void onGameStarted(ChessGame* game);
        void onGameFinished(ChessGame* game);
        void onGameDestroyed(ChessGame* game);
        void onGameStartFailed(ChessGame* game);

    private:
        enum OutputField
        {
            Rank,
            Name,
            Games,
            Wins,
            Losses,
            Draws,
            WhiteWins,
            WhiteLosses,
            WhiteDraws,
            BlackWins,
            BlackLosses,
            BlackDraws,
            Points,
            Score,
            DrawScore,
            EloDiff,
            ErrorMargin,
            LOS,
            WhiteScore,
            WhiteDrawScore,
            WhiteEloDiff,
            WhiteErrorMargin,
            WhiteLOS,
            BlackScore,
            BlackDrawScore,
            BlackEloDiff,
            BlackErrorMargin,
            BlackLOS,
            TimeForfeits,
            IllegalMoves,
            Disconnections,
            StalledConnections,
            InvalidResultClaims,
            RegularLosses,
            RegularWins,
            OtherWins,
            DrawsByStalemate,
            DrawsByMaterial,
            DrawsByRepetiton,
            DrawsByMovesRule,
            DrawsByCountingRules,
            DrawsByAdjudication,
            DrawsByAgreement,
            OtherDraws,
            TimeControlString
        };

        const QMap<QString, int> m_tokenMap = {
            {"Rank",    Rank},
            {"Name",    Name},
            {"Games",   Games},
            {"W",       Wins},
            {"L",       Losses},
            {"D",       Draws},
            {"wW",      WhiteWins},
            {"wL",      WhiteLosses},
            {"wD",      WhiteDraws},
            {"bW",      BlackWins},
            {"bL",      BlackLosses},
            {"bD",      BlackDraws},
            {"Points",  Points},
            {"Score",   Score},
            {"DScore",  DrawScore},
            {"Elo",     EloDiff},
            {"Error",   ErrorMargin},
            {"LOS",     LOS},
            {"wScore",  WhiteScore},
            {"wDScore", WhiteDrawScore},
            {"wElo",    WhiteEloDiff},
            {"wError",  WhiteErrorMargin},
            {"wLOS",    WhiteLOS},
            {"bScore",  BlackScore},
            {"bDScore", BlackDrawScore},
            {"bElo",    BlackEloDiff},
            {"bError",  BlackErrorMargin},
            {"Time",    TimeForfeits},
            {"Illegal", IllegalMoves},
            {"Discon",  Disconnections},
            {"Stall",   StalledConnections},
            {"WrClaim", InvalidResultClaims},
            {"RegulL",  RegularLosses},
            {"RegulW",  RegularWins},
            {"OtherW",  OtherWins},
            {"DStale",  DrawsByStalemate},
            {"DMater",  DrawsByMaterial},
            {"DRepet",  DrawsByRepetiton},
            {"DMoves",  DrawsByMovesRule},
            {"DCount",  DrawsByCountingRules},
            {"DAdj",    DrawsByAdjudication},
            {"DAgree",  DrawsByAgreement},
            {"OtherD",  OtherDraws},
            {"TC",      TimeControlString}
        };

        const QMap<QString, QString> m_namedGroups =
        {
            {"WLDStats",    "W,L,D,Points,Score,wW,wL,wD,wPoints,wScore,"
                    "bW,bL,bD,bPoints,bScore"},
            {"DrawStats",   "DScore,DStale,DMater,DRepet,DMoves,DAdj,DAgree,OtherD"},
            {"Terminations","Time,Illegal,Discon,Stall,WrClaim"}
        };

        const QMap<QString, QString> m_namedFormats =
        {
            {"minimal", "Rank,Name"},
            {"small",   "Rank,Name,Games,Points"},
            {"short",   "Rank,Name,Elo,Games"},
            {"concise", "Rank,Name,Elo,Error,Games"},
            {"default", QString(c_defaultFormat)},
            {"with-points", "Rank,Name,Elo,Error,Games,Points,Score,DScore"},
            {"wide",    "Rank,Name,Elo,Error,Games,W,L,D,Points,Score,DScore"},
            {"wide2",   "Rank,Name,Elo,Error,Games,W,L,D,Points,"
                    "Score,DScore,wScore,bScore"},
            {"per-color",   "Rank,Name,Elo,Error,Games,W,L,D,Points,"
                    "wW,wL,wD,wPoints,bW,bL,bD,bPoints"},
            {"ordo",    "Rank,Name,Elo,Points,Games,Score"},
            {"term",    "Rank,Name,Elo,Error,Games,Score,"
                    "Time,Illegal,Discon,Stall,WrClaim"},
            {"draws",   "Rank,Name,Elo,Error,Games,W,L,D,Points,Score,DScore,"
                    "DStale,DMater,DRepet,DMoves,DAdj,DAgree,OtherD"},
            {"wide3",   "Rank,Name,TC,Elo,Error,Games,WLDStats,"
                    "DrawStats,Terminations"}
        };

        struct GameData
        {
            int number;
            int whiteIndex;
            int blackIndex;
        };
        struct RankingData
        {
            QString name;
            int games;
            int wins;
            int losses;
            int draws;
            int whiteWins;
            int whiteLosses;
            int whiteDraws;
            int blackWins;
            int blackLosses;
            int blackDraws;
            qreal points;
            qreal score;
            qreal drawScore;
            qreal eloDiff;
            qreal errorMargin;
            qreal LOS;
            qreal whiteScore;
            qreal whiteDrawScore;
            qreal whiteEloDiff;
            qreal whiteErrorMargin;
            qreal whiteLOS;
            qreal blackScore;
            qreal blackDrawScore;
            qreal blackEloDiff;
            qreal blackErrorMargin;
            qreal blackLOS;
            int timeForfeits;
            int illegalMoves;
            int disconnections;
            int stalledConnections;
            int invalidResultClaims;
            int regularLosses;
            int regularWins;
            int otherWins;
            int drawsByStalemate;
            int drawsByMaterial;
            int drawsByRepetiton;
            int drawsByMovesRule;
            int drawsByCountingRules;
            int drawsByAdjudication;
            int drawsByAgreement;
            int otherDraws;
            QString timeControl;
        };

        QString resultsForSides(int index) const;

        GameManager* m_gameManager;
        ChessGame* m_lastGame;
        QString m_error;
        QString m_name;
        QString m_site;
        QString m_variant;
        int m_round;
        int m_oldRound;
        int m_nextGameNumber;
        int m_finishedGameCount;
        int m_savedGameCount;
        int m_finalGameCount;
        int m_gamesPerEncounter;
        int m_roundMultiplier;
        int m_startDelay;
        int m_openingDepth;
        int m_seedCount;
        bool m_stopping;
        int m_openingRepetitions;
        OpeningPolicy m_openingPolicy;
        bool m_recover;
        bool m_pgnCleanup;
        bool m_pgnWriteUnfinishedGames;
        bool m_finished;
        bool m_bookOwnership;
        GameAdjudicator m_adjudicator;
        OpeningSuite* m_openingSuite;
        Sprt* m_sprt;
        QFile m_pgnFile;
        QTextStream m_pgnOut;
        QFile m_epdFile;
        QTextStream m_epdOut;
        QString m_startFen;
        int m_repetitionCounter;
        int m_swapSides;
        bool m_reverseSides;

        QString m_resultFormat;
        PgnGame::PgnMode m_pgnOutMode;
        TournamentPair* m_pair;
        QMap< QPair<int, int>, TournamentPair* > m_pairs;
        QList<TournamentPlayer> m_players;
        QMap<int, PgnGame> m_pgnGames;
        QMap<ChessGame*, GameData*> m_gameData;
        QVector<Chess::Move> m_openingMoves;
        QMap<int, QString> m_headerMap;
};

class LIB_EXPORT ResultFormatter : public QObject
{
    Q_OBJECT

    public:
        ResultFormatter(const QMap<QString, int>& tokenMap,
                const QString& format = QString(),
                QObject* parent = nullptr);
        void setEntryFormat(const QString& format);
        QString entryFormat() const;
        QString entry(const QMap<int, QString>& data) const;
    private:
        QString m_entryFormat;
        QMap<QString, int> m_tokenMap;
        QStringList m_tokenList;
};

#endif // TOURNAMENT_H