#!/usr/bin/python

import argparse
import distutils.spawn
import email.parser
import logging
import os
import os.path
import re
import shutil
import subprocess
import sys
import tempfile

import pip.util
import pkg_resources


logger = logging.getLogger()

package_map = {}
arch_dependent = set()
epoch_map = {}

requirements_section_re = re.compile(r'\[(.*?)\]')
version_re = re.compile(r"^(.*[^.0])(\.0+)*$")
setup_py = "setup.py"

DEFAULT_SCRIPTS = {
    "prep":
    """%setup -n %{pkg_name}-%{unmangled_version} -n %{pkg_name}-%{unmangled_version}""",
    "build":
    """python setup.py build""",
    "install":
    """python setup.py install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILES
abspath_installed_files=$(readlink -f INSTALLED_FILES)
(
    cd $RPM_BUILD_ROOT
    for i in usr/*/python*/site-packages/* usr/bin/*; do
        if [ -e "$i" ]; then
            sed -i "s@/$i/@DELETE_ME@" "$abspath_installed_files"
            echo "/$i"
        fi
    done
    if [ -d usr/man ]; then
        rm -rf usr/share/man
        mkdir -p usr/share
        mv usr/man usr/share/
        sed -i "s@/usr/man/@DELETE_ME@" "$abspath_installed_files"
        for i in usr/share/man/*; do
            echo "/$i/*"
        done
    fi
) >> GATHERED_FILES
{ sed '/^DELETE_ME/d' INSTALLED_FILES; cat GATHERED_FILES; } | sort -u > INSTALLED_FILES.tmp
mv -f INSTALLED_FILES{.tmp,}""",
    "clean":
    """rm -rf $RPM_BUILD_ROOT""",
}


class InstallationError(Exception):
    pass


def python_name_to_key(name):
    return pkg_resources.Requirement.parse(name).key


def python_key_to_rpm(python_name):
    python_name = python_name.lower()
    try:
        return package_map[python_name]
    except KeyError:
        pass
    python_name = python_name.replace("_", "-").replace(".", "-")
    if python_name.startswith("python-"):
        prefixed_name = python_name
    else:
        prefixed_name = "python-%s" % python_name
    return prefixed_name


def egg_info_path(source_dir, filename):
    base = os.path.join(source_dir, "pip-egg-info")
    filenames = os.listdir(base)
    if not filenames:
        raise InstallationError("No files/directories in %s (from %s)"
                                % (base, filename))

    # if we have more than one match, we pick the toplevel one.
    if len(filenames) > 1:
        filenames.sort(key=lambda x: x.count(os.path.sep) +
                       (os.path.altsep and
                        x.count(os.path.altsep) or 0))
    return os.path.join(base, filenames[0], filename)


def egg_info_lines(source_dir, filename):
    filename = egg_info_path(source_dir, filename)
    if not os.path.exists(filename):
        return []
    with open(filename, "r") as f:
        return f.readlines()


def egg_info_requirements(source_dir, extras=()):
    in_extra = None
    for line in egg_info_lines(source_dir, 'requires.txt'):
        match = requirements_section_re.match(line.lower())
        if match:
            in_extra = match.group(1)
            continue
        if in_extra and in_extra not in extras:
            # Skip requirement for an extra we aren't requiring
            continue
        yield line


def pkg_info(source_dir):
    p = email.parser.FeedParser()
    filename = egg_info_path(source_dir, "PKG-INFO")
    if not os.path.exists(filename):
        logger.warn('No PKG-INFO file found in %s' % source_dir)
    else:
        with open(filename, "r") as f:
            for line in f.readlines():
                # NOTE(aababilov): d2to1 has bad PKG-INFO
                # that is fixed this way:
                if line and not line[0].isspace() and not ":" in line:
                    line = " " + line
                p.feed(line)
    return p.close()


def setup_py_one_line(source_dir, command):
    """Run `python setup.py $command` and return the last line.

    python ldap is so clever that is prints extra stuff
    before package name or version. Lets return the last line
    """
    return call_subprocess(
        [sys.executable, setup_py, command],
        cwd=source_dir, show_stdout=False)[0].splitlines()[-1].strip()


