#!/usr/bin/env python3
# This file is part of 'miniver': https://github.com/jbweston/miniver

import sys
import os
import os.path
import argparse
import tempfile
import shutil
import textwrap
from zipfile import ZipFile
from importlib.util import find_spec
from urllib.request import urlretrieve

if sys.version_info < (3, 5):
    print('Miniver needs at least Python 3.5')
    sys.exit(1)

try:
    import miniver
    _miniver_version = miniver.__version__
    del miniver
    _miniver_is_installed = True
except ImportError:
    _miniver_is_installed = False

# When we fetch miniver from local files
_miniver_modules = ('_version',)


# When we fetch miniver from GitHub
_miniver_zip_url = 'https://github.com/jbweston/miniver/archive/master.zip'
_zipfile_root = 'miniver-master'  # tied to the fact that we fetch master.zip

# File templates
_setup_template = '''
    # Loads version.py module without importing the whole package.
    def get_version_and_cmdclass(package_path):
        import os
        from importlib.util import module_from_spec, spec_from_file_location
        spec = spec_from_file_location('version',
                                       os.path.join(package_path, '_version.py'))
        module = module_from_spec(spec)
        spec.loader.exec_module(module)
        return module.__version__, module.cmdclass


    version, cmdclass = get_version_and_cmdclass('{package_dir}')

    setup(
        ...,
        version=version,
        cmdclass=cmdclass,
    )
'''

_static_version_template = textwrap.dedent('''\
    # -*- coding: utf-8 -*-
    # This file is part of 'miniver': https://github.com/jbweston/miniver
    #
    # This file will be overwritten by setup.py when a source or binary
    # distribution is made.  The magic value "__use_git__" is interpreted by
    # version.py.

    version = "__use_git__"

    # These values are only set if the distribution was created with 'git archive'
    refnames = "$Format:%D$"
    git_hash = "$Format:%h$"
''')

_init_template = 'from ._version import __version__'
_gitattribute_template = '{package_dir}/_static_version.py export-subst'


def _line_in_file(to_find, filename):
    """Return True if the specified line exists in the named file."""
    assert '\n' not in to_find
    try:
        with open(filename) as f:
            for line in f:
                if to_find in line:
                    return True
            return False
    except FileNotFoundError:
        return False


def _write_line(content, filename):
    assert '\n' not in content
    if not _line_in_file(content, filename):
        with open(filename, 'a') as f:
            f.write(content)


def _write_content(content, filename):
    with open(filename, 'w') as f:
        f.write(content)


def _fail(msg):
    print(msg, file=sys.stderr)
    print('Miniver was not installed', file=sys.stderr)
    sys.exit(1)


def extract_miniver_from_github():
    filename, _ = urlretrieve(_miniver_zip_url)
    z = ZipFile(filename)
    tmpdir = tempfile.mkdtemp()
    input_paths = ['/'.join((_zipfile_root, 'miniver', module+'.py'))
                   for module in _miniver_modules]
    for p in input_paths:
        z.extract(p, path=tmpdir)
    return [os.path.join(tmpdir, *p.split()) for p in input_paths]


def extract_miniver_from_local():
    return [find_spec('.' + module, package='miniver').origin
            for module in _miniver_modules]


def get_args():
    parser = argparse.ArgumentParser(
        description="Install 'miniver' into the current Python package")
    parser.add_argument("-v", "--version", action="version",
                        version=_miniver_version)
    parser.add_argument('package_directory',
                        help="Directory to install 'miniver' into.")
    return parser.parse_args().package_directory


def main():
    package_dir = get_args()
    if not os.path.isdir(package_dir):
        _fail("Directory '{}' does not exist".format(package_dir))
    if package_dir != os.path.relpath(package_dir):
        _fail("'{}' is not a relative directory".format(package_dir))

    # Get miniver files
    if _miniver_is_installed:
        miniver_paths = extract_miniver_from_local()
    else:
        miniver_paths = extract_miniver_from_github()
    output_paths = [os.path.join(package_dir, os.path.basename(path))
                    for path in miniver_paths]

    for path in output_paths:
        if os.path.exists(path):
            _fail("'{}' already exists".format(path))

    # Write content to local package directory
    for path, output_path in zip(miniver_paths, output_paths):
        shutil.copy(path, output_path)
    _write_content(_static_version_template,
                   os.path.join(package_dir, '_static_version.py'))
    _write_line(_gitattribute_template.format(package_dir=package_dir),
                '.gitattributes')
    _write_line(_init_template.format(package_dir=package_dir),
                os.path.join(package_dir, '__init__.py'))

    msg = '\n'.join(textwrap.wrap(
        "Miniver is installed into '{package_dir}/'. "
        "You still have to copy the following snippet into your 'setup.py':"
    ))
    print('\n'.join((msg, _setup_template)).format(package_dir=package_dir))


if __name__ == '__main__':
    main()
