import glob
import os
import os.path as osp
import re
import shutil
import sys

from distutils.command.clean import clean as _clean
from distutils import sysconfig

from os.path import join as pjoin

from setuptools import setup, Extension, Distribution
from setuptools.command.build_ext import build_ext as _build_ext

# Check if we're running 64-bit Python
is_64_bit = sys.maxsize > 2**32

class clean(_clean):
 def run(self):
 _clean.run(self)
 for x in []:
 try:
 os.remove(x)
 except OSError:
 pass

class build_ext(_build_ext):
 def run(self):
 self._run_cmake()

 # adapted from cmake_build_ext in dynd-python
 # github.com/libdynd/dynd-python

 description = "Build the C-extensions for arrow"
 user_options = ([('extra-cmake-args=', None, 'extra arguments for CMake'),
 ('build-type=', None, 'build type (Debug or Release)')] +
 _build_ext.user_options)

 def initialize_options(self):
 _build_ext.initialize_options(self)
 self.extra_cmake_args = os.environ.get('XLNTPYARROW_CMAKE_OPTIONS', '')
 self.build_type = os.environ.get('XLNTPYARROW_BUILD_TYPE', 'Debug')

 self.cmake_cxxflags = os.environ.get('XLNTPYARROW_CXXFLAGS', '')

 if sys.platform == 'win32':
 # Cannot do debug builds in Windows unless Python itself is a debug
 # build
 if not hasattr(sys, 'gettotalrefcount'):
 self.build_type = 'Release'

 def _run_cmake(self):
 # The directory containing this setup.py
 source = osp.dirname(osp.abspath(__file__))

 # The staging directory for the module being built
 build_temp = pjoin(os.getcwd(), self.build_temp)
 build_lib = os.path.join(os.getcwd(), self.build_lib)

 # Change to the build directory
 saved_cwd = os.getcwd()
 if not os.path.isdir(self.build_temp):
 self.mkpath(self.build_temp)
 os.chdir(self.build_temp)

 # Detect if we built elsewhere
 if os.path.isfile('CMakeCache.txt'):
 cachefile = open('CMakeCache.txt', 'r')
 cachedir = re.search('CMAKE_CACHEFILE_DIR:INTERNAL=(.*)',
 cachefile.read()).group(1)
 cachefile.close()
 if (cachedir != build_temp):
 return

 static_lib_option = ''

 cmake_options = [
 '-DPYTHON_EXECUTABLE=%s' % sys.executable,
 static_lib_option,
 ]

 if len(self.cmake_cxxflags) > 0:
 cmake_options.append('-DPYARROW_CXXFLAGS="{0}"'
 .format(self.cmake_cxxflags))

 cmake_options.append('-DCMAKE_BUILD_TYPE={0}'
 .format(self.build_type))

 if 'CMAKE_GENERATOR' in os.environ:
 cmake_options.append('-G{}'
 .format(os.environ['CMAKE_GENERATOR']))

 if sys.platform != 'win32':
 cmake_options.append('-DCMAKE_INSTALL_PREFIX={0}'
 .format(os.environ['PREFIX']))
 cmake_command = (['cmake', self.extra_cmake_args] +
 cmake_options + [source])

 print("-- Runnning cmake for xlntpyarrow")
 self.spawn(cmake_command)
 print("-- Finished cmake for xlntpyarrow")
 args = ['make']
 if os.environ.get('XLNTPYARROW_BUILD_VERBOSE', '0') == '1':
 args.append('VERBOSE=1')

 if 'XLNTPYARROW_PARALLEL' in os.environ:
 args.append('-j{0}'.format(os.environ['XLNTPYARROW_PARALLEL']))

 args.append('install')

 print("-- Running cmake --build for xlntpyarrow")
 self.spawn(args)
 print("-- Finished cmake --build for xlntpyarrow")
 else:
 import shlex
 if not is_64_bit:
 raise RuntimeError('Not supported on 32-bit Windows')

 cmake_options.append('-DCMAKE_INSTALL_PREFIX={0}'
 .format(os.environ['LIBRARY_PREFIX']))
 extra_cmake_args = shlex.split(self.extra_cmake_args)
 cmake_command = (['cmake'] + extra_cmake_args +
 cmake_options + [source])

 print("-- Runnning cmake for xlntpyarrow")
 self.spawn(cmake_command)
 print("-- Finished cmake for xlntpyarrow")
 # Do the build
 print("-- Running cmake --build for xlntpyarrow")
 self.spawn(['cmake', '--build', '.', '--config', self.build_type, '--target', 'INSTALL'])
 print("-- Finished cmake --build for xlntpyarrow")

 if self.inplace:
 # a bit hacky
 build_lib = saved_cwd

 # Move the libraries to the place expected by the Python
 # build
 shared_library_prefix = 'lib'
 if sys.platform == 'darwin':
 shared_library_suffix = '.dylib'
 elif sys.platform == 'win32':
 shared_library_suffix = '.dll'
 shared_library_prefix = ''
 else:
 shared_library_suffix = '.so'

 try:
 os.makedirs(pjoin(build_lib, 'xlntpyarrow'))
 except OSError:
 pass

 self._found_names = []
 built_path = self.get_ext_built('lib')
 if not os.path.exists(built_path):
 raise RuntimeError('xlntpyarrow C-extension failed to build:',
 os.path.abspath(built_path))

 ext_path = pjoin(build_lib, self._get_cmake_ext_path('lib'))
 if os.path.exists(ext_path):
 os.remove(ext_path)
 self.mkpath(os.path.dirname(ext_path))
 print('Moving built C-extension', built_path,
 'to build path', ext_path)
 shutil.move(self.get_ext_built('lib'), ext_path)
 self._found_names.append('lib')

 os.chdir(saved_cwd)

 def _failure_permitted(self, name):
 return False

 def _get_inplace_dir(self):
 pass

 def _get_cmake_ext_path(self, name):
 # Get the package directory from build_py
 build_py = self.get_finalized_command('build_py')
 package_dir = build_py.get_package_dir('xlntpyarrow')
 # This is the name of the arrow C-extension
 suffix = sysconfig.get_config_var('EXT_SUFFIX')
 if suffix is None:
 suffix = sysconfig.get_config_var('SO')
 filename = name + suffix
 return pjoin(package_dir, filename)

 def get_ext_built(self, name):
 if sys.platform == 'win32':
 head, tail = os.path.split(name)
 suffix = sysconfig.get_config_var('SO')
 return pjoin(head, self.build_type, tail + suffix)
 else:
 suffix = sysconfig.get_config_var('SO')
 print('suffix is', suffix)
 return name + suffix

 def get_names(self):
 return self._found_names

 def get_outputs(self):
 # Just the C extensions
 # regular_exts = _build_ext.get_outputs(self)
 return [self._get_cmake_ext_path(name)
 for name in self.get_names()]

