#ifndef NETWORKACCESSMANAGER_H
#define NETWORKACCESSMANAGER_H

#include <QFuture>
#include <QFutureInterface>
#include <QHttpMultiPart>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QList>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <functional>

class NetworkAccessManager : public QNetworkAccessManager
{
    Q_OBJECT

public:
    static NetworkAccessManager* instance();

protected:
    NetworkAccessManager(QObject* parent = nullptr);
    QNetworkReply* createRequest(Operation op,
                                 const QNetworkRequest& request,
                                 QIODevice* outgoingData = nullptr) override;
};
// HTTP 响应结构
struct HttpResponse
{
    int code = 0;
    QJsonValue data;
    QString message;
};

namespace TC {
// 拦截器接口
class Interceptor
{
public:
    virtual ~Interceptor() {}
    virtual void interceptRequest(QNetworkRequest& /*request*/) {}
    virtual void interceptResponse(QNetworkReply* /*reply*/) {}
};

// 请求客户端选项
struct RequestClientOptions
{
    QString baseURL;
    bool enableDefaultInterceptors = true;
    QString responseReturn = ""; // 可以是 "data" 或空

    int timeout = 10000; // 默认超时时间为10秒
};

// 请求客户端
class RequestClient : public QObject
{
    Q_OBJECT
public:
    explicit RequestClient(const RequestClientOptions& options = RequestClientOptions());

    // 创建客户端实例
    static RequestClient* createClient(const QString& baseURL,
                                       const RequestClientOptions& options = RequestClientOptions());

    // 获取全局实例
    static RequestClient* requestClient(const RequestClientOptions& options = RequestClientOptions());
    static RequestClient* baseRequestClient(
        const RequestClientOptions& options = RequestClientOptions());

    // 拦截器管理
    void addInterceptor(Interceptor* interceptor);
    void removeInterceptor(Interceptor* interceptor);

    // 基础URL设置
    void setBaseUrl(const QString& url);
    QString baseUrl() const;

    void setTimeout(int timeout);
    int timeout() const;

    // 同步请求
    QNetworkReply* getSync(const QString& url, const QVariantMap& params = QVariantMap());
    QNetworkReply* postSync(const QString& url, const QJsonDocument& data = QJsonDocument());
    QNetworkReply* putSync(const QString& url, const QJsonDocument& data = QJsonDocument());
    QNetworkReply* deleteSync(const QString& url);
    QNetworkReply* uploadSync(const QString& url, QHttpMultiPart* multiPart);

    // 异步请求
    QFuture<HttpResponse> getAsync(const QString& url, const QVariantMap& params = QVariantMap());
    QFuture<HttpResponse> postAsync(const QString& url, const QJsonDocument& data = QJsonDocument());
    QFuture<HttpResponse> putAsync(const QString& url, const QJsonDocument& data = QJsonDocument());
    QFuture<HttpResponse> deleteAsync(const QString& url);
    QFuture<HttpResponse> uploadAsync(const QString& url, QHttpMultiPart* multiPart);

    QFuture<bool> downloadAsync(const QString& url, const QString& saveFilePath);

    bool download(const QString& url, const QString& saveFilePath);

    // Token 刷新相关
    bool isRefreshing() const { return m_isRefreshing; }
    void setRefreshing(bool refreshing) { m_isRefreshing = refreshing; }
    QList<std::function<void(const QString&)>>& refreshTokenQueue() { return m_refreshTokenQueue; }

    void setupAsyncConnections(QNetworkReply* reply, QFutureInterface<HttpResponse>& _interface);

private:
    // 原始请求方法
    QNetworkReply* get(const QString& url, const QVariantMap& params = QVariantMap());
    QNetworkReply* post(const QString& url, const QJsonDocument& data = QJsonDocument());
    QNetworkReply* put(const QString& url, const QJsonDocument& data = QJsonDocument());
    QNetworkReply* deleteResource(const QString& url);
    QNetworkReply* upload(const QString& url, QHttpMultiPart* multiPart);

    void setupDefaultInterceptors();
    void processRequest(QNetworkRequest& request);
    void processResponse(QNetworkReply* reply);

    HttpResponse parseReplyData(QNetworkReply* reply);

    QString m_baseUrl;
    int m_timeout = 10000;

    QList<Interceptor*> interceptors;
    bool m_isRefreshing = false;
    QList<std::function<void(const QString&)>> m_refreshTokenQueue;
};

} // namespace TC

#endif // NETWORKACCESSMANAGER_H