#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Setup script for GDAL Python bindings.
# Inspired by psycopg2 setup.py file
# http://www.initd.org/tracker/psycopg/browser/psycopg2/trunk/setup.py
# Howard Butler hobu.inc@gmail.com


gdal_version = "3.6.0"

import os
import sys
from glob import glob

from setuptools import Extension, find_packages, setup
from setuptools.command.build_ext import build_ext

# If CXX is defined in the environment, it will be used to link the .so
# but setuptools will be confused if it is made of several words like 'ccache g++'
# and it will try to use only the first word.
# See https://lists.osgeo.org/pipermail/gdal-dev/2016-July/044686.html
# Note: in general when doing "make", CXX will not be defined, unless it is defined as
# an environment variable, but in that case it is the value of GDALmake.opt that
# will be set, not the one from the environment that started "make" !
# If no CXX environment variable is defined, then the value of the CXX variable
# in GDALmake.opt will not be set as an environment variable
if "CXX" in os.environ and os.environ["CXX"].strip().find(" ") >= 0:
    if (
        os.environ["CXX"].strip().startswith("ccache ")
        and os.environ["CXX"].strip()[len("ccache ") :].find(" ") < 0
    ):
        os.environ["CXX"] = os.environ["CXX"].strip()[len("ccache ") :]
    else:
        print(
            'WARNING: "CXX=%s" was defined in the environment and contains more than one word. Unsetting it since that is incompatible of setuptools'
            % os.environ["CXX"]
        )
        del os.environ["CXX"]
if "CC" in os.environ and os.environ["CC"].strip().find(" ") >= 0:
    if (
        os.environ["CC"].strip().startswith("ccache ")
        and os.environ["CC"].strip()[len("ccache ") :].find(" ") < 0
    ):
        os.environ["CC"] = os.environ["CC"].strip()[len("ccache ") :]
    else:
        print(
            'WARNING: "CC=%s" was defined in the environment and contains more than one word. Unsetting it since that is incompatible of setuptools'
            % os.environ["CC"]
        )
        del os.environ["CC"]

# ---------------------------------------------------------------------------
# Switches
# ---------------------------------------------------------------------------

HAVE_NUMPY = False
BUILD_FOR_CHEESESHOP = False
GNM_ENABLED = True

# ---------------------------------------------------------------------------
# Default build options
# (may be overridden with setup.cfg or command line switches).
# ---------------------------------------------------------------------------

include_dirs = [
    "../../port",
    "../../gcore",
    "../../alg",
    "../../ogr/",
    "../../ogr/ogrsf_frmts",
    "../../gnm",
    "../../apps",
]
library_dirs = ["../../.libs", "../../"]
libraries = ["gdal"]


# ---------------------------------------------------------------------------
# Helper Functions
# ---------------------------------------------------------------------------

# Function to find numpy's include directory
def get_numpy_include():
    if HAVE_NUMPY:
        return numpy.get_include()
    return "."


# ---------------------------------------------------------------------------
# Imports
# ---------------------------------------------------------------------------

try:
    import numpy

    HAVE_NUMPY = True
    # check version
    numpy_major = numpy.__version__.split(".")[0]
    if int(numpy_major) < 1:
        print("numpy version must be > 1.0.0")
        HAVE_NUMPY = False
    else:
        #  print ('numpy include', get_numpy_include())
        if get_numpy_include() == ".":
            print(
                "WARNING: numpy headers were not found!  Array support will not be enabled"
            )
            HAVE_NUMPY = False
except ImportError:
    print("WARNING: numpy not available!  Array support will not be enabled")
    pass


class gdal_config_error(Exception):
    pass


def fetch_config(option, gdal_config="gdal-config"):

    command = gdal_config + " --%s" % option

    import subprocess

    command, args = command.split()[0], command.split()[1]
    try:
        p = subprocess.Popen([command, args], stdout=subprocess.PIPE)
    except OSError:
        e = sys.exc_info()[1]
        raise gdal_config_error(e)
    r = p.stdout.readline().decode("ascii").strip()
    p.stdout.close()
    p.wait()

    return r


