// Copyright 2021 Proyectos y Sistemas de Mantenimiento SL (eProsima).

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include "SystemInfo.hpp"

#ifdef __unix__

#   include <sys/file.h>

#   include <unistd.h>

#endif // ifdef __unix__

#ifdef _WIN32

#include <windows.h>

#else

#include <pwd.h>

#include <sys/stat.h>

#endif // _WIN32

#include <chrono>

#include <fstream>

#include <iomanip>

#include <mutex>

#include <string>

#include <thread>

#include <time.h>

#include <nlohmann/json.hpp>

#include <fastdds/dds/core/ReturnCode.hpp>

#include <fastdds/utils/IPFinder.hpp>

#include <utils/threading.hpp>

namespace eprosima {

using IPFinder = fastdds::rtps::IPFinder;

SystemInfo::SystemInfo()

{

    // From ctime(3) linux man page:

    // According to POSIX.1-2004, localtime() is required to behave as though tzset(3) was called, while

    // localtime_r() does not have this requirement. For portable code tzset(3) should be called before

    // localtime_r().

#if (_POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || \

    defined(_POSIX_SOURCE) || defined(__unix__)

    tzset();

#endif // if (_POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) ||

       // defined(_POSIX_SOURCE) || defined(__unix__)

    update_interfaces();

}

fastdds::dds::ReturnCode_t SystemInfo::get_env(

        const std::string& env_name,

        std::string& env_value)

{

    if (env_name.empty())

    {

        return fastdds::dds::RETCODE_BAD_PARAMETER;

    }

    // Try to read environment variable from file

    if (!environment_file_.empty() && fastdds::dds::RETCODE_OK == get_env(environment_file_, env_name, env_value))

    {

        return fastdds::dds::RETCODE_OK;

    }

    char* data;

#pragma warning(suppress:4996)

    data = getenv(env_name.c_str());

    if (nullptr != data)

    {

        env_value = data;

    }

    else

    {

        return fastdds::dds::RETCODE_NO_DATA;

    }

    return fastdds::dds::RETCODE_OK;

}

fastdds::dds::ReturnCode_t SystemInfo::get_env(

        const std::string& filename,

        const std::string& env_name,

        std::string& env_value)

{

    // Check that the file exists

    if (!SystemInfo::file_exists(filename))

    {

        return fastdds::dds::RETCODE_BAD_PARAMETER;

    }

    // Read json file

    std::ifstream file(filename);

    nlohmann::json file_content;

    try

    {

        file >> file_content;

    }

    catch (const nlohmann::json::exception&)

    {

        return fastdds::dds::RETCODE_ERROR;

    }

    try

    {

        env_value = file_content.at(env_name);

    }

    catch (const nlohmann::json::exception&)

    {

        return fastdds::dds::RETCODE_NO_DATA;

    }

    return fastdds::dds::RETCODE_OK;

}

fastdds::dds::ReturnCode_t SystemInfo::get_username(

        std::string& username)

{

#ifdef _WIN32

#define INFO_BUFFER_SIZE 32767

    char user[INFO_BUFFER_SIZE];

    DWORD bufCharCount = INFO_BUFFER_SIZE;

    if (!GetUserNameA(user, &bufCharCount))

    {

        return fastdds::dds::RETCODE_ERROR;

    }

    username = user;

    return fastdds::dds::RETCODE_OK;

#else

    uid_t user_id = geteuid();

    struct passwd* pwd = getpwuid(user_id);

    if (pwd != nullptr)

    {

        username = pwd->pw_name;

        if (!username.empty())

        {

            return fastdds::dds::RETCODE_OK;

        }

    }

    return fastdds::dds::RETCODE_ERROR;

#endif // _WIN32

}

bool SystemInfo::file_exists(

        const std::string& filename)

{

#ifdef _WIN32

    // modify for mingw

    DWORD fileAttributes = GetFileAttributesA(filename.c_str());

    if (fileAttributes == INVALID_FILE_ATTRIBUTES)

    {

        return false;

    }

    return !(fileAttributes & FILE_ATTRIBUTE_DIRECTORY);

#else

    struct stat s;

    return (stat(filename.c_str(), &s) == 0 && s.st_mode & S_IFREG);

#endif // ifdef _WIN32

}

bool SystemInfo::wait_for_file_closure(

        const std::string& filename,

        const std::chrono::seconds timeout)

{

    auto start = std::chrono::steady_clock::now();

#ifdef _MSC_VER

    std::ofstream os;

    do

    {

        // MSVC specific

        os.open(filename, std::ios::out | std::ios::app, _SH_DENYWR);

        if (!os.is_open()

                // If the file is lock-opened in an external editor do not hang

                && (std::chrono::steady_clock::now() - start) < timeout )

        {

            std::this_thread::yield();

        }

        else

        {

            break;

        }

    }

    while (true);

#elif __unix__

    int fd = open(filename.c_str(), O_WRONLY);

    while (flock(fd, LOCK_EX | LOCK_NB)

            // If the file is lock-opened in an external editor do not hang

            && (std::chrono::steady_clock::now() - start) < timeout )

    {

        std::this_thread::yield();

    }

    flock(fd, LOCK_UN | LOCK_NB);

    close(fd);

#else

    // plain wait

    std::this_thread::sleep_for(timeout);

    // avoid unused warning

    (void)start;

    (void)filename;

#endif // ifdef _MSC_VER

    return std::chrono::steady_clock::now() - start < timeout;

}

fastdds::dds::ReturnCode_t SystemInfo::set_environment_file()

{

    return SystemInfo::get_env(FASTDDS_ENVIRONMENT_FILE_ENV_VAR, SystemInfo::environment_file_);

}

const std::string& SystemInfo::get_environment_file()

{

    return SystemInfo::environment_file_;

}

FileWatchHandle SystemInfo::watch_file(

        std::string filename,

        std::function<void()> callback,

        const fastdds::rtps::ThreadSettings& watch_thread_config,

        const fastdds::rtps::ThreadSettings& callback_thread_config)

{

#if defined(_WIN32) || defined(__unix__)

    return FileWatchHandle (new filewatch::FileWatch<std::string>(filename,

                   [callback](const std::string& /*path*/, const filewatch::Event change_type)

                   {

                       switch (change_type)

                       {

                           case filewatch::Event::modified:

                               callback();

                               break;

                           default:

                               // No-op

                               break;

                       }

                   }, watch_thread_config, callback_thread_config));

#else // defined(_WIN32) || defined(__unix__)

    static_cast<void>(filename);

    static_cast<void>(callback);

    static_cast<void>(watch_thread_config);

    static_cast<void>(callback_thread_config);

    return FileWatchHandle();

#endif // defined(_WIN32) || defined(__unix__)

}

void SystemInfo::stop_watching_file(

        FileWatchHandle& handle)

{

#if defined(_WIN32) || defined(__unix__)

    handle.reset();

#endif // if defined(_WIN32) || defined(__unix__)

    static_cast<void>(handle);

}

std::string SystemInfo::get_timestamp(

        const char* format)

{

    std::stringstream stream;

    auto now = std::chrono::system_clock::now();

    std::time_t now_c = std::chrono::system_clock::to_time_t(now);

    std::chrono::system_clock::duration tp = now.time_since_epoch();

    tp -= std::chrono::duration_cast<std::chrono::seconds>(tp);

    auto ms = static_cast<unsigned>(tp / std::chrono::milliseconds(1));

#if defined(_WIN32)

    struct tm timeinfo;

    localtime_s(&timeinfo, &now_c);

    //#elif defined(__clang__) && !defined(std::put_time) // TODO arm64 doesn't seem to support std::put_time

    //    (void)now_c;

    //    (void)ms;

#elif (_POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || \

    defined(_POSIX_SOURCE) || defined(__unix__)

    std::tm timeinfo;

    localtime_r(&now_c, &timeinfo);

#else

    std::tm timeinfo = *localtime(&now_c);

#endif // if defined(_WIN32)

    stream << std::put_time(&timeinfo, format) << "." << std::setw(3) << std::setfill('0') << ms;

    return stream.str();

}

bool SystemInfo::update_interfaces()

{

    std::vector<IPFinder::info_IP> ifaces;

    auto ret = IPFinder::getIPs(&ifaces, true);

    if (ret)

    {

        std::lock_guard<std::mutex> lock(interfaces_mtx_);

        // Copy fetched interfaces to attribute

        interfaces_ = ifaces;

        // Set to true when successful, but not to false if lookup failed (may have been successfully cached before)

        cached_interfaces_ = true;

    }

    return ret;

}

bool SystemInfo::get_ips(

        std::vector<IPFinder::info_IP>& vec_name,

        bool return_loopback,

        bool force_lookup)

{

    if (force_lookup)

    {

        return IPFinder::getIPs(&vec_name, return_loopback);

    }

    else

    {

        {

            std::lock_guard<std::mutex> lock(interfaces_mtx_);

            if (cached_interfaces_)

            {

                for (const auto& iface : interfaces_)

                {

                    if (return_loopback || (iface.type != IPFinder::IPTYPE::IP4_LOCAL &&

                            iface.type != IPFinder::IPTYPE::IP6_LOCAL))

                    {

                        vec_name.push_back(iface);

                    }

                }

                return true;

            }

        }

        // Interfaces not cached, perform lookup

        return IPFinder::getIPs(&vec_name, return_loopback);

    }

}

std::string SystemInfo::environment_file_;

bool SystemInfo::cached_interfaces_;

std::vector<IPFinder::info_IP> SystemInfo::interfaces_;

std::mutex SystemInfo::interfaces_mtx_;

} // eprosima

// threading.hpp implementations

#ifdef _WIN32

#include "threading/threading_win32.ipp"

#include "thread_impl/thread_impl_win32.ipp"

#elif defined(__APPLE__)

#include "threading/threading_osx.ipp"

#include "thread_impl/thread_impl_pthread.ipp"

#elif defined(_POSIX_SOURCE) || defined(__QNXNTO__) || defined(__ANDROID__)

#include "threading/threading_pthread.ipp"

#include "thread_impl/thread_impl_pthread.ipp"

#else

#include "threading/threading_empty.ipp"

#endif // Platform selection