#include <QApplication>
#include <QNetworkAccessManager>
#include <QOAuth2AuthorizationCodeFlow>
#include <QOAuthHttpServerReplyHandler>
#include <QDebug>
#include <QUrlQuery>
#include <QDesktopServices>
#include <QSettings>

// Define constants similar to the original code
#define STRAVA_CLIENT_ID 7976
#define STRAVA_CLIENT_ID_S "7976"
// You would define STRAVA_SECRET_KEY in a real application

class StravaConnectTest : public QObject {
    Q_OBJECT

public:
    StravaConnectTest(QObject *parent = nullptr) : QObject(parent) {
        manager = nullptr;
        strava = nullptr;
        stravaReplyHandler = nullptr;
        connect(&m_timer, &QTimer::timeout, this, &StravaConnectTest::testConnect);
        m_timer.start(1000); // Start test after 1 second
    }

    ~StravaConnectTest() {
        if (manager) delete manager;
        if (strava) delete strava;
        if (stravaReplyHandler) delete stravaReplyHandler;
    }

public slots:
    void testConnect() {
        m_timer.stop();
        qDebug() << "Starting Strava connect test";
        strava_connect();
    }

private slots:
    void onStravaGranted() {
        qDebug() << "Strava authentication granted";
        stravaAuthWebVisible = false;
        QSettings settings;
        settings.setValue("strava_accesstoken", strava->token());
        settings.setValue("strava_refreshtoken", strava->refreshToken());
    }

    void onStravaAuthorizeWithBrowser(const QUrl &url) {
        qDebug() << "Open with browser:" << url.toString();
        stravaAuthUrl = url.toString();
        
        // In a real application, you might choose between internal or external browser
        QDesktopServices::openUrl(url);
    }

    void replyDataReceived(const QByteArray &v) {
        qDebug() << "Reply data received:" << v;
        
        QSettings settings;
        QString s(v);
        QJsonDocument jsonResponse = QJsonDocument::fromJson(s.toUtf8());
        settings.setValue("strava_accesstoken", jsonResponse["access_token"]);
        settings.setValue("strava_refreshtoken", jsonResponse["refresh_token"]);
        settings.setValue("strava_expires", jsonResponse["expires_at"]);
    }

    void callbackReceived(const QVariantMap &values) {
        qDebug() << "Callback received:" << values;
        if (!values.value("code").toString().isEmpty()) {
            strava_code = values.value("code").toString();
            qDebug() << "Strava code:" << strava_code;
        }
    }

private:
    QOAuth2AuthorizationCodeFlow *strava_connect() {
        if (manager) {
            delete manager;
            manager = nullptr;
        }
        if (strava) {
            delete strava;
            strava = nullptr;
        }
        if (stravaReplyHandler) {
            delete stravaReplyHandler;
            stravaReplyHandler = nullptr;
        }
        
        manager = new QNetworkAccessManager(this);
        strava = new QOAuth2AuthorizationCodeFlow(manager, this);
        strava->setScope("activity:read_all,activity:write");
        strava->setClientIdentifier(STRAVA_CLIENT_ID_S);
        strava->setAuthorizationUrl(QUrl("https://www.strava.com/oauth/authorize"));
        strava->setAccessTokenUrl(QUrl("https://www.strava.com/oauth/token"));
        
        // In a real application, you would set the client secret
        // strava->setClientIdentifierSharedKey(STRINGIFY(STRAVA_SECRET_KEY));
        
        // Set up modify parameters function
        strava->setModifyParametersFunction(
            [](QAbstractOAuth::Stage stage, QMultiMap<QString, QVariant> *parameters) {
                if (stage == QAbstractOAuth::Stage::RequestingAuthorization) {
                    parameters->insert("responseType", "code");
                    parameters->insert("approval_prompt", "force");
                    QByteArray code = parameters->value("code").toByteArray();
                    parameters->remove("code");
                    parameters->insert("code", QUrl::fromPercentEncoding(code));
                }
                if (stage == QAbstractOAuth::Stage::RefreshingAccessToken) {
                    parameters->insert("client_id", STRAVA_CLIENT_ID_S);
                    // parameters->insert("client_secret", STRINGIFY(STRAVA_SECRET_KEY));
                }
            }
        );
        
        stravaReplyHandler = new QOAuthHttpServerReplyHandler(QHostAddress("127.0.0.1"), 8091, this);
        connect(stravaReplyHandler, &QOAuthHttpServerReplyHandler::replyDataReceived, 
                this, &StravaConnectTest::replyDataReceived);
        connect(stravaReplyHandler, &QOAuthHttpServerReplyHandler::callbackReceived, 
                this, &StravaConnectTest::callbackReceived);

        strava->setReplyHandler(stravaReplyHandler);

        connect(strava, &QOAuth2AuthorizationCodeFlow::authorizeWithBrowser, 
                this, &StravaConnectTest::onStravaAuthorizeWithBrowser);
        connect(strava, &QOAuth2AuthorizationCodeFlow::granted, 
                this, &StravaConnectTest::onStravaGranted);

        // Attempt to start the OAuth process - this is where the crash might occur
        strava->grant();

        return strava;
    }

    QNetworkAccessManager *manager;
    QOAuth2AuthorizationCodeFlow *strava;
    QOAuthHttpServerReplyHandler *stravaReplyHandler;
    QString strava_code;
    QString stravaAuthUrl;
    bool stravaAuthWebVisible = false;
    QTimer m_timer;
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    // Set up application metadata
    QCoreApplication::setOrganizationName("QZ");
    QCoreApplication::setApplicationName("StravaConnectTest");
    
    QLoggingCategory::setFilterRules("qt.networkauth.*=true");
    
    StravaConnectTest tester;
    
    return app.exec();
}

#include "main.moc"