#include <fluent-bit/flb_info.h>
#include <fluent-bit/flb_mem.h>
#include <fluent-bit/flb_http_client.h>
#include <fluent-bit/flb_upstream.h>
#include <fluent-bit/flb_signv4.h>
#include <fluent-bit/flb_aws_credentials.h>
#include <monkey/mk_core.h>
#include <unistd.h>
#include <fluent-bit/flb_sds.h>
#include "flb_fuzz_header.h"

#define AWS_ACCESS_KEY_ID              "AWS_ACCESS_KEY_ID"
#define AWS_SECRET_ACCESS_KEY          "AWS_SECRET_ACCESS_KEY"
#define AWS_SESSION_TOKEN              "AWS_SESSION_TOKEN"

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    if (size < 59) {
        return 0;
    }

    /* Set flb_malloc_mod to be fuzzer-data dependent */
    flb_malloc_p = 0;
    flb_malloc_mod = *(int*)data;
    data += 4;
    size -= 4;

    /* Avoid division by zero for modulo operations */
    if (flb_malloc_mod == 0) {
        flb_malloc_mod = 1;
    }

    char s3_mode = data[0];
    MOVE_INPUT(1)
    int method = (int)data[0];

    /* Prepare a general null-terminated string */
    char *uri             = get_null_terminated(50, &data, &size);
    char *null_terminated = get_null_terminated(size, &data, &size);

    /* Now begin the core work of the fuzzer */
    struct flb_config *config;
    struct mk_list *tests;
    struct flb_aws_provider *provider;
    config = flb_calloc(1, sizeof(struct flb_config));
    if (!config) {
        flb_free(uri);
        flb_free(null_terminated);
        return 0;
    }
    mk_list_init(&config->upstreams);
    provider = flb_aws_env_provider_create();

    /* Create the necessary http context */
    struct flb_upstream *http_u;
    struct flb_connection *http_u_conn = NULL;
    struct flb_http_client *http_c;
    struct flb_config *http_config;

    http_config = flb_config_init();
    if (http_config == NULL) {
        flb_aws_provider_destroy(provider);
        flb_free(uri);
        flb_free(null_terminated);
        flb_free(config);
        return 0;
    }

    http_u = flb_upstream_create(http_config, "127.0.0.1", 8001, 0, NULL);
    if (http_u != NULL) {
        http_u_conn = flb_calloc(1, sizeof(struct flb_connection));
        if (http_u_conn != NULL) {
            http_u_conn->upstream = http_u;

            http_c = flb_http_client(http_u_conn, method, uri,
                         null_terminated, size, "127.0.0.1", 8001, NULL, 0);
            if (http_c) {
                /* Call into the main target flb_signv4_do*/
                time_t t = 1440938160;
                char *region = "us-east-1";
                char *access_key = "AKIDEXAMPLE";
                char *service = "service";
                char *secret_key = "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY";
                int ret = setenv(AWS_ACCESS_KEY_ID, access_key, 1);
                if (ret >= 0) {
                    ret = setenv(AWS_SECRET_ACCESS_KEY, secret_key, 1);
                    if (ret >= 0) {
                        flb_sds_t signature = flb_signv4_do(http_c, FLB_TRUE, FLB_FALSE,
                                    t, region, service, s3_mode, NULL, provider);
                        if (signature) {
                          flb_sds_destroy(signature);
                        }
                    }
                }
                flb_http_client_destroy(http_c);
            }
        }
        flb_upstream_destroy(http_u);
    }

    /* Cleanup */
    flb_config_exit(http_config);
    flb_aws_provider_destroy(provider);
    flb_free(config);

    flb_free(null_terminated);
    flb_free(http_u_conn);
    flb_free(uri);

    return 0;
}