hwo to send token on redirection in passport

// Step 1: Include necessary libraries and headers
#include <iostream>
#include <cpprest/http_client.h>
#include <cpprest/http_listener.h>
#include <cpprest/uri.h>
#include <cpprest/json.h>
#include <cpprest/filestream.h>
#include <cpprest/containerstream.h>
#include <cpprest/interopstream.h>
#include <cpprest/producerconsumerstream.h>
#include <cpprest/rawptrstream.h>
#include <cpprest/streams.h>
#include <cpprest/asyncrt_utils.h>
#include <cpprest/uri_builder.h>
#include <cpprest/http_headers.h>
#include <cpprest/base_uri.h>

using namespace web;
using namespace web::http;
using namespace web::http::client;
using namespace web::http::experimental::listener;
using namespace web::http::headers;

// Step 2: Define a callback URI for redirection
utility::string_t callback_uri = U("http://localhost:5000/callback");

// Step 3: Create an OAuth2 authorization request URI
void handle_authorize(web::http::http_request request)
{
    web::http::uri_builder authorize_uri(U("https://oauth2provider.com/authorize"));
    authorize_uri.append_query(U("client_id"), U("your_client_id"));
    authorize_uri.append_query(U("redirect_uri"), callback_uri);
    authorize_uri.append_query(U("response_type"), U("code"));

    request.reply(web::http::status_codes::Found, U(""), {{U("Location"), authorize_uri.to_uri().to_string()}});
}

// Step 4: Handle the callback after authorization
void handle_callback(web::http::http_request request)
{
    // Step 4.1: Extract the authorization code from the query parameters
    auto query_params = web::http::uri::split_query(request.request_uri().query());
    auto authorization_code = query_params[U("code")];

    // Step 4.2: Exchange the authorization code for an access token
    web::http::client::http_client client(U("https://oauth2provider.com/token"));
    web::http::uri_builder token_uri(U(""));
    token_uri.append_query(U("client_id"), U("your_client_id"));
    token_uri.append_query(U("client_secret"), U("your_client_secret"));
    token_uri.append_query(U("redirect_uri"), callback_uri);
    token_uri.append_query(U("code"), authorization_code);
    token_uri.append_query(U("grant_type"), U("authorization_code"));

    web::http::http_request token_request(web::http::methods::POST);
    token_request.headers().set_content_type(U("application/x-www-form-urlencoded"));
    token_request.headers().set_content_length(0);

    client.request(token_request).then([request](web::http::http_response response) {
        // Step 4.3: Extract the access token from the response
        auto token = response.extract_json().get().at(U("access_token")).as_string();

        // Step 4.4: Use the access token as needed (e.g., send it in the response)
        request.reply(web::http::status_codes::OK, token);
    }).wait();
}

// Step 5: Set up the HTTP listener to handle authorization and callback
int main()
{
    http_listener listener(callback_uri);
    listener.support(web::http::methods::GET, handle_authorize);
    listener.support(web::http::methods::GET, handle_callback);

    try
    {
        listener.open().wait();
        std::cout << "Listening for requests..." << std::endl;
        std::this_thread::sleep_for(std::chrono::minutes(5)); // Run for 5 minutes for demonstration purposes
        listener.close().wait();
    }
    catch (const std::exception &e)
    {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}