# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from distutils.core import setup, Extension
from distutils.command.build import build as _build
from distutils.command.clean import clean as _clean
from distutils.cmd import Command as _Command
from distutils.dep_util import newer_group
import distutils.ccompiler
import distutils.sysconfig
import os
import glob
import platform
import shutil
import subprocess
import sysconfig
import sys
import unittest

def ext_build_dir(base):
    """Returns the build directory for compiled extensions"""
    pattern = "lib.{platform}-{version[0]}.{version[1]}"
    dirname = pattern.format(platform=sysconfig.get_platform(),
                             version=sys.version_info)
    return os.path.join(base, 'build', dirname)

# Get a compiler object and and strings representing the compiler type and
# CFLAGS.  Add the Python headers include dir to CFLAGS.
compiler = distutils.ccompiler.new_compiler()
cflags = sysconfig.get_config_var('CFLAGS')
if cflags is None:
    cflags = "-I" + distutils.sysconfig.get_python_inc()
else:
    cflags = cflags + " -I" + distutils.sysconfig.get_python_inc()
compiler_type = distutils.ccompiler.get_default_compiler()

# There's no public way to get a string representing the compiler executable
# out of distutils, but the member variable has been in the same place for a
# long time, so violating encapsulation may be ok.
if compiler_type == 'unix':
    compiler_name = "".join(compiler.compiler)
    make_command  = ["make", "-j"]   # TODO portability
    CORELIB_NAME  = 'libclownfish.a' # TODO portability
    TESTLIB_NAME  = 'libtestcfish.a' # TODO portability
elif compiler_type == 'msvc':
    compiler.initialize()
    compiler_name = compiler.cc
    make_command  = ["nmake"]
    CORELIB_NAME  = 'clownfish.lib'
    TESTLIB_NAME  = 'testcfish.lib'

BASE_DIR        = os.path.abspath(os.path.join(os.pardir, os.pardir))
PARENT_DIR      = os.path.abspath(os.pardir)
CORE_SOURCE_DIR = os.path.join(PARENT_DIR, 'core')
TEST_SOURCE_DIR = os.path.join(PARENT_DIR, 'test')
CFEXT_DIR       = 'cfext'
COMMON_SOURCE_DIR    = os.path.join(PARENT_DIR, 'common')
CHARMONIZER_C        = os.path.join(COMMON_SOURCE_DIR, 'charmonizer.c')
CHARMONIZER_EXE_NAME = compiler.executable_filename('charmonizer')
CHARMONIZER_EXE_PATH = os.path.join(os.curdir, CHARMONIZER_EXE_NAME)
CHARMONY_H_PATH      = 'charmony.h'
CORELIB_PATH         = os.path.abspath(os.path.join(os.curdir, CORELIB_NAME))
TESTLIB_PATH         = os.path.abspath(os.path.join(os.curdir, TESTLIB_NAME))
AUTOGEN_INCLUDE      = os.path.join('autogen', 'include')
CFC_DIR              = os.path.join(BASE_DIR, 'compiler', 'python')
CFC_BUILD_DIR        = ext_build_dir(os.path.join(CFC_DIR))
PY_BINDING_DIR       = os.path.abspath(os.curdir)
BINDING_FILE         = '_clownfish.c'

c_filepaths = [BINDING_FILE]
paths_to_clean = [
    CHARMONIZER_EXE_PATH,
    CHARMONY_H_PATH,
    '_charm*',
    BINDING_FILE,
]

def _quotify(text):
    text = text.replace('\\', '\\\\')
    text = text.replace('"', '\\"')
    return '"' + text + '"'

