#!/usr/bin/env python

from distutils.core import setup, Extension
import distutils.sysconfig
from distutils.cmd import Command
from distutils import log
import sys
import os.path
from jToolkit import __version__
# py2exe only available on Windows
try:
  import py2exe
  build_exe = py2exe.build_exe.py2exe
  Distribution = py2exe.Distribution
except ImportError:
  py2exe = None
  build_exe = Command

join = os.path.join

jtoolkitversion = __version__.ver

packagesdir = distutils.sysconfig.get_python_lib()
sitepackages = packagesdir.replace(sys.prefix + os.sep, '')

class fileset(list):
  """this is a installation list of a set of files from a directory"""
  def __init__(self, src, dest, destsubdir, exclude=["CVS"]):
    """creates the fileset by walking through src directory"""
    self.src = src
    self.dest = dest
    self.destsubdir = destsubdir
    self.exclude = exclude
    # this calls self.adddirfiles(None, dirname, names) for each subdirectory dirname of self.src
    os.path.walk(self.src, self.adddirfiles, None)

  def adddirfiles(self, arg, dirname, names):
    """adds the files names from dirname to self (which is a list)"""
    # arg is ignored
    filenames = []
    for name in names:
      if name in self.exclude:
        continue
      filename = join(dirname,name)
      if not os.path.isdir(filename):
        filenames.append(filename)
    if len(filenames) > 0:
      destsubdirname = dirname.replace(self.src,self.destsubdir,1)
      destpath = join(self.dest,destsubdirname)
      self.append((destpath,filenames))

class InnoScript:
    """class that builds an InnoSetup script"""
    def __init__(self, name, lib_dir, dist_dir, exe_files = [], other_files = [], install_scripts = [], version = "1.0"):
        self.lib_dir = lib_dir
        self.dist_dir = dist_dir
        if not self.dist_dir.endswith(os.sep):
            self.dist_dir += os.sep
        self.name = name
        self.version = version
        self.exe_files = [self.chop(p) for p in exe_files]
        self.other_files = [self.chop(p) for p in other_files]
        self.install_scripts = install_scripts

    def getcompilecommand(self):
        try:
            import _winreg
            compile_key = _winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT, "innosetupscriptfile\\shell\\compile\\command")
            compilecommand = _winreg.QueryValue(compile_key, "")
            compile_key.Close()
        except:
            compilecommand = "compil32.exe"
        return compilecommand

    def chop(self, pathname):
        """returns the path relative to self.dist_dir"""
        assert pathname.startswith(self.dist_dir)
        return pathname[len(self.dist_dir):]

    def create(self, pathname=None):
        """creates the InnoSetup script"""
        if pathname is None:
          self.pathname = os.path.join(self.dist_dir, self.name + os.extsep + "iss")
        else:
          self.pathname = pathname
        ofi = self.file = open(self.pathname, "w")
        print >> ofi, "; WARNING: This script has been created by py2exe. Changes to this script"
        print >> ofi, "; will be overwritten the next time py2exe is run!"
        print >> ofi, r"[Setup]"
        print >> ofi, r"AppName=%s" % self.name
        print >> ofi, r"AppVerName=%s %s" % (self.name, self.version)
        print >> ofi, r"DefaultDirName={pf}\%s" % self.name
        print >> ofi, r"DefaultGroupName=%s" % self.name
        print >> ofi, r"OutputBaseFilename=%s-%s-setup" % (self.name, self.version)
        print >> ofi
        print >> ofi, r"[Files]"
        for path in self.exe_files + self.other_files:
            print >> ofi, r'Source: "%s"; DestDir: "{app}\%s"; Flags: ignoreversion' % (path, os.path.dirname(path))
        print >> ofi
        print >> ofi, r"[Icons]"
        for path in self.exe_files:
            if path in self.install_scripts:
                continue
            linkname = os.path.splitext(os.path.basename(path))[0]
            print >> ofi, r'Name: "{group}\%s"; Filename: "{app}\%s"; WorkingDir: "{app}"; Flags: dontcloseonexit' % \
                  (linkname, path)
        print >> ofi, 'Name: "{group}\Uninstall %s"; Filename: "{uninstallexe}"' % self.name
        if self.install_scripts:
            print >> ofi, r"[Run]"
            for path in self.install_scripts:
                print >> ofi, r'Filename: "{app}\%s"; WorkingDir: "{app}"; Parameters: "-install"' % path
            print >> ofi
            print >> ofi, r"[UninstallRun]"
            for path in self.install_scripts:
                print >> ofi, r'Filename: "{app}\%s"; WorkingDir: "{app}"; Parameters: "-remove"' % path
        print >> ofi
        ofi.close()

    def compile(self):
        """compiles the script using InnoSetup"""
        shellcompilecommand = self.getcompilecommand()
        compilecommand = shellcompilecommand.replace('"%1"', self.pathname)
        result = os.system(compilecommand)
        if result:
            print "Error compiling iss file"
            print "Opening iss file, use InnoSetup GUI to compile manually"
            os.startfile(self.pathname)

