/*
 * Copyright (C) 2019-2026 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
 */

#include "shared/source/compiler_interface/compiler_cache.h"

#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/casts.h"
#include "shared/source/helpers/file_io.h"
#include "shared/source/helpers/hash.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/helpers/path.h"
#include "shared/source/utilities/io_functions.h"

#include "elements_struct.h"
#include "os_inc.h"

#include <cstring>
#include <iomanip>
#include <mutex>
#include <sstream>
#include <string>

namespace NEO {

std::mutex CompilerCache::cacheAccessMtx;

const std::string CompilerCache::getCachedFileName(const HardwareInfo &hwInfo, const ArrayRef<const char> input,
                                                   const ArrayRef<const char> options, const ArrayRef<const char> internalOptions,
                                                   const ArrayRef<const char> specIds, const ArrayRef<const char> specValues,
                                                   const ArrayRef<const char> igcRevision, size_t igcLibSize, time_t igcLibMTime) {
    Hash hash;

    hash.update("----", 4);
    hash.update(&*igcRevision.begin(), igcRevision.size());
    hash.update(safePodCast<const char *>(&igcLibSize), sizeof(igcLibSize));
    hash.update(safePodCast<const char *>(&igcLibMTime), sizeof(igcLibMTime));

    hash.update("----", 4);
    hash.update(&*input.begin(), input.size());
    hash.update("----", 4);
    hash.update(&*options.begin(), options.size());
    hash.update("----", 4);
    hash.update(&*internalOptions.begin(), internalOptions.size());
    hash.update("----", 4);
    hash.update(&*specIds.begin(), specIds.size());
    hash.update(&*specValues.begin(), specValues.size());
    hash.update("----", 4);
    hash.update(safePodCast<const char *>(&hwInfo.platform), sizeof(hwInfo.platform));
    hash.update("----", 4);

    const auto featureTableHashStr = std::to_string(hwInfo.featureTable.asHash());
    hash.update(featureTableHashStr.c_str(), featureTableHashStr.length());
    hash.update("----", 4);

    const auto workaroundTableHashStr = std::to_string(hwInfo.workaroundTable.asHash());
    hash.update(workaroundTableHashStr.c_str(), workaroundTableHashStr.length());
    hash.update("----", 4);

    hash.update(reinterpret_cast<const char *>(&hwInfo.ipVersion), sizeof(uint32_t));

    auto res = hash.finish();
    std::stringstream stream;
    stream << std::setfill('0')
           << std::setw(sizeof(res) * 2)
           << std::hex
           << res;

    if (debugManager.flags.BinaryCacheTrace.get()) {
        std::string traceFilePath = config.cacheDir + PATH_SEPARATOR + stream.str() + ".trace";
        std::string inputFilePath = config.cacheDir + PATH_SEPARATOR + stream.str() + ".input";
        std::lock_guard<std::mutex> lock(cacheAccessMtx);
        auto fp = NEO::IoFunctions::fopenPtr(traceFilePath.c_str(), "w");
        if (fp) {
            NEO::IoFunctions::fprintf(fp, "---- igcRevision ----\n");
            NEO::IoFunctions::fprintf(fp, "%s\n", &*igcRevision.begin());
            NEO::IoFunctions::fprintf(fp, "  libSize=%llu\n", igcLibSize);
            NEO::IoFunctions::fprintf(fp, "  libMTime=%llu\n", igcLibMTime);
            NEO::IoFunctions::fprintf(fp, "---- input ----\n");
            NEO::IoFunctions::fprintf(fp, "<%s>\n", inputFilePath.c_str());
            NEO::IoFunctions::fprintf(fp, "---- options ----\n");
            NEO::IoFunctions::fprintf(fp, "%s\n", &*options.begin());
            NEO::IoFunctions::fprintf(fp, "---- internal options ----\n");
            NEO::IoFunctions::fprintf(fp, "%s\n", &*internalOptions.begin());
            NEO::IoFunctions::fprintf(fp, "---- specialization constants ----\n");
            NEO::IoFunctions::fprintf(fp, "specIds=");
            for (size_t idx = 0; idx < specIds.size(); idx++) {
                NEO::IoFunctions::fprintf(fp, "%02x", specIds[idx]);
            }
            NEO::IoFunctions::fprintf(fp, "\n");
            NEO::IoFunctions::fprintf(fp, "specValues=");
            for (size_t idx = 0; idx < specValues.size(); idx++) {
                NEO::IoFunctions::fprintf(fp, "%02x", specValues[idx]);
            }
            NEO::IoFunctions::fprintf(fp, "\n");

            NEO::IoFunctions::fprintf(fp, "---- platform ----\n");
            NEO::IoFunctions::fprintf(fp, "  eProductFamily=%d\n", hwInfo.platform.eProductFamily);
            NEO::IoFunctions::fprintf(fp, "  ePCHProductFamily=%d\n", hwInfo.platform.ePCHProductFamily);
            NEO::IoFunctions::fprintf(fp, "  eDisplayCoreFamily=%d\n", hwInfo.platform.eDisplayCoreFamily);
            NEO::IoFunctions::fprintf(fp, "  eRenderCoreFamily=%d\n", hwInfo.platform.eRenderCoreFamily);
            NEO::IoFunctions::fprintf(fp, "  ePlatformType=%d\n", hwInfo.platform.ePlatformType);
            NEO::IoFunctions::fprintf(fp, "  usDeviceID=%d\n", hwInfo.platform.usDeviceID);
            NEO::IoFunctions::fprintf(fp, "  usRevId=%d\n", hwInfo.platform.usRevId);
            NEO::IoFunctions::fprintf(fp, "  usDeviceID_PCH=%d\n", hwInfo.platform.usDeviceID_PCH);
            NEO::IoFunctions::fprintf(fp, "  usRevId_PCH=%d\n", hwInfo.platform.usRevId_PCH);
            NEO::IoFunctions::fprintf(fp, "  eGTType=%d\n", hwInfo.platform.eGTType);

            NEO::IoFunctions::fprintf(fp, "---- feature table ----\n");
            auto featureTable = safePodCast<const char *>(&hwInfo.featureTable.packed);
            for (size_t idx = 0; idx < sizeof(hwInfo.featureTable.packed); idx++) {
                NEO::IoFunctions::fprintf(fp, "%02x.", (uint8_t)(featureTable[idx]));
            }
            NEO::IoFunctions::fprintf(fp, "\n");

            NEO::IoFunctions::fprintf(fp, "---- workaround table ----\n");
            auto workaroundTable = reinterpret_cast<const char *>(&hwInfo.workaroundTable);
            for (size_t idx = 0; idx < sizeof(hwInfo.workaroundTable); idx++) {
                NEO::IoFunctions::fprintf(fp, "%02x.", (uint8_t)(workaroundTable[idx]));
            }
            NEO::IoFunctions::fprintf(fp, "\n");

            NEO::IoFunctions::fclosePtr(fp);
        }
        fp = NEO::IoFunctions::fopenPtr(inputFilePath.c_str(), "w");
        if (fp) {
            NEO::IoFunctions::fwritePtr(&*input.begin(), input.size(), 1, fp);
            NEO::IoFunctions::fclosePtr(fp);
        }
    }

    return stream.str();
}

CompilerCache::CompilerCache(const CompilerCacheConfig &cacheConfig)
    : config(cacheConfig) {};

std::string CompilerCache::getCachedFilePath(const std::string &cacheFile) {
    std::string path = config.cacheDir;
    for (int i = 0; i < maxCacheDepth; i++) {
        path = joinPath(path, std::string(1, cacheFile[i]));
    }
    path = joinPath(path, cacheFile);

    return path;
}

std::unique_ptr<char[]> CompilerCache::loadCachedBinary(const std::string &kernelFileHash, size_t &cachedBinarySize) {
    auto cacheFilename = kernelFileHash + config.cacheFileExtension;
    if (cacheFilename.length() < maxCacheDepth + config.cacheFileExtension.length()) {
        PRINT_STRING(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "[Cache failure]: Load cached binary failed - cache file name is too short!\n");
        cachedBinarySize = 0;
        return nullptr;
    }

    std::string filePath = getCachedFilePath(cacheFilename);
    auto data = NEO::loadDataFromFile(filePath.c_str(), cachedBinarySize);

    if (cachedBinarySize == 0) {
        if (config.statsEnabled) {
            updateAllStats(cacheFilename, false);
        }
        return nullptr;
    }

    if (config.statsEnabled) {
        updateAllStats(cacheFilename, true);
    }

    return data;
}

bool CompilerCache::getCachedFiles(std::vector<ElementsStruct> &cacheFiles) {
    cacheFiles.clear();

    auto filterFunction = [](const std::string_view &path) {
        return path.find(".cl_cache") != path.npos || path.find(".ocloc_cache") != path.npos || path.find(".l0_cache") != path.npos;
    };

    if (!getFiles(config.cacheDir, filterFunction, cacheFiles)) {
        return false;
    }

    std::sort(cacheFiles.begin(), cacheFiles.end(), [this](const ElementsStruct &a, const ElementsStruct &b) {
        return this->compareByLastAccessTime(a, b);
    });

    return true;
}

bool CompilerCache::updateAllStats(const std::string &fileName, bool hit) {
    std::string path = config.cacheDir;
    for (int i = 0; i <= maxCacheDepth; i++) {
        if (!updateStats(joinPath(path, "stats"), hit)) {
            return false;
        }
        path = joinPath(path, std::string(1, fileName[i]));
    }

    return true;
}

bool CompilerCache::showStats(bool verbose, std::string &output) {
    std::stringstream ss;
    ss << "Compiler cache stats:\n\n";

    auto appendStats = [](std::stringstream &ss, const std::string &statsPath, const CacheStats &cacheStats) {
        auto lastSep = statsPath.rfind(PATH_SEPARATOR);
        ss << "Cache directory: " << (lastSep != std::string::npos ? statsPath.substr(0, lastSep + 1) : statsPath) << "\n";
        ss << "Version    Hits    Misses    Hit Rate\n";
        ss << std::left << std::setw(9) << cacheStats.version << " "
           << std::setw(7) << cacheStats.hits << " "
           << std::setw(9) << cacheStats.misses << " "
           << std::fixed << std::setprecision(2)
           << (cacheStats.hits + cacheStats.misses > 0
                   ? static_cast<double>(cacheStats.hits) / (cacheStats.hits + cacheStats.misses) * 100.0
                   : 0.0)
           << "%\n\n";
    };

    if (!verbose) {
        std::string statsPath = joinPath(config.cacheDir, "stats");

        CacheStats cacheStats{};
        auto result = readStatsFromFile(statsPath, cacheStats);
        if (result != StatsResult::success) {
            if (result == StatsResult::notFound) {
                ss << "No stats found in cache directory.\n";
                output = ss.str();
                return true;
            }
            return false;
        }

        appendStats(ss, statsPath, cacheStats);
        output = ss.str();
        return true;
    }

    std::vector<ElementsStruct> statsFiles;
    if (!getFiles(config.cacheDir, isStatsFile, statsFiles)) {
        return false;
    }

    if (statsFiles.empty()) {
        ss << "No stats found in cache directories.\n";
        output = ss.str();
        return true;
    }

    for (const auto &statsFile : statsFiles) {
        CacheStats cacheStats{};
        if (readStatsFromFile(statsFile.path, cacheStats) != StatsResult::success) {
            return false;
        }

        appendStats(ss, statsFile.path, cacheStats);
    }

    output = ss.str();
    return true;
}

bool CompilerCache::isStatsFile(const std::string_view &path) {
    auto lastSep = path.rfind(PATH_SEPARATOR);
    auto basename = (lastSep != std::string_view::npos) ? path.substr(lastSep + 1) : path;
    return basename == "stats";
}

CompilerCache::StatsResult CompilerCache::zeroStats() {
    if (config.cacheDir.empty()) {
        return StatsResult::notFound;
    }

    std::vector<ElementsStruct> statsFiles;
    if (!getFiles(config.cacheDir, isStatsFile, statsFiles)) {
        return StatsResult::error;
    }

    if (statsFiles.empty()) {
        return StatsResult::notFound;
    }

    CacheStats cacheStats{0, 0, CompilerCache::cacheVersion};
    for (const auto &statsFile : statsFiles) {
        if (!writeStatsToFile(statsFile.path, cacheStats)) {
            return StatsResult::error;
        }
    }

    return StatsResult::success;
}

bool CompilerCache::clear() {
    return clearDirectoryContents(config.cacheDir);
}

} // namespace NEO