def supports_cxx11(compiler, compiler_flag=None):
    ret = False
    with open("gdal_python_cxx11_test.cpp", "wt") as f:
        f.write(
            """
#if __cplusplus < 201103L
#error "C++11 required"
#endif
int main () { return 0; }"""
        )
        f.close()
        extra_postargs = None
        if compiler_flag:
            extra_postargs = [compiler_flag]

        if os.name == "posix":
            # Redirect stderr to /dev/null to hide any error messages
            # from the compiler.
            devnull = open(os.devnull, "w")
            oldstderr = os.dup(sys.stderr.fileno())
            os.dup2(devnull.fileno(), sys.stderr.fileno())
            try:
                compiler.compile([f.name], extra_postargs=extra_postargs)
                ret = True
            except Exception:
                pass
            os.dup2(oldstderr, sys.stderr.fileno())
            devnull.close()
        else:
            try:
                compiler.compile([f.name], extra_postargs=extra_postargs)
                ret = True
            except Exception:
                pass
    os.unlink("gdal_python_cxx11_test.cpp")
    if os.path.exists("gdal_python_cxx11_test.o"):
        os.unlink("gdal_python_cxx11_test.o")
    return ret


###Based on: https://stackoverflow.com/questions/28641408/how-to-tell-which-compiler-will-be-invoked-for-a-python-c-extension-in-setuptool
def has_flag(compiler, flagname):
    import tempfile

    with tempfile.NamedTemporaryFile("w", suffix=".cpp") as f:
        f.write("int main (int argc, char **argv) { return 0; }")
        try:
            compiler.compile([f.name], extra_postargs=[flagname])
        except Exception:
            return False
    return True


class gdal_ext(build_ext):

    GDAL_CONFIG = "gdal-config"
    user_options = build_ext.user_options[:]
    user_options.extend(
        [
            (
                "gdal-config=",
                None,
                "The name of the gdal-config binary and/or a full path to it",
            ),
        ]
    )

    def initialize_options(self):
        build_ext.initialize_options(self)

        self.numpy_include_dir = get_numpy_include()
        self.gdaldir = None
        self.gdal_config = self.GDAL_CONFIG
        self.extra_cflags = []
        self.parallel = True  # Python 3.5 only

    def get_compiler(self):
        return self.compiler or ("msvc" if os.name == "nt" else "unix")

    def get_gdal_config(self, option):
        try:
            return fetch_config(option, gdal_config=self.gdal_config)
        except gdal_config_error:
            # If an error is thrown, it is possibly because
            # the gdal-config location given in setup.cfg is
            # incorrect, or possibly the default -- ../../apps/gdal-config
            # We'll try to use the gdal-config that might be on the path.
            try:
                return fetch_config(option)
            except gdal_config_error:
                msg = "Could not find gdal-config. Make sure you have installed the GDAL native library and development headers."
                import sys
                import traceback

                traceback_string = "".join(traceback.format_exception(*sys.exc_info()))
                raise gdal_config_error(traceback_string + "\n" + msg)

    def build_extensions(self):

        # Add a -std=c++11 or similar flag if needed
        ct = self.compiler.compiler_type
        if ct == "unix" and not supports_cxx11(self.compiler):
            cxx11_flag = None
            if supports_cxx11(self.compiler, "-std=c++11"):
                cxx11_flag = "-std=c++11"
            if cxx11_flag:
                for ext in self.extensions:
                    # gdalconst builds as a .c file
                    if ext.name != "osgeo._gdalconst":
                        ext.extra_compile_args += [cxx11_flag]

                    # Adding arch flags here if OS X and compiler is clang
                    if sys.platform == "darwin" and [
                        int(x) for x in os.uname()[2].split(".")
                    ] >= [11, 0, 0]:
                        # since MacOS X 10.9, clang no longer accepts -mno-fused-madd
                        # extra_compile_args.append('-Qunused-arguments')
                        clang_flag = "-Wno-error=unused-command-line-argument-hard-error-in-future"
                        if has_flag(self.compiler, clang_flag):
                            ext.extra_compile_args += [clang_flag]
                        else:
                            clang_flag = "-Wno-error=unused-command-line-argument"
                            if has_flag(self.compiler, clang_flag):
                                ext.extra_compile_args += [clang_flag]

        build_ext.build_extensions(self)

    def finalize_options(self):
        global include_dirs, library_dirs

        if self.include_dirs is None:
            self.include_dirs = include_dirs
        # Needed on recent MacOSX
        elif isinstance(self.include_dirs, str) and sys.platform == "darwin":
            self.include_dirs += ":" + ":".join(include_dirs)
        if self.library_dirs is None:
            self.library_dirs = library_dirs
        # Needed on recent MacOSX
        elif isinstance(self.library_dirs, str) and sys.platform == "darwin":
            self.library_dirs += ":" + ":".join(library_dirs)
        if self.libraries is None:
            if self.get_compiler() == "msvc":
                libraries.remove("gdal")
                libraries.append("gdal_i")
            self.libraries = libraries

        build_ext.finalize_options(self)

        self.include_dirs.append(self.numpy_include_dir)

        if self.get_compiler() == "msvc":
            return True

        self.gdaldir = self.get_gdal_config("prefix")
        self.library_dirs.append(os.path.join(self.gdaldir, "lib"))
        self.include_dirs.append(os.path.join(self.gdaldir, "include"))

        cflags = self.get_gdal_config("cflags")
        if cflags:
            self.extra_cflags = cflags.split()

    def build_extension(self, ext):
        # We override this instead of setting extra_compile_args directly on
        # the Extension() instantiations below because we want to use the same
        # logic to resolve the location of gdal-config throughout.
        ext.extra_compile_args.extend(self.extra_cflags)
        return build_ext.build_extension(self, ext)


