/******************************************************************************
 *
 * Project:  GDAL
 * Purpose:  Return the path of the "gdal" binary
 * Author:   Even Rouault <even dot rouault at spatialys.com>
 *
 ******************************************************************************
 * Copyright (c) 2025, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "cpl_config.h"

#if HAVE_DL_ITERATE_PHDR
#if !defined(_GNU_SOURCE)
#define _GNU_SOURCE
#endif
#include <link.h>

#elif defined(__MACH__) && defined(__APPLE__)
#include <mach-o/dyld.h>

#endif

#include "cpl_spawn.h"
#include "cpl_vsi_virtual.h"
#include "gdal.h"
#include "gdalgetgdalpath.h"

#include <cassert>

/************************************************************************/
/*                   GDALGetGDALPathDLIterateCbk()                      */
/************************************************************************/

#if HAVE_DL_ITERATE_PHDR && !defined(STATIC_BUILD)

static int GDALGetGDALPathDLIterateCbk(struct dl_phdr_info *info,
                                       size_t /*size*/, void *data)
{
    if (info->dlpi_name && strstr(info->dlpi_name, "/libgdal.so."))
    {
        *static_cast<std::string *>(data) = info->dlpi_name;
        return 1;
    }
    return 0;  // continue iteration
}

#endif

/************************************************************************/
/*                         GDALGetGDALPath()                            */
/************************************************************************/

/** Return the path of the "gdal" binary, or an empty string if it cannot be
 * found.
 *
 * The GDAL_PATH configuration option may be set to point to the directory where
 * the GDAL binary is located.
 */
std::string GDALGetGDALPath()
{
    const char *pszGDAL_PATH = CPLGetConfigOption("GDAL_PATH", nullptr);
    if (pszGDAL_PATH)
    {
        VSIStatBufL sStat;
        for (const char *pszProgramName : {"gdal"
#ifdef _WIN32
                                           ,
                                           "gdal.exe"
#endif
             })
        {
            std::string osPath =
                CPLFormFilenameSafe(pszGDAL_PATH, pszProgramName, nullptr);
            if (VSIStatL(osPath.c_str(), &sStat) == 0)
                return osPath;
        }
        CPLError(CE_Failure, CPLE_AppDefined,
                 "No 'gdal' binary can be found in '%s'", pszGDAL_PATH);
        return std::string();
    }

    constexpr int MAXPATH_SIZE = 4096;
    std::string osPath;
    osPath.resize(MAXPATH_SIZE);
    if (CPLGetExecPath(osPath.data(), MAXPATH_SIZE))
    {
        osPath.resize(strlen(osPath.c_str()));
        if (!cpl::ends_with(osPath, "/gdal") &&
            !cpl::ends_with(osPath, "\\gdal") &&
            !cpl::ends_with(osPath, "\\gdal.exe"))
        {
            osPath.clear();
#if (HAVE_DL_ITERATE_PHDR || (defined(__MACH__) && defined(__APPLE__))) &&     \
    !defined(STATIC_BUILD)
            std::string osGDALLib;
#if HAVE_DL_ITERATE_PHDR
            dl_iterate_phdr(GDALGetGDALPathDLIterateCbk, &osGDALLib);
#else
            const uint32_t imageCount = _dyld_image_count();
            for (uint32_t i = 0; i < imageCount; ++i)
            {
                const char *imageName = _dyld_get_image_name(i);
                if (imageName && strstr(imageName, "/libgdal."))
                {
                    osGDALLib = imageName;
                    break;
                }
            }
#endif
            if (!osGDALLib.empty() && osGDALLib[0] == '/')
            {
                const std::string osPathOfGDALLib =
                    CPLGetDirnameSafe(osGDALLib.c_str());
                std::string osBinFilename = CPLFormFilenameSafe(
                    CPLGetDirnameSafe(osPathOfGDALLib.c_str()).c_str(),
                    "bin/gdal", nullptr);
                VSIStatBufL sStat;
                if (VSIStatL(osBinFilename.c_str(), &sStat) == 0)
                {
                    // Case if osGDALLib=/usr/lib/libgdal.so.xxx
                    osPath = std::move(osBinFilename);
                }
                else
                {
                    osBinFilename = CPLFormFilenameSafe(
                        CPLGetDirnameSafe(
                            CPLGetDirnameSafe(osPathOfGDALLib.c_str()).c_str())
                            .c_str(),
                        "bin/gdal", nullptr);
                    if (VSIStatL(osBinFilename.c_str(), &sStat) == 0)
                    {
                        // Case if pszLibName=/usr/lib/libgdal.so.xxx
                        osPath = std::move(osBinFilename);
                    }
                    else
                    {
                        osBinFilename = CPLFormFilenameSafe(
                            osPathOfGDALLib.c_str(), "apps/gdal", nullptr);
                        if (VSIStatL(osBinFilename.c_str(), &sStat) == 0)
                        {
                            // Case if pszLibName=/usr/lib/yyyyy/libgdal.so.xxx
                            osPath = std::move(osBinFilename);
                        }
                        else
                        {
                            osBinFilename = CPLFormFilenameSafe(
                                osPathOfGDALLib.c_str(), "apps/gdal", nullptr);
                            if (VSIStatL(osBinFilename.c_str(), &sStat) == 0)
                            {
                                // Case if pszLibName=/path/to/build_dir/libgdal.so.xxx
                                osPath = std::move(osBinFilename);
                            }
                        }
                    }
                }
            }
#endif
        }
        if (!osPath.empty())
        {
            CPLDebug("GDAL", "gdal binary found at '%s'", osPath.c_str());
        }
    }
    else
    {
        osPath.clear();
    }
    if (osPath.empty())
    {
        // Try to locate from the path
#ifdef _WIN32
        osPath = "gdal.exe";
#else
        osPath = "gdal";
#endif
    }

    const char *const apszArgv[] = {osPath.c_str(), "--version", nullptr};
    const std::string osTmpFilenameVersion =
        VSIMemGenerateHiddenFilename(nullptr);
    auto fpOut = std::unique_ptr<VSIVirtualHandle>(
        VSIFOpenL(osTmpFilenameVersion.c_str(), "wb+"));
    VSIUnlink(osTmpFilenameVersion.c_str());
    CPLAssert(fpOut);
    CPLSpawn(apszArgv, nullptr, fpOut.get(), /* bDisplayErr = */ false);
    const auto nPos = fpOut->Tell();
    std::string osVersion;
    osVersion.resize(128);
    if (nPos > 0 && nPos < osVersion.size())
    {
        osVersion.resize(static_cast<size_t>(nPos));
        fpOut->Seek(0, SEEK_SET);
        fpOut->Read(osVersion.data(), 1, osVersion.size());
        for (const char ch : {'\n', '\r'})
        {
            if (!osVersion.empty() && osVersion.back() == ch)
            {
                osVersion.pop_back();
            }
        }
        if (osVersion == GDALVersionInfo(""))
        {
            return osPath;
        }
        else
        {
            CPLError(CE_Failure, CPLE_AppDefined,
                     "'%s --version' returned '%s', whereas '%s' "
                     "expected. Make sure the gdal binary corresponding "
                     "to the version of the libgdal of the current "
                     "process is in the PATH environment variable",
                     osPath.c_str(), osVersion.c_str(), GDALVersionInfo(""));
        }
    }
    else
    {
        CPLError(CE_Failure, CPLE_AppDefined,
                 "Could not find 'gdal' binary. Make sure it is in the "
                 "PATH environment variable.");
    }
    return std::string();
}