#pragma once

#include <QList>
#include "rpcobject.h"
#include "../downloads/downloadinforequest.h"
#include <unordered_set>
#include <unordered_map>
#include "../outward/outwarddownloads.h"
#include "../common/uniquesessionidproducer.h"
#include "../downloads/downloadscreator.h"

class SettingsMgr;
class DownloadsMgr;
class OutwardDownloadsManager;
class FoldersHistoryMgr;
class PasswordsMgr;
class QNetworkCookie;
class UIHelper;
class DownloadsPlusCreatingDownloads;
class DownloadsScheduledTasksMgr;
class CustomQtEventsDispatcher;
class BatchDownloadsCreator;
class AllDownloadsManager;
class DownloadsCreatorStrongTasksManager;
class BaseDefaultDownloadFolderProvider;
class FdmDiskMonitor;

class RPCDownloadWizard : public RPCObject
{
    Q_OBJECT

private:
    using UiTransactionId = qint64;
    static constexpr UiTransactionId InvalidUiTransactionId = -1;

    struct InfoReceivedEvent : public QEvent
    {
        static const QEvent::Type Type;

        InfoReceivedEvent(Download::Id id)
            : QEvent(Type),
              requestId(id)
        {}

        Download::Id requestId;
    };

    struct InfoRequestFailedEvent : public QEvent
    {
        static const QEvent::Type Type;

        InfoRequestFailedEvent(Download::Id id)
            : QEvent(Type),
              requestId(id)
        {}

        Download::Id requestId;
    };

public:
    explicit RPCDownloadWizard(AllDownloadsManager *allDownloadsMgr,
                               SettingsMgr *settingsMgr,
                               DownloadsMgr *downloadsMgr,
                               DownloadsCreator *downloadsCreator,
                               DownloadsCreatorStrongTasksManager *strongCreateTasks,
                               BatchDownloadsCreator *batchDownloadsCreator,
                               QSharedPointer<DownloadsPlusCreatingDownloads> allDownloads,
                               OutwardDownloadsManager *outwardDownloadsMgr,
                               FoldersHistoryMgr *foldersHistoryMgr,
                               UIHelper *uihelper,
                               class PreviewManager *previewMgr,
                               QSharedPointer<DownloadsScheduledTasksMgr> downloadsScheduler,
                               QSharedPointer<CustomQtEventsDispatcher> customEventsDispatcher,
                               QSharedPointer<BaseDefaultDownloadFolderProvider> defaultDownloadFolderProvider,
                               QSharedPointer<FdmDiskMonitor> fdmDiskMonitor,
                               RPCObject *parent = nullptr);
    virtual ~RPCDownloadWizard() = default;

    // RPCObject
    virtual bool process(const QString &id, const Value &args, Value &result) override;

    RPC_METHOD bool requestDownloadInfo(const Value &arguments, Value &result);
    RPC_METHOD bool createDownload(const Value &arguments, Value &result);
    RPC_METHOD bool cancelCreation(const Value &arguments, Value &result);
    RPC_METHOD bool getPreparedURL(const Value &arguments, Value &result);
    RPC_METHOD bool getLastFolders(const Value &arguments, Value &result);
    RPC_METHOD bool getFolderForDownloadType(const Value &arguments, Value &result);
    RPC_METHOD bool autostartFailed(const Value &arguments, Value &result);
    RPC_METHOD bool addTrackers(const Value &arguments, Value &result);
    RPC_METHOD bool downloadListLinks(const Value &arguments, Value &result);
    RPC_METHOD bool resumeDownload(const Value &arguments, Value &result);
    RPC_METHOD bool calcSizeOnDiskForSelection(const Value &arguments, Value &result);
    RPC_METHOD bool startUiTransaction(const Value &arguments, Value &result);

signals:
    void downloadCaught(
            OutwardDownloadId id,
            const OutwardDownloadProcessingResult &result);

protected:
    virtual void customEvent(QEvent *event) override;

private slots:
    void onDownloadInfoReceived(Download::Id requestId);
    void onDownloadInfoRequestFailed(Download::Id requestId);
    void onTorrentExistsAlready(Download::Id requestId);
    void onEquivalentDownloadsExist(Download::Id id, Download::Id eqId);