def create_parser():
    parser = argparse.ArgumentParser()

    rpm_base = os.path.expanduser("~/rpmbuild")
    source_dir = os.getcwd()

    rpmbuild_executable = (distutils.spawn.find_executable("rpmbuild") or
                           distutils.spawn.find_executable("rpm"))
    parser.add_argument(
        "--pip-verbose", "-f",
        action="store_true",
        default=False,
        help="Show pip stdout")
    parser.add_argument(
        "--debug", "-d",
        action="store_true",
        default=False,
        help="Print debug information")
    parser.add_argument(
        "--source-only", "-s",
        action="store_true",
        default=False,
        help="Only generate source RPM")
    parser.add_argument(
        "--binary-only", "-b",
        action="store_true",
        default=False,
        help="Only generate binary RPM")
    parser.add_argument(
        "--rpm-base",
        metavar="<dir>",
        default=rpm_base,
        help="rpmbuild directory (default: %s)" % rpm_base)
    parser.add_argument(
        "--rpmbuild",
        metavar="<dir>",
        default=rpmbuild_executable,
        help="rpmbuild executable (default: %s)" % rpmbuild_executable)
    parser.add_argument(
        "--convert", "-c",
        dest="convert",
        metavar="<name>",
        nargs="+",
        default=[],
        help="Python requirement name to be converted to RPM package names")
    parser.add_argument(
        dest="sources",
        metavar="<dir or archive>",
        nargs="*",
        default=[source_dir],
        help="Source directories of packages (default: current directory)")
    parser.add_argument(
        "--scripts-dir",
        metavar="<dir>",
        default=None,
        help="Specify a directory with scripts for packages")
    parser.add_argument(
        "--arch-dependent", "-a",
        metavar="<Python package name>",
        nargs="+",
        default=[],
        help="Known architecture dependent packages")
    parser.add_argument(
        "--epoch", "-e",
        metavar="<number>",
        type=int,
        default=None,
        help="RPM epoch for generated packages")
    parser.add_argument(
        "--epoch-map", "-x",
        metavar="<Python package name == epoch number>",
        nargs="+",
        default=[],
        help="Forced RPM epochs for packages")
    parser.add_argument(
        "--release", "-r",
        metavar="<number>",
        default="0%{?dist}",
        help="RPM release for generated packages")
    parser.add_argument(
        "--package-map", "-p",
        metavar="<Python package name == RPM name>",
        nargs="+",
        default=[],
        help="Correspondence between Python and RPM package names")
    return parser


def call_subprocess(cmd, cwd=None, show_stdout=True, raise_on_returncode=True):
    if show_stdout:
        stdout = None
    else:
        stdout = subprocess.PIPE
    proc = subprocess.Popen(cmd, cwd=cwd, stderr=None, stdin=None, stdout=stdout)
    ret = proc.communicate()
    if proc.returncode:
        cwd = cwd or os.getcwd()
        command_desc = " ".join(cmd)
        if raise_on_returncode:
            raise InstallationError(
                "Command %s failed with error code %s in %s"
                % (command_desc, proc.returncode, cwd))
        else:
            logger.warn(
                "Command %s had error code %s in %s"
                % (command_desc, proc.returncode, cwd))
    return ret


def setup_logging(options):
    level = logging.DEBUG if options.debug else logging.WARNING
    handler = logging.StreamHandler(sys.stderr)
    logger.addHandler(handler)
    logger.setLevel(level)


def truncate(text, max_len=77):
    if max_len <= 0:
        return ''
    if len(text) < max_len:
        return text
    text = text[0:max_len] + "..."
    return text


def build_map(arguments):
    result = {}
    for arg in arguments:
        try:
            (key, value) = arg.split("==")
            key = python_name_to_key(key)
            value = value.strip()
            assert value
        except (IndexError, ValueError, AssertionError):
            raise InstallationError("Bad specifier: `%s'" % arg)
        else:
            result[key] = value
    return result


