#ifndef SPARENTPROCESS
#define SPARENTPROCESS
#include <QObject>
#include "sutilclass.h"
#include <QVector>
#include <QMap>
#include <QProcess>
//#include "serrorsender.h"

class QStringList;
class QString;


class SParentProcess: public QObject
{
    Q_OBJECT

protected:
    enum class E_INNER_RUN_MODE:unsigned short
    {
        MODE_WAIT = 0,
        MODE_RUN_INIT,
        MODE_RUN_EVENTCODE,
        MODE_WAIT_INIT,
        MODE_WAIT_EVENTCODE,
        MODE_WAIT_TERMINATE,
        MODE_WAIT_HANGING,
        MODE_FINISH = MODE_WAIT
    };


public:
    SParentProcess();
    virtual void setList(const QVector<int>& _list) = 0;
    virtual void setList(QVector<int>&& _list) = 0;
    virtual void setList(const QVector<SEffectRow>& _list) = 0;
    virtual void setList(QVector<SEffectRow>&& _list) = 0;
    virtual void runInit() = 0;
    virtual void runEventCode() = 0;
    virtual void clear();
    QVector<SEffectRow> getErrorList() const;
    SReportSummary getReportSummary(int _id) const;
    QMap<int, SReportSummary> getReportSummary() const;
    SError getError() const;
    bool isWaiting() const;
    void setModeWait();

private:
    SError analyzeStdOut(const QString& _str);
    QString makeLog(const SError& _error);
    void killProcess();


protected:
    QStringList getProcessArguments(const SEffectRow& _row) const;
    //QStringList getProcessArguments(SEffectRow&& _row) const;

    void setError(const SError& _error);
    void setError(SError&& _error);
    void setInnerMode(E_INNER_RUN_MODE _mode);
    bool isUserAbort();
    void setCurrentEffectRow(const SEffectRow& _row);
    void setCurrentEffectRow(SEffectRow&& _row);
    void runProcess(QStringList _arguments);
    void setReportSummary(const QMap<int, SReportSummary>& _mapSummary);

public slots:
    void stop();
    void update();
    void finishedProcess(int exitCode, QProcess::ExitStatus exitStatus);
    void finishedProcess(QProcess::ProcessError _error);

signals:
    void signalUserAbort();
    void signalTerminateError(const SError& _error);
    void signalTerminateNormal();
    void signalTerminate();
    void signalLog(const QString& _log);
    void signalTerminateEachEvent(int _company, E_CRAWL_STATE _state);


protected slots:
    void slotTerminateError(const SError& _error);


private:
    QProcess* m_pProcess;

    E_INNER_RUN_MODE m_eInnerMode;
    SEffectRow m_erCurrentRow;
    QVector<SEffectRow> m_vecError;
    bool m_bRunning;
    unsigned int nTime;
    SError m_error;
    bool m_bUserAbort;
    QMap<int, SReportSummary> m_mapReportSummary;
    //SErrorSender* m_pErrorSender;
};


#endif // SPARENTPROCESS