chessengine.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 CHESSENGINE_H
#define CHESSENGINE_H

#include "chessplayer.h"
#include <QVariant>
#include <QStringList>
#include "engineconfiguration.h"

class QIODevice;
class EngineOption;


class LIB_EXPORT ChessEngine : public ChessPlayer
{
    Q_OBJECT

    public:
        enum WriteMode
        {
            Buffered,   
            Unbuffered  
        };

        ChessEngine(QObject* parent = nullptr);
        virtual ~ChessEngine();

        QIODevice* device() const;
        void setDevice(QIODevice* device);

        // Inherited from ChessPlayer
        virtual void endGame(const Chess::Result& result);
        virtual bool isHuman() const;
        virtual bool isReady() const;
        virtual bool supportsVariant(const QString& variant) const;

        void start();

        void applyConfiguration(const EngineConfiguration& configuration);

        void ping(bool sendCommand = true);
        
        virtual QString protocol() const = 0;

        void write(const QString& data, WriteMode mode = Buffered);

        void setOption(const QString& name, const QVariant& value);

        QList<EngineOption*> options() const;

        QStringList variants() const;
        
    public slots:
        // Inherited from ChessPlayer
        virtual void go();
        virtual void quit();
        virtual void kill();
        
    protected:
        static QStringRef firstToken(const QString& str,
                         bool readToEnd = false);
        static QStringRef nextToken(const QStringRef& previous,
                        bool readToEnd = false);

        // Inherited from ChessPlayer
        virtual void startGame() = 0;

        virtual void startProtocol() = 0;

        virtual void parseLine(const QString& line) = 0;

        virtual bool sendPing() = 0;

        virtual void sendStop() = 0;

        virtual void sendQuit() = 0;

        bool stopThinking();

        void addOption(EngineOption* option);
        EngineOption* getOption(const QString& name) const;
        virtual void sendOption(const QString& name, const QVariant& value) = 0;

        void addVariant(const QString& variant);
        void clearVariants();

        EngineConfiguration::RestartMode restartMode() const;
        virtual bool restartsBetweenGames() const;
        virtual bool isPondering() const;

        bool whiteEvalPov() const;
        bool pondering() const;

    protected slots:
        // Inherited from ChessPlayer
        virtual void onTimeout();

        void onReadyRead();

        void onPingTimeout();

        void onIdleTimeout();

        void pong(bool emitReady = true);

        void onProtocolStart();

        void flushWriteBuffer();

        void clearWriteBuffer();

    private slots:
        void onQuitTimeout();
        void onProtocolStartTimeout();

    private:
        static int s_count;

        int m_id;
        State m_pingState;
        bool m_pinging;
        bool m_whiteEvalPov;
        bool m_pondering;
        QTimer* m_pingTimer;
        QTimer* m_quitTimer;
        QTimer* m_idleTimer;
        QTimer* m_protocolStartTimer;
        QIODevice *m_ioDevice;
        QStringList m_writeBuffer;
        QStringList m_variants;
        QList<EngineOption*> m_options;
        QMap<QString, QVariant> m_optionBuffer;
        EngineConfiguration::RestartMode m_restartMode;
};

#endif // CHESSENGINE_H