def run_egg_info(source_dir, options):
    script = """
__file__ = __SETUP_PY__
from setuptools.command import egg_info
import pkg_resources
import os
def replacement_run(self):
    self.mkpath(self.egg_info)
    installer = self.distribution.fetch_build_egg
    if self.distribution.has_ext_modules():
        with open("%s/ext_modules.txt" % self.egg_info, "w") as f:
            pass
    for ep in pkg_resources.iter_entry_points('egg_info.writers'):
        # require=False is the change we're making:
        writer = ep.load(require=False)
        if writer:
            writer(self, ep.name, os.path.join(self.egg_info,ep.name))
    self.find_sources()
egg_info.egg_info.run = replacement_run
exec(compile(open(__file__).read().replace('\\r\\n', '\\n'), __file__, 'exec'))
"""
    script = script.replace('__SETUP_PY__', "'setup.py'")
    egg_info_dir = os.path.join(source_dir, 'pip-egg-info')
    if not os.path.exists(egg_info_dir):
        os.makedirs(egg_info_dir)
    egg_base_option = ['--egg-base', 'pip-egg-info']
    call_subprocess(
        [sys.executable, '-c', script, 'egg_info'] + egg_base_option,
        cwd=source_dir,
        show_stdout=options.pip_verbose)


def trim_zeroes(version):
    """RPM mishandles versions like "0.8.0". Make it happy."""
    match = version_re.match(version)
    if match:
        return match.group(1)
    return version


def requires_and_conflicts(req_list):
    rpm_requires = ""
    rpm_conflicts = ""
    for line in req_list:
        try:
            req = pkg_resources.Requirement.parse(line)
        except Exception:
            continue
        rpm_name = python_key_to_rpm(req.key)
        if not req.specs:
            rpm_requires += "\nRequires:"
            rpm_requires = "%s %s" % (
                rpm_requires, rpm_name)
        for spec in req.specs:
            # kind in ("==", "<=", ">=", "!=")
            kind = spec[0]
            version = trim_zeroes(spec[1])
            try:
                version = "%s:%s" % (epoch_map[req.key], version)
            except KeyError:
                pass
            if kind == "!=":
                rpm_conflicts += "\nConflicts:"
                rpm_conflicts = "%s %s = %s" % (
                    rpm_conflicts, rpm_name, version)
                continue
            if kind == "==":
                kind = "="
            rpm_requires += "\nRequires:"
            rpm_requires = "%s %s %s %s" % (
                rpm_requires, rpm_name, kind, version)
    return rpm_requires, rpm_conflicts


def one_line(line, max_len=80):
    line = line.replace("\n", " ")
    if max_len > 0:
        return line[:max_len]
    return line


