// Copyright (C) 2023 Intel Corporation
// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
// See LICENSE.TXT
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include 

#include 

#include "helpers.h"
#include "ur_util.hpp"

class GetEnvToMapWithParam
    : public ::testing::TestWithParam<
          std::map> {
  protected:
    int ret = -1;
    std::map test_map;

    void SetUp() override {
        std::stringstream env_var_value;
        test_map = GetParam();

        for (auto const &item : test_map) {
            if (&item.first != &test_map.begin()->first) {
                env_var_value front(), huge_str);

    ret = unsetenv("UR_TEST_ENV_VAR");
    ASSERT_EQ(ret, 0);
}

TEST(GetenvToVec, MultipleValues) {
    int ret = setenv("UR_TEST_ENV_VAR", "value_1,value_2", 1);
    ASSERT_EQ(ret, 0);

    std::vector test_vec = {"value_1", "value_2"};
    auto vec = getenv_to_vec("UR_TEST_ENV_VAR");
    ASSERT_TRUE(vec.has_value());
    ASSERT_EQ(vec, test_vec);

    ret = unsetenv("UR_TEST_ENV_VAR");
    ASSERT_EQ(ret, 0);
}

TEST(GetenvToVec, EmptyEnvVar) {
    int ret = unsetenv("UR_TEST_ENV_VAR");
    ASSERT_EQ(ret, 0);

    auto vec = getenv_to_vec("UR_TEST_ENV_VAR");
    ASSERT_FALSE(vec.has_value());
}

TEST(GetenvToMap, EmptyEnvVar) {
    int ret = unsetenv("UR_TEST_ENV_VAR");
    ASSERT_EQ(ret, 0);

    auto map = getenv_to_map("UR_TEST_ENV_VAR");
    ASSERT_FALSE(map.has_value());
}

// ////////////////////////////////////////////////////////////////////////////////////
// // Negative tests

class GetEnvFailureWithParam : public ::testing::TestWithParam {
  protected:
    int ret = -1;
    std::string env_var_value = "";

    void SetUp() override {
        env_var_value = GetParam();
        ret = setenv("UR_TEST_ENV_VAR", env_var_value.c_str(), 1);
        ASSERT_EQ(ret, 0);
    }

    void TearDown() override {
        ret = unsetenv("UR_TEST_ENV_VAR");
        ASSERT_EQ(ret, 0);
    }
};

class GetenvToMap : public GetEnvFailureWithParam {};

class GetenvToVec : public GetEnvFailureWithParam {};

INSTANTIATE_TEST_SUITE_P(
    WrongValuesForMap, GetenvToMap,
    testing::Values("value_1;value_2", "param_1:value_1,value_2;param_2:",
                    "param_1:value_1,value_2;:value_1", ",;:", ",;",
                    "rvrawerv)(*&)($@#93939854;;)", "simple", ",", ":", ";",
                    "value,value", "param:value;param:value",
                    "param,value;param:value", "param:value;param_2,value",
                    "param:value;param_2", "param:value;param_2;param_3",
                    "param:value:value_2", "param:value;:", "param:value;,"));

TEST_P(GetenvToMap, WrongEnvVarValues) {
    ASSERT_THROW(getenv_to_map("UR_TEST_ENV_VAR"), std::invalid_argument);
}

INSTANTIATE_TEST_SUITE_P(WrongValuesForVec, GetenvToVec,
                         testing::Values("value_1;value_2",
                                         "param_1:value_1,value_2;param_2", ",",
                                         ";", ":", ",,,",
                                         "rvrawerv)(*&)($@#93939854,,)",
                                         "value,,", "value;"));

TEST_P(GetenvToVec, WrongEnvVarValues) {
    ASSERT_THROW(getenv_to_vec("UR_TEST_ENV_VAR"), std::invalid_argument);
}

#if defined(_WIN32)
TEST(GetEnvExceptionWindows, HugeInput) {
    std::string huge_str;
    huge_str.reserve(1040);
    for (int i = 0; i < 103; ++i) {
        huge_str += "huuuuuuuge";
    }

    auto map = getenv_to_map("UR_TEST_ENV_VAR");
    ASSERT_FALSE(map.has_value());
    auto vec = getenv_to_vec("UR_TEST_ENV_VAR");
    ASSERT_FALSE(vec.has_value());
}
#endif