def fix_bdist_rpm(setupfile):
    """Fixes bdist_rpm to use the given setup filename instead of setup.py"""
    try:
        from distutils.command import bdist_rpm
        build_rpm = bdist_rpm.bdist_rpm
    except ImportError:
        return
    if not hasattr(build_rpm, "_make_spec_file"):
        return
    orig_make_spec_file = build_rpm._make_spec_file
    def fixed_make_spec_file(self):
        """Generate the text of an RPM spec file and return it as a
        list of strings (one per line).
        """
        orig_spec_file = orig_make_spec_file(self)
        return [line.replace("setup.py", setupfile) for line in orig_spec_file]
    build_rpm._make_spec_file = fixed_make_spec_file

def exclude_python_file(excludefile):
    """Adjusts build_py to not include the given .py file even if it is in a package"""
    # TODO: complete this, some other commands still need to be adjusted
    from distutils.command import build_py
    if hasattr(build_py.build_py, "find_package_modules"):
        orig_find_package_modules = build_py.build_py.find_package_modules
        def find_package_modules_with_exclude(*args, **kwargs):
            """Finds package modules, but excludes excludefile"""
            orig_package_modules = orig_find_package_modules(*args, **kwargs)
            return [(package, module_base, filename) for (package, module_base, filename) in orig_package_modules
                    if not filename.endswith(excludefile)]
        build_py.build_py.find_package_modules = find_package_modules_with_exclude

############# remove_source alterations to distutils ############

def extend_function(orig_function, extended_function):
    def wrapped_function(*args, **kwargs):
         result = orig_function(*args, **kwargs)
         result = extended_function(result, *args, **kwargs)
         return result
    return wrapped_function

def is_removable (py_file):
    """Checks whether a given python file should be removed.
    Can be overridden to only remove selected files; by default always returns True"""
    return True

def map_data_file (data_file):
    """remaps a data_file (could be a directory) to a different location
    Can be overridden to rearrange data locations; by default always returns data_file"""
    return data_file

def remove_source (py_files, verbose=1, dry_run=0):
    """Remove the original source for a collection of Python source files
    (assuming they have been compiled to either .pyc or .pyo form).
    'py_files' is a list of files to remove; any files that don't end in 
    ".py" are silently skipped.

    If 'verbose' is true, prints out a report of each file.  If 'dry_run'
    is true, doesn't actually do anything that would affect the filesystem.

    """
    for file in py_files:
        if file[-3:] != ".py":
            # This lets us be lazy and not filter filenames in
            # the "install_lib" command.
            continue
        if not os.path.exists(file+"c") or os.path.exists(file+"o"):
            log.warn("compiled file does not exist for %s" % (file))
        if os.path.exists(file) and is_removable(file):
            log.info("removing source file %s" % (file))
            if not dry_run:
                os.remove(file)

def bdist_get_inidata_removesource(result, self):
    return result + "\nremove_source=%d" % (self.remove_source)

# in run, set install_lib.remove_source (and compile) appropriately
def reinitialize_command_removesource(result, self, command, reinit_subcommands=0):
    if command == "install_lib":
        # pass the remove_source argument on to install_lib
        result.remove_source = self.remove_source
    return result

def make_finalize_options_removesource(command_source):
    """makes an extender method for getting the removesource option from the given command name"""
    def finalize_options_removesource(result, self):
        self.set_undefined_options(command_source, ('remove_source', 'remove_source'))
        return result
    return finalize_options_removesource