def build_rpm(options, filename):
    if os.path.isfile(filename):
        temp_dir = tempfile.mkdtemp('-unpack', 'py2rpm-')
        pip.util.unpack_file(filename, temp_dir, None, None)
        source_dir = temp_dir
        archive_name = filename
    elif os.path.isdir(filename):
        temp_dir = None
        archive_name = None
        source_dir = filename
    else:
        raise InstallationError(
            "`%s' is not a regular file nor a directory" % filename)

    run_egg_info(source_dir, options)
    info = pkg_info(source_dir)
    rpm_requires, rpm_conflicts = requires_and_conflicts(
        egg_info_requirements(source_dir))
    # NOTE(aababilov): do not use info["name"] to get the name - it is
    # the key (e.g., "nose-plugin"), not the name ("nose_plugin")
    pkg_name = setup_py_one_line(source_dir, "--name")
    pkg_key = python_name_to_key(pkg_name)
    build_dir = options.rpm_base
    rpm_name = python_key_to_rpm(pkg_key)
    version = one_line(info["version"])
    for path in (os.path.join(build_dir, "SPECS"),
                 os.path.join(build_dir, "SOURCES")):
        if not os.path.isdir(path):
            os.makedirs(path)
    spec_name = os.path.join(build_dir, "SPECS", "%s.spec" % rpm_name)

    if not archive_name:
        cmdline = [
            sys.executable, setup_py, "sdist",
        ]
        call_subprocess(cmdline, cwd=source_dir, raise_on_returncode=False)
        archive_name = "%s/dist/%s-%s.tar.gz" % (source_dir, pkg_name, version)
    shutil.copy(archive_name, os.path.join(build_dir, "SOURCES"))

    # We need to do this so that when a package such as hacking depends on
    # flake8 v2 that we don't go ahead and build a v2.0 version.
    #
    # Note(harlowja): Not sure why rpm seems to not understand these are the same...
    cleaned_version = trim_zeroes(version.replace('-', '_'))
    with open(spec_name, "w") as spec_file:
        print >> spec_file, "%define pkg_name", pkg_name
        print >> spec_file, "%define rpm_name", rpm_name
        print >> spec_file, "%define version", cleaned_version
        print >> spec_file, "%define release", options.release
        print >> spec_file, "%define unmangled_version", version
        print >> spec_file, ""
        tags = []
        tags.append(("Name", "%{rpm_name}"))
        epoch = epoch_map.get(pkg_key, options.epoch)
        if epoch is not None:
            tags.append(("Epoch", epoch))
        tags.append(("Version", "%{version}"))
        tags.append(("Release", "%{release}"))
        tags.append(("Summary", info["summary"]))
        archive_name = os.path.basename(archive_name)
        if archive_name == ("%s-%s.tar.gz" % (pkg_name, version)):
            tags.append(("Source0", "%{pkg_name}-%{unmangled_version}.tar.gz"))
        else:
            tags.append(("Source0", archive_name))
        tags.append(("License", info["license"]))
        tags.append(("Group", "Development/Libraries"))
        tags.append(("BuildRoot", "%{_tmppath}/%{pkg_name}-%{unmangled_version}-%{release}-buildroot"))
        tags.append(("Prefix", "%{_prefix}"))
        if pkg_key not in arch_dependent:
            if not os.path.exists(egg_info_path(source_dir, "ext_modules.txt")):
                tags.append(("BuildArch", "noarch"))
        tags.append(("Vendor", "%s <%s>" % (info["author"], info["author-email"])))
        tags.append(("Url", info["home-page"]))
        max_name_len = max(len(tag[0]) for tag in tags)
        for tag in tags:
            print >> spec_file, "%s:" % tag[0], " " * (
                max_name_len - len(tag[0]) + 1), one_line(tag[1], max_len=-1)
        if rpm_requires:
            print >> spec_file, rpm_requires
        if rpm_conflicts:
            print >> spec_file, rpm_conflicts
        print >> spec_file, "\n%description\n", info["description"]

        for script in "prep", "build", "install", "clean":
            print >> spec_file, "\n\n%%%s" % script
            if options.scripts_dir:
                script_filename = "%s/%s-%s.sh" % (options.scripts_dir, pkg_key, script)
                if os.path.isfile(script_filename):
                    with open(script_filename) as f_in:
                        print >> spec_file, f_in.read()
                    continue
            print >> spec_file, DEFAULT_SCRIPTS[script]
        print >> spec_file, """

%files -f INSTALLED_FILES
%defattr(-,root,root)
"""

    if options.source_only:
        rpmbuild_what = "-bs"
    elif options.binary_only:
        rpmbuild_what = "-bb"
    else:
        rpmbuild_what = "-ba"
    call_subprocess(
        [options.rpmbuild, rpmbuild_what,
         "--define", "_topdir %s" % build_dir,
         spec_name])
    if temp_dir:
        shutil.rmtree(temp_dir)


def main():
    parser = create_parser()
    options = parser.parse_args()
    setup_logging(options)
    global arch_dependent
    global package_map
    global epoch_map
    arch_dependent = set(python_name_to_key(pkg)
                         for pkg in options.arch_dependent)
    package_map = build_map(options.package_map)
    epoch_map = build_map(options.epoch_map)

    if options.convert:
        rpm_requires, rpm_conflicts = requires_and_conflicts(options.convert)
        if rpm_requires:
            print rpm_requires.strip()
        if rpm_conflicts:
            print rpm_conflicts.strip()
        return

    failed_pkgs = []
    for src in (os.path.abspath(sdir) for sdir in options.sources):
        try:
            build_rpm(options, src)
        except Exception as ex:
            failed_pkgs.append((src, ex))
            print >> sys.stderr, ex
    if failed_pkgs:
        print >> sys.stderr, "These packages failed to build:"
        for descr in failed_pkgs:
            print >> sys.stderr, "%s:\n\t%s" % descr
        sys.exit(1)


if __name__ == "__main__":
    try:
        main()
    except Exception as exp:
        print >> sys.stderr, exp