use serde_json::Value; // <--

async fn function_handler(event: LambdaEvent<EventBridgeEvent<Value>>) -> Result<(), Error> {
//                                                           -------
    dbg!(&event); // <--
    Ok(())
}

async fn function_handler(event: LambdaEvent<EventBridgeEvent<Value>>) -> Result<(), Error> {
    let resp = reqwest::get("https://loige.co").await?;
    let status = resp.status().as_u16();
    let success = resp.status().is_success();
    dbg!(status);
    dbg!(success);

    Ok(())
}

sam build --beta-features

// ...
use std::time::Instant;

async fn function_handler(_event: LambdaEvent<EventBridgeEvent<Value>>) -> Result<(), Error> {
    let start = Instant::now(); // <--
    let resp = reqwest::get("https://loige.co").await?;
    let duration = start.elapsed(); // <--

    let status = resp.status().as_u16();
    let success = resp.status().is_success();
    dbg!(status);
    dbg!(success);
    dbg!(duration); // <--

    Ok(())
}

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(10))
        .build()?;

    let resp = client
        .get("https://httpstat.us/504?sleep=60000")
        .send()
        .await?;

 let resp = client
        .get("https://httpstat.us/504?sleep=60000")
        .send()
        .await; // <--- removed "?"
    let duration = start.elapsed();

    match resp {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let success = resp.status().is_success();
            dbg!(status);
            dbg!(success);
            dbg!(duration);
        }
        Err(e) => {
            eprintln!("The request failed: {}", e);
        }
    }

struct HandlerConfig {
    url: reqwest::Url,
    client: reqwest::Client,
}

async fn function_handler(
    config: &HandlerConfig, // <- now we can receive a reference to the config
    _event: LambdaEvent<EventBridgeEvent<Value>>,
) -> Result<(), Error> {
  // ...
}

let start = Instant::now();
    // Here we use the client from config and we don't need to create one
    let resp = config.client.get(config.url.as_str()).send().await; 
    let duration = start.elapsed();

    match resp {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let success = resp.status().is_success();
            dbg!(status);
            dbg!(success);
            dbg!(duration);
        }
        Err(e) => {
            eprintln!("The request failed: {}", e);
        }
    }

    Ok(())

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing::init_default_subscriber();

    // new code
    let url = env::var("URL").expect("URL environment variable is not set");
    let url = reqwest::Url::parse(&url).expect("URL environment variable is not a valid URL");
    let timeout = env::var("TIMEOUT").unwrap_or_else(|_| "60".to_string());
    let timeout = timeout
        .parse::<u64>()
        .expect("TIMEOUT environment variable is not a valid number");
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(timeout))
        .build()?;
    let config = &HandlerConfig { url, client };
    // end new code

    // updated to pass the config in every invocation
    run(service_fn(move |event| async move {
        function_handler(config, event).await
    }))
    .await
}

struct HandlerConfig {
    url: reqwest::Url,
    client: reqwest::Client,
    table_name: String, // <-
}

let table_name = env::var("TABLE_NAME").expect("TABLE_NAME environment variable is not set");

let config = &HandlerConfig {
    url,
    client,
    table_name, // <- new
};

struct HandlerConfig {
    url: reqwest::Url,
    client: reqwest::Client,
    table_name: String,
    dynamodb_client: aws_sdk_dynamodb::Client, // <-
}

let region_provider = RegionProviderChain::default_provider();
let config = aws_config::defaults(BehaviorVersion::latest())
    .region(region_provider)
    .load()
    .await;
let dynamodb_client = aws_sdk_dynamodb::Client::new(&config);

let config = &HandlerConfig {
    url,
    client,
    table_name,
    dynamodb_client, // <-
};

cargo add chrono

async fn function_handler(
    config: &HandlerConfig,
    event: LambdaEvent<EventBridgeEvent<Value>>,
) -> Result<(), Error> {
    let start = Instant::now();
    let resp = config.client.get(config.url.as_str()).send().await;
    let duration = start.elapsed();

    // Added logic to get the current timestamp (either from the event or,
    // if not provided, uses the current timestamp)
    let timestamp = event
        .payload
        .time
        .unwrap_or_else(chrono::Utc::now)
        .format("%+")
        .to_string();
    
    // We start to create the record we want to store in DynamoDb
    let mut item = HashMap::new();
    // We insert the Id and the Timestamp fields
    item.insert(
        "Id".to_string(),
        AttributeValue::S(format!("{}#{}", config.url, timestamp)),
    );
    item.insert("Timestamp".to_string(), AttributeValue::S(timestamp));

    // Updated our match statement to populate the record fields
    // depending if the request failed or if it completed
    // Note: we are now returning success: (always false for request failures, 
    // while it depends on the status code for completed requests)
    let success = match resp {
        Ok(resp) => {
            let status = resp.status().as_u16();
            // In case of success we add the Status and the Duration fields
            item.insert("Status".to_string(), AttributeValue::N(status.to_string()));
            item.insert(
                "Duration".to_string(),
                AttributeValue::N(duration.as_millis().to_string()),
            );
            resp.status().is_success()
        }
        Err(e) => {
            // In case of failure we add the Error field
            item.insert("Error".to_string(), AttributeValue::S(e.to_string()));
            false
        }
    };
    // Finally, we had the Success field
    item.insert("Success".to_string(), AttributeValue::Bool(success));

    // Now we can send the request to DynamoDB
    let insert_result = config
        .dynamodb_client
        .put_item()
        .table_name(config.table_name.as_str())
        .set_item(Some(item))
        .send()
        .await?;

    // And log the result
    tracing::info!("Insert result: {:?}", insert_result);

    Ok(())
}

sam validate --lint && sam build --beta-features && sam deploy