extra_link_args = []
extra_compile_args = []

gdal_module = Extension(
    "osgeo._gdal",
    sources=["extensions/gdal_wrap.cpp"],
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)

gdalconst_module = Extension(
    "osgeo._gdalconst",
    sources=["extensions/gdalconst_wrap.c"],
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)

osr_module = Extension(
    "osgeo._osr",
    sources=["extensions/osr_wrap.cpp"],
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)

ogr_module = Extension(
    "osgeo._ogr",
    sources=["extensions/ogr_wrap.cpp"],
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)


array_module = Extension(
    "osgeo._gdal_array",
    sources=["extensions/gdal_array_wrap.cpp"],
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)

gnm_module = Extension(
    "osgeo._gnm",
    sources=["extensions/gnm_wrap.cpp"],
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)

ext_modules = [gdal_module, gdalconst_module, osr_module, ogr_module]

if os.path.exists("setup_vars.ini"):
    with open("setup_vars.ini") as f:
        lines = f.readlines()
        if "GNM_ENABLED=no" in lines or "GNM_ENABLED=no\n" in lines:
            GNM_ENABLED = False

if GNM_ENABLED:
    ext_modules.append(gnm_module)

if HAVE_NUMPY:
    ext_modules.append(array_module)

utils_package_root = "gdal-utils"  # path for gdal-utils sources
packages = find_packages(utils_package_root)
packages = ["osgeo"] + packages
package_dir = {"osgeo": "osgeo", "": utils_package_root}

readme = open("README.rst", encoding="utf-8").read()

name = "GDAL"
version = gdal_version
author = "Frank Warmerdam"
author_email = "warmerdam@pobox.com"
maintainer = "Howard Butler"
maintainer_email = "hobu.inc@gmail.com"
description = "GDAL: Geospatial Data Abstraction Library"
license_type = "MIT"
url = "http://www.gdal.org"

classifiers = [
    "Development Status :: 5 - Production/Stable",
    "Intended Audience :: Developers",
    "Intended Audience :: Science/Research",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
    "Programming Language :: Python :: 3",
    "Programming Language :: C",
    "Programming Language :: C++",
    "Topic :: Scientific/Engineering :: GIS",
    "Topic :: Scientific/Engineering :: Information Analysis",
]


if BUILD_FOR_CHEESESHOP:
    data_files = [("osgeo/data/gdal", glob(os.path.join("../../data", "*")))]
else:
    data_files = None

exclude_package_data = {"": ["GNUmakefile"]}

setup_kwargs = dict(
    name=name,
    version=gdal_version,
    author=author,
    author_email=author_email,
    maintainer=maintainer,
    maintainer_email=maintainer_email,
    long_description=readme,
    long_description_content_type="text/x-rst",
    description=description,
    license=license_type,
    classifiers=classifiers,
    packages=packages,
    package_dir=package_dir,
    url=url,
    python_requires=">=3.6.0",
    data_files=data_files,
    ext_modules=ext_modules,
    scripts=glob(utils_package_root + "/scripts/*.py"),
    cmdclass={"build_ext": gdal_ext},
    extras_require={"numpy": ["numpy > 1.0.0"]},
    zip_safe=False,
    exclude_package_data=exclude_package_data,
)

setup(**setup_kwargs)