class charmony(_Command):
    description = "Build and run charmonizer"
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def run(self):
        # Compile charmonizer.
        if newer_group([CHARMONIZER_C], CHARMONIZER_EXE_PATH):
            command = [compiler_name]
            if compiler_type == 'msvc':
                command.append('/Fe' + CHARMONIZER_EXE_PATH)
            else:
                command.extend(['-o', CHARMONIZER_EXE_PATH])
            command.append(CHARMONIZER_C)
            print(" ".join(command))
            subprocess.check_call(command)

        # Run charmonizer.
        if newer_group([CHARMONIZER_EXE_PATH], CHARMONY_H_PATH):
            command = [
                CHARMONIZER_EXE_PATH,
                '--cc=' + _quotify(compiler_name),
                '--enable-c',
                '--enable-python',
                '--host=python',
                '--enable-makefile',
                '--',
                cflags
            ]
            if 'CHARM_VALGRIND' in os.environ:
                command[0:0] = "valgrind", "--leak-check=yes";
            print(" ".join(command))
            subprocess.check_call(command)

class libclownfish(_Command):
    description = "Build the Clownfish runtime core as a static archive."
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass

    def run(self):
        self.run_command('charmony')
        self.run_cfc()
        subprocess.check_call(make_command + ['static'])

    def run_cfc(self):
        sys.path.append(CFC_DIR)
        sys.path.append(CFC_BUILD_DIR)
        import cfc
        hierarchy = cfc.model.Hierarchy(dest="autogen")
        hierarchy.add_source_dir(CORE_SOURCE_DIR)
        hierarchy.add_source_dir(TEST_SOURCE_DIR)
        hierarchy.build()
        header = "Autogenerated by setup.py"
        core_binding = cfc.binding.BindCore(hierarchy=hierarchy, header=header)
        modified = core_binding.write_all_modified()
        if modified:
            py_binding = cfc.binding.Python(hierarchy=hierarchy)
            py_binding.set_header(header)
            py_binding.write_bindings(parcel="Clownfish", dest=PY_BINDING_DIR)
            hierarchy.write_log()

class my_clean(_clean):
    def run(self):
        _clean.run(self)
        if os.path.isfile("Makefile"):
            subprocess.check_call(make_command + ['distclean'])
        for elem in paths_to_clean:
            for path in glob.glob(elem):
                print("removing " + path)
                if os.path.isdir(path):
                    shutil.rmtree(path)
                else:
                    os.unlink(path)

class my_build(_build):
    def run(self):
        self.run_command('charmony')
        self.run_command('libclownfish')
        _build.run(self)

class test(_Command):
    description = "Run unit tests."
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def ext_build_dir(self):
        """Returns the build directory for compiled extensions"""
        pattern = "lib.{platform}-{version[0]}.{version[1]}"
        dirname = pattern.format(platform=sysconfig.get_platform(),
                                 version=sys.version_info)
        return os.path.join('build', dirname)

    def run(self):
        self.run_command('build')
        orig_sys_path = sys.path[:]
        sys.path.append(self.ext_build_dir())

        loader = unittest.TestLoader()
        tests = loader.discover("test")
        test_runner = unittest.runner.TextTestRunner()
        if not test_runner.run(tests).wasSuccessful():
            sys.exit(1)

        # restore sys.path
        sys.path = orig_sys_path

clownfish_extension = Extension('clownfish._clownfish',
                                 include_dirs = [
                                    CORE_SOURCE_DIR,
                                    AUTOGEN_INCLUDE,
                                    CFEXT_DIR,
                                    os.curdir,
                                 ],
                                 extra_link_args = [
                                    TESTLIB_PATH,
                                    CORELIB_PATH,
                                 ],
                                 sources = c_filepaths)

setup(name = 'clownfish',
      version = '0.6.3',
      description = 'Clownfish runtime',
      author = 'Apache Lucy Project',
      author_email = 'dev at lucy dot apache dot org',
      url = 'http://lucy.apache.org',
      packages = ['clownfish',
                 ],
      cmdclass = {
          'build': my_build,
          'clean': my_clean,
          'charmony': charmony,
          'libclownfish': libclownfish,
          'test': test,
      },
      package_dir={'': 'src'},
      ext_modules = [clownfish_extension])