def byte_compile_removesource(self, files):
    if self.remove_source and not (self.compile or self.optimize > 0):
      self.compile = 1
    self.byte_compile_orig(files)
    if self.remove_source:
        remove_source(files, verbose=self.verbose, dry_run=self.dry_run)

def get_outputs_removesource(result, self):
    if self.remove_source:
        filtered_result = []
        for filename in result:
            if filename.endswith(".pycc"):
                continue
            elif filename.endswith(".py"):
                if not is_removable(filename):
                    filtered_result.append(filename)
            else:
                filtered_result.append(filename)
        return filtered_result
    else:
        return result

def initialize_remove_source(result, self):
    self.remove_source = None
    return result

def allow_distutils_remove_source():
    """adds the remove_source capabilities to distutils"""
    from distutils import util
    util.remove_source = remove_source
    option = ('remove-source', None, "don't include original .py source files (remove from distribution)")
    option_passing = {"build_py": "build", "install_lib": "install"}
    def add_remove_source_option(commandclass):
      commandclass.user_options.append(option)
      commandclass.boolean_options.append('remove-source')
      commandclass.initialize_options = extend_function(commandclass.initialize_options, initialize_remove_source)
      if hasattr(commandclass, "byte_compile"):
        commandclass.byte_compile_orig = commandclass.byte_compile
        commandclass.byte_compile = byte_compile_removesource
      if commandclass.__name__ in option_passing:
        finalize_options_removesource = make_finalize_options_removesource(option_passing[commandclass.__name__])
        commandclass.finalize_options = extend_function(commandclass.finalize_options, finalize_options_removesource)
    # bdist_wininst changes
    from distutils.command import bdist_wininst
    wininst = bdist_wininst.bdist_wininst
    add_remove_source_option(wininst)
    wininst.reinitialize_command = extend_function(wininst.reinitialize_command, reinitialize_command_removesource)
    wininst.get_inidata = extend_function(wininst.get_inidata, bdist_get_inidata_removesource)
    # bdist_rpm changes
    from distutils.command import bdist_rpm
    add_remove_source_option(bdist_rpm.bdist_rpm)
    # build changes
    from distutils.command import build
    add_remove_source_option(build.build)
    from distutils.command import build_py
    add_remove_source_option(build_py.build_py)
    # install changes
    from distutils.command import install
    add_remove_source_option(install.install)
    from distutils.command import install_lib
    libinst = install_lib.install_lib
    add_remove_source_option(libinst)
    libinst.get_outputs = extend_function(libinst.get_outputs, get_outputs_removesource)

class build_installer(build_exe):
    """distutils class that first builds the exe file(s), then creates a Windows installer using InnoSetup"""
    description = "create an executable installer for MS Windows using InnoSetup and py2exe"
    user_options = getattr(build_exe, 'user_options', []) + \
        [('install-script=', None,
          "basename of installation script to be run after installation or before deinstallation")]

    def initialize_options(self):
        build_exe.initialize_options(self)
        self.install_script = None

    def reinitialize_command(self, command, reinit_subcommands=0):
        if command == "install_data":
            install_data = build_exe.reinitialize_command(self, command, reinit_subcommands)
            install_data.data_files = self.remap_data_files(install_data.data_files)
            return install_data
        return build_exe.reinitialize_command(self, command, reinit_subcommands)

    def remap_data_files(self, data_files):
        new_data_files = []
        for f in data_files:
            if type(f) in (str, unicode):
                f = map_data_file(f)
            else:
                dir, files = f
                dir = map_data_file(dir)
                if dir is None:
                  f = None
                else:
                  f = dir, files
            if f is not None:
              new_data_files.append(f)
        return new_data_files

    def run(self):
        # First, let py2exe do it's work.
        build_exe.run(self)
        lib_dir = self.lib_dir
        dist_dir = self.dist_dir
        # create the Installer, using the files py2exe has created.
        exe_files = self.windows_exe_files + self.console_exe_files
        install_scripts = self.install_script
        if isinstance(install_scripts, (str, unicode)):
            install_scripts = [install_scripts]
        script = InnoScript(self.distribution.metadata.name, lib_dir, dist_dir, exe_files, self.lib_files, version=self.distribution.metadata.version, install_scripts=install_scripts)
        print "*** creating the inno setup script***"
        script.create()
        print "*** compiling the inno setup script***"
        script.compile()
        # Note: By default the final setup.exe will be in an Output subdirectory.