long_description = """
xlntpyarrow allows Apache Arrow tables to be written to and read from an XLSX
file efficiently using the C++ library xlnt.
""".strip()

classifiers = [
 'Development Status :: 5 - Production/Stable',
 'Environment :: Plugins',
 'Intended Audience :: Science/Research',
 'License :: OSI Approved :: MIT License',
 'Natural Language :: English',
 'Operating System :: Microsoft :: Windows',
 'Operating System :: MacOS :: MacOS X',
 'Operating System :: POSIX :: Linux',
 'Programming Language :: C',
 'Programming Language :: C++',
 'Programming Language :: Python :: 2.7',
 'Programming Language :: Python :: 3.6',
 'Programming Language :: Python :: Implementation :: CPython',
 'Topic :: Database',
 'Topic :: Office/Business :: Financial :: Spreadsheet',
 'Topic :: Scientific/Engineering :: Information Analysis',
 'Topic :: Software Development :: Libraries :: Python Modules'
]

class BinaryDistribution(Distribution):
 def has_ext_modules(foo):
 return True

setup(
 name = 'xlntpyarrow',
 version = '1.1.0',
 description = 'Python library for converting Apache Arrow tables<->XLSX files',
 long_description = long_description,
 author = 'Thomas Fussell',
 author_email = 'thomas.fussell@gmail.com',
 maintainer = 'Thomas Fussell',
 maintainer_email = 'thomas.fussell@gmail.com',
 url = 'https://github.com/tfussell/xlnt',
 download_url = 'https://github.com/tfussell/xlnt/releases',
 packages = ['xlntpyarrow'],
 ext_modules = [Extension('xlntpyarrow.lib', [])],
 cmdclass = {
 'clean': clean,
 'build_ext': build_ext
 },
 classifiers = classifiers,
 distclass = BinaryDistribution,
 zip_safe = False
)