/**
 * Copyright (c) 2025 Huawei Technologies Co., Ltd.
 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
 * CANN Open Software License Agreement Version 2.0 (the "License").
 * Please refer to the License for details. You may not use this file except in compliance with the License.
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
 * See LICENSE in the root of the software repository for the full text of the License.
 */
#include "acl_rt_impl_base.h"
#include <mutex>
#include <string>
#include <fstream>
#include <sstream>
#include <map>
#include <unordered_set>
#include <string>
#include "runtime/dev.h"
#include "acl_rt_impl.h"
#include "acl/acl_base.h"
#include "common/log_inner.h"
#include "common/error_codes_inner.h"
#include "platform/platform_info.h"
#include "runtime/config.h"

namespace {
std::mutex aclSocVersionMutex;
std::string aclSocVersion;
constexpr size_t SOC_VERSION_LEN = 128U;
std::recursive_mutex aclInitMutex;
uint64_t aclInitRefCount = 0;
std::string aclConfigStr;
} // namespace

namespace acl {
constexpr int32_t MODULE_TYPE_VECTOR_CORE = 7;
constexpr int32_t MODULE_TYPE_AICORE = 4;
constexpr int32_t INFO_TYPE_CORE_NUM = 3;
std::mutex g_platformInfoInitMutex;
std::unordered_set<int32_t> g_platformInfoInitSet;

aclError UpdatePlatformInfoWithDevice(int32_t deviceId)
{
#ifdef __GNUC__
    // init platform info
    const char* socName = aclrtGetSocNameImpl();
    if (socName == nullptr) {
        ACL_LOG_ERROR("Init SocVersion failed");
        return ACL_ERROR_INTERNAL_ERROR;
    }
    const std::string socVersion(socName);
    if (fe::PlatformInfoManager::GeInstance().InitRuntimePlatformInfos(socVersion) != 0U) {
        ACL_LOG_WARN(
            "[Init][PlatformInfo]init runtime platform info unsuccessfully, SocVersion = %s", socVersion.c_str());
        return ACL_ERROR_INTERNAL_ERROR;
    }

    const std::unique_lock<std::mutex> lk(g_platformInfoInitMutex);
    if (g_platformInfoInitSet.count(deviceId) > 0U) {
        return ACL_SUCCESS;
    }

    uint32_t aicCnt = 0U;
    auto rtErr = rtGetAiCoreCount(&aicCnt);
    if (rtErr != RT_ERROR_NONE) {
        ACL_LOG_WARN("get aicore count unsuccessfully, runtime result = %d", static_cast<int32_t>(rtErr));
        return ACL_GET_ERRCODE_RTS(rtErr);
    }

    int64_t vecCoreCnt = 0U;
    // some chips has no vector core
    rtErr = rtGetDeviceInfo(static_cast<uint32_t>(deviceId), MODULE_TYPE_VECTOR_CORE, INFO_TYPE_CORE_NUM, &vecCoreCnt);
    if (rtErr != RT_ERROR_NONE) {
        ACL_LOG_WARN("get vector core count unsuccessfully, runtime result = %d", static_cast<int32_t>(rtErr));
        return ACL_GET_ERRCODE_RTS(rtErr);
    }

    int64_t cubeCoreCnt = 0U;
    rtErr = rtGetDeviceInfo(static_cast<uint32_t>(deviceId), MODULE_TYPE_AICORE, INFO_TYPE_CUBE_NUM, &cubeCoreCnt);
    if (rtErr != RT_ERROR_NONE) {
        ACL_LOG_WARN("get cube core count unsuccessfully, runtime result = %d", static_cast<int32_t>(rtErr));
        return ACL_GET_ERRCODE_RTS(rtErr);
    }

    fe::PlatFormInfos platformInfos;
    uint32_t platformRet =
        fe::PlatformInfoManager::GeInstance().GetRuntimePlatformInfosByDevice(deviceId, platformInfos);
    if (platformRet != 0U) {
        ACL_LOG_WARN("get runtime platformInfos by device unsuccessfully, deviceId = %d", deviceId);
        return ACL_ERROR_INTERNAL_ERROR;
    }

    const std::string socInfoKey = "SoCInfo";
    const std::string aicCntKey = "ai_core_cnt";
    const std::string vecCoreCntKey = "vector_core_cnt";
    const std::string cubeCoreCntKey = "cube_core_cnt";
    std::map<std::string, std::string> res;
    if (!platformInfos.GetPlatformResWithLock(socInfoKey, res)) {
        ACL_LOG_WARN("unable to get platform result");
        return ACL_ERROR_INTERNAL_ERROR;
    }

    res[aicCntKey] = std::to_string(aicCnt);
    res[vecCoreCntKey] = std::to_string(vecCoreCnt);
    res[cubeCoreCntKey] = std::to_string(cubeCoreCnt);
    platformInfos.SetPlatformResWithLock(socInfoKey, res);
    platformRet = fe::PlatformInfoManager::GeInstance().UpdateRuntimePlatformInfosByDevice(deviceId, platformInfos);
    if (platformRet != 0U) {
        ACL_LOG_WARN("update runtime platformInfos by device unsuccessfully, deviceId = %d", deviceId);
        return ACL_ERROR_INTERNAL_ERROR;
    }
    (void)g_platformInfoInitSet.emplace(deviceId);
    ACL_LOG_INFO(
        "Successfully to UpdatePlatformInfoWithDevice, deviceId = %d, aicCnt = %u, vecCoreCnt = %ld, "
        "cubeCoreCnt = %ld",
        deviceId, aicCnt, vecCoreCnt, cubeCoreCnt);
#endif
    return ACL_SUCCESS;
}

aclError InitSocVersion()
{
    const std::unique_lock<std::mutex> lk(aclSocVersionMutex);
    if (aclSocVersion.empty()) {
        // get socVersion
        char_t socVersion[SOC_VERSION_LEN] = {};
        const auto rtErr = rtGetSocVersion(socVersion, static_cast<uint32_t>(sizeof(socVersion)));
        if (rtErr != RT_ERROR_NONE) {
            ACL_LOG_INFO("Cannot get soc version, runtime errorCode is %d", static_cast<int32_t>(rtErr));
            return ACL_GET_ERRCODE_RTS(rtErr);
        }
        aclSocVersion = std::string(socVersion);
    }
    ACL_LOG_INFO("get SocVersion success, SocVersion = %s", aclSocVersion.c_str());
    return ACL_SUCCESS;
}

const std::string& GetSocVersion()
{
    ACL_LOG_INFO("socVersion is %s", aclSocVersion.c_str());
    return aclSocVersion;
}

bool GetAclInitFlag() { return aclInitRefCount > 0UL; }

uint64_t& GetAclInitRefCount() { return aclInitRefCount; }

std::recursive_mutex& GetAclInitMutex() { return aclInitMutex; }

std::string& GetConfigPathStr() { return aclConfigStr; }

void SetConfigPathStr(std::string& configStr) { aclConfigStr = configStr; }

aclError GetStrFromConfigPath(const char* configPath, std::string& configStr)
{
    // 文件路径为空，按照空文件处理
    if (configPath != nullptr && strlen(configPath) != 0UL) {
        char_t realPath[MMPA_MAX_PATH] = {};
        if (mmRealPath(configPath, realPath, MMPA_MAX_PATH) != EN_OK) {
            const auto formatErrMsg = acl::AclGetErrorFormatMessage(mmGetErrorCode());
            acl::AclErrorLogManager::ReportInputError(
                acl::INVALID_PATH_MSG, std::vector<const char*>({"path", "reason"}),
                std::vector<const char*>({configPath, formatErrMsg.c_str()}));
            ACL_LOG_ERROR("Invalid file: %s", configPath);
            return ACL_ERROR_INVALID_FILE;
        }
        std::ifstream file(realPath, std::ios::binary);
        if (!file.is_open()) {
            acl::AclErrorLogManager::ReportInputError(
                acl::INVALID_PATH_MSG, std::vector<const char*>({"path", "reason"}),
                std::vector<const char*>({configPath, "file open failed"}));
            ACL_LOG_ERROR("Failed to open file: %s", configPath);
            return ACL_ERROR_INVALID_FILE;
        }

        std::stringstream buffer;
        buffer << file.rdbuf();
        configStr = buffer.str();
        file.close(); // 显式关闭文件
    }
    return ACL_SUCCESS;
}
} // namespace acl

#ifdef __cplusplus
extern "C" {
#endif

const char* aclrtGetSocNameImpl()
{
    ACL_LOG_INFO("start to execute aclrtGetSocName.");
    // get socVersion
    const auto ret = acl::InitSocVersion();
    if (ret != ACL_SUCCESS) {
        ACL_LOG_INFO("Cannot init soc version, errorCode = %d", ret);
        return nullptr;
    }
    ACL_LOG_INFO("execute aclrtGetSocName successfully");
    return aclSocVersion.c_str();
}

aclError aclrtGetVersionImpl(int32_t* majorVersion, int32_t* minorVersion, int32_t* patchVersion)
{
    ACL_LOG_INFO("start to execute aclrtGetVersion.");
    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(majorVersion);
    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(minorVersion);
    ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(patchVersion);

    // Acl version is (*majorVersion).(*minorVersion).(*patchVersion)
    *majorVersion = ACL_MAJOR_VERSION;
    *minorVersion = ACL_MINOR_VERSION;
    *patchVersion = ACL_PATCH_VERSION;
    ACL_LOG_INFO("acl version is %d.%d.%d", *majorVersion, *minorVersion, *patchVersion);

    return ACL_SUCCESS;
}
#ifdef __cplusplus
}
#endif