# the localize directory contains localized files...
localizesrc = 'localize' # join('jLogbook','localize')
localizedest = sitepackages
localizedestsubdir = join('localize')
localizefileset = fileset(localizesrc, localizedest, localizedestsubdir)
sitejtoolkit = join(sitepackages, 'jToolkit')

def get_data_files(*subdir_parts):
    return fileset(join(sitepackages, *subdir_parts), sitepackages, join(*subdir_parts))

datafiles = get_data_files('jToolkit', 'icons') + \
            get_data_files('jToolkit', 'js')

initfiles = [(join(sitepackages,'jToolkit'),[join('jToolkit','__init__.py')]),
             (join(sitepackages,'jToolkit', 'data'),[join('jToolkit', 'data', '__init__.py')]),
             (join(sitepackages,'jToolkit', 'web'),[join('jToolkit', 'web', '__init__.py')]),
             (join(sitepackages,'jToolkit', 'widgets'),[join('jToolkit', 'widgets', '__init__.py')]),
             (join(sitepackages,'jToolkit', 'xml'),[join('jToolkit', 'xml', '__init__.py')])]

setuppackages = ['jToolkit', 'jToolkit.data', 'jToolkit.web', 'jToolkit.widgets', 'jToolkit.xml']

standarddatafiles = localizefileset + datafiles + initfiles

setupdatafiles = standarddatafiles

def buildmanifest_in(file):
  """This writes the required files to a MANIFEST.in file"""
  print >>file, "# MANIFEST.in: the below autogenerated by setup.py from jToolkit %s" % jtoolkitversion
  print >>file, "# things needed by translate setup.py to rebuild"
  print >>file, "graft jToolkit/icons"
  print >>file, "graft jToolkit/demo/tutorial"
  print >>file, "graft jToolkit/js"
  print >>file, "include ChangeLog"
  print >>file, "include COPYING"
  print >>file, "include LICENSE"
  print >>file, "graft jToolkit/js"
  print >>file, "# MANIFEST.in: the above autogenerated by setup.py from translate %s" % jtoolkitversion

def standardsetup(name, version, custompackages=[], customdatafiles=[]):
  try:
    manifest_in = open("MANIFEST.in", "w")
    buildmanifest_in(manifest_in)
    manifest_in.close()
  except IOError, e:
    print >> sys.stderr, "warning: could not recreate MANIFEST.in, continuing anyway. Error was %s" % e
  fix_bdist_rpm(os.path.basename(__file__))
  exclude_python_file(join("jToolkit", "data", "ADODB.py"))
  dosetup(name, version, setuppackages + custompackages, setupdatafiles + customdatafiles)

classifiers = [
  "Development Status :: 4 - Beta",
  "Environment :: Web Environment",
  "Intended Audience :: Developers",
  "License :: OSI Approved :: GNU General Public License (GPL)",
  "Programming Language :: Python",
  "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
  "Topic :: Software Development :: Libraries :: Python Modules",
  "Operating System :: OS Independent",
  "Operating System :: Microsoft :: Windows",
  "Operating System :: Unix"
  ]

jToolkitBlurb = """jToolkit is a Python web application framework built on modpython and Apache. There is also a simple command line webserver for running applications from.
It is aimed at dynamically generated pages rather than mostly-static pages (for which there are templating solutions). Pages can be produced using a variety of widgets. It handles sessions and database connections (and multi-database portability)."""

def dosetup(name, version, packages, datafiles):
  setup(name=name,
        version=version,
        license="GNU General Public License (GPL)",
        description="jToolkit web framework",
        long_description=jToolkitBlurb,
        author="St James Software",
        author_email="info@sjsoft.com",
        url="http://jtoolkit.sourceforge.net/",
        platforms=["any"],
        classifiers=classifiers,
        packages=packages,
        data_files=datafiles
        )

if __name__ == "__main__":
  standardsetup("jToolkit", jtoolkitversion)