    void onNewDownload(
            const OutwardDownloadInfo &info,
            const OutwardDownloadCreateParams &params);
    void onNewDownloads(
            const OutwardDownloadsInfo &info,
            const OutwardDownloadCreateParams &params);

    void onPreviewGenerated(quint32 id);
    void onDefaultTimetableChanged();

private:
    void downloadInfoReceived(Download::Id requestId);

    ValueMap constructDownloadInfoMap(UiTransactionId tid);
    ValueMap constructDownloadInfoMap(Download::Id singleDnldId,
                                      const DownloadsCreator::DownloadCreateState &s,
                                      int authErrorCount);

    qint64 diskSizeFor(const DownloadInfo &dInfo, const std::set<int> &nodes, bool supportsSparseFiles) const;

private:
    AllDownloadsManager *m_allDownloadsMgr;
    SettingsMgr *m_settingsMgr;
    DownloadsMgr *m_downloadsMgr;
    FoldersHistoryMgr *m_foldersHistoryMgr;
    DownloadsCreator *m_downloadsCreator;
    DownloadsCreatorStrongTasksManager *m_strongCreateTasks;
    BatchDownloadsCreator *m_batchDownloadsCreator;
    PasswordsMgr *m_passwordsMgr;
    UIHelper *m_uihelper;
    QSharedPointer<DownloadsPlusCreatingDownloads> m_allDownloads;
    std::mutex m_mutex;
    UniqueSessionIdProducer m_idGen;
    QSharedPointer<DownloadsScheduledTasksMgr> m_downloadsScheduler;
    QSharedPointer<CustomQtEventsDispatcher> m_customEventsDispatcher;
    QSharedPointer<BaseDefaultDownloadFolderProvider> m_defaultDownloadFolderProvider;
    QSharedPointer<FdmDiskMonitor> m_fdmDiskMonitor;

    struct UiTransactionInfo
    {
        OutwardDownloadId outwardDownloadId = InvalidOutwardDownloadId;

        struct DownloadData
        {
            Download::Id downloadId = Download::InvalidId;
            DownloadInfo downloadInfo;
            bool useDownloadInfo = false;
            int authErrorCount = 0;
            bool abortCreationOnCancel = true;
        };

        std::vector<DownloadData> downloads = {DownloadData()};

        bool silentDownload = false;
        bool idSubmitted = false;

        DownloadData& singleDownload()
        {
            Q_ASSERT(downloads.size() == 1);
            return downloads.front();
        }

        const DownloadData& singleDownload() const
        {
            Q_ASSERT(downloads.size() == 1);
            return downloads.front();
        }

        bool isSingleDownload() const
        {
            return downloads.size() == 1;
        }
    };

    std::unordered_map<UiTransactionId, UiTransactionInfo> m_transactions;
    std::unordered_map<Download::Id, UiTransactionId> m_request2transaction;

    bool transactionExists(UiTransactionId id);
    bool downloadTransactionExists(Download::Id dId);
    UiTransactionInfo transaction(UiTransactionId id);
    void updateTransaction(UiTransactionId id, const UiTransactionInfo &info);
    void removeTransaction(UiTransactionId id);
    UiTransactionId transactionId(Download::Id infoRequestId);
    void endTransaction(UiTransactionId id, bool cancelDownloadCreation, bool downloadAdded);

protected:
    void newDialog(UiTransactionId id);
    QString adjustAuthErrorMessage(const QString &err, int errCount);
    void cancelTransactionDownload(UiTransactionId id, bool downloadAdded);
};