// 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 <map>

#include <gtest/gtest.h>

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

class GetEnvToMapWithParam
    : public ::testing::TestWithParam<
          std::map<std::string, std::vector<std::string>>> {
  protected:
    int ret = -1;
    std::map<std::string, std::vector<std::string>> 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 << ";";
            }
            env_var_value << item.first << ":";
            for (auto const &vec_value : item.second) {
                env_var_value << vec_value;
                if (&vec_value != &item.second.back()) {
                    env_var_value << ",";
                }
            }
        }

        ret = setenv("UR_TEST_ENV_VAR", env_var_value.str().c_str(), 1);
        ASSERT_EQ(ret, 0);
    }

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

using TestMaps = std::vector<std::map<std::string, std::vector<std::string>>>;

TestMaps getTestMaps() {
    TestMaps test_maps_vec;
    test_maps_vec.push_back({{"param_1", {"value_1", "value_2"}},
                             {"param_2", {"value_1", "value_3"}}});
    test_maps_vec.push_back(
        {{"param_1", {"value_1"}}, {"param_2", {"value_1"}}});
    test_maps_vec.push_back({{"param_1", {"value_1"}}});
    return test_maps_vec;
}

INSTANTIATE_TEST_SUITE_P(possibleEnvVarValues, GetEnvToMapWithParam,
                         testing::ValuesIn(getTestMaps()));

TEST_P(GetEnvToMapWithParam, MapValues) {
    auto map = getenv_to_map("UR_TEST_ENV_VAR");
    ASSERT_TRUE(map.has_value());
    for (auto &it : test_map) {
        ASSERT_EQ(map->at(it.first), test_map[it.first]);
    }
}

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

    auto vec = getenv_to_vec("UR_TEST_ENV_VAR");
    ASSERT_TRUE(vec.has_value());
    ASSERT_EQ(vec->front(), "value_1");

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

TEST(GetenvToVec, OneValueSpecialChars) {
    int ret = setenv("UR_TEST_ENV_VAR", "!@#$%^&*()_+-={}[]|\\\\\"<>?/`~", 1);
    ASSERT_EQ(ret, 0);

    auto vec = getenv_to_vec("UR_TEST_ENV_VAR");
    ASSERT_TRUE(vec.has_value());
    ASSERT_EQ(vec->front(), "!@#$%^&*()_+-={}[]|\\\\\"<>?/`~");

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

TEST(GetenvToVec, HugeInput) {
    std::string huge_str;
    huge_str.reserve(1024);
    for (int i = 0; i < 102; ++i) {
        huge_str += "huuuuuuuge";
    }

    int ret = setenv("UR_TEST_ENV_VAR", huge_str.c_str(), 1);
    ASSERT_EQ(ret, 0);

    auto vec = getenv_to_vec("UR_TEST_ENV_VAR");
    ASSERT_TRUE(vec.has_value());
    ASSERT_EQ(vec->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<std::string> 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<std::string> {
  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