#!/usr/bin/env python3
#
# Copyright (C) 2020 The Android Open Source Project
#
# Licensed 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.
#
"""Unzips and installs the vendor snapshot."""

import argparse
import glob
import logging
import os
import re
import shutil
import subprocess
import sys
import tempfile
import textwrap
import json

INDENT = ' ' * 4


def get_notice_path(module_name):
    return os.path.join('NOTICE_FILES', module_name + '.txt')


def get_target_arch(json_rel_path):
    return json_rel_path.split('/')[0]


def get_arch(json_rel_path):
    return json_rel_path.split('/')[1].split('-')[1]


def get_variation(json_rel_path):
    return json_rel_path.split('/')[2]

# convert .bp prop dictionary to .bp prop string
def gen_bp_prop(prop, ind):
    bp = ''
    for key in sorted(prop):
        val = prop[key]

        # Skip empty list or dict, rather than printing empty prop like
        # "key: []," or "key: {},"
        if type(val) == list and len(val) == 0:
            continue
        if type(val) == dict and gen_bp_prop(val, '') == '':
            continue

        bp += ind + key + ': '
        if type(val) == bool:
            bp += 'true,\n' if val else 'false,\n'
        elif type(val) == str:
            bp += '"%s",\n' % val
        elif type(val) == list:
            bp += '[\n'
            for elem in val:
                bp += ind + INDENT + '"%s",\n' % elem
            bp += ind + '],\n'
        elif type(val) == dict:
            bp += '{\n'
            bp += gen_bp_prop(val, ind + INDENT)
            bp += ind + '},\n'
        else:
            raise TypeError('unsupported type %s for gen_bp_prop' % type(val))
    return bp


# Remove non-existent dirs from given list. Emits warning for such dirs.
def remove_invalid_dirs(paths, bp_dir, module_name):
    ret = []
    for path in paths:
        if os.path.isdir(os.path.join(bp_dir, path)):
            ret.append(path)
        else:
            logging.warning('Dir "%s" of module "%s" does not exist', path,
                            module_name)
    return ret


JSON_TO_BP = {
    'ModuleName': 'name',
    'RelativeInstallPath': 'relative_install_path',
    'ExportedDirs': 'export_include_dirs',
    'ExportedSystemDirs': 'export_system_include_dirs',
    'ExportedFlags': 'export_flags',
    'Sanitize': 'sanitize',
    'SanitizeMinimalDep': 'sanitize_minimal_dep',
    'SanitizeUbsanDep': 'sanitize_ubsan_dep',
    'Symlinks': 'symlinks',
    'InitRc': 'init_rc',
    'VintfFragments': 'vintf_fragments',
    'SharedLibs': 'shared_libs',
    'RuntimeLibs': 'runtime_libs',
    'Required': 'required',
}

SANITIZER_VARIANT_PROPS = {
    'export_include_dirs',
    'export_system_include_dirs',
    'export_flags',
    'sanitize_minimal_dep',
    'sanitize_ubsan_dep',
    'src',
}

EXPORTED_FLAGS_PROPS = {
    'export_include_dirs',
    'export_system_include_dirs',
    'export_flags',
}


# Converts parsed json dictionary (which is intermediate) to Android.bp prop
# dictionary. This validates paths such as include directories and init_rc
# files while converting.
def convert_json_to_bp_prop(json_path, bp_dir):
    prop = json.load(json_path)
    ret = {}

    module_name = prop['ModuleName']
    ret['name'] = module_name

    # Soong will complain about non-existing paths on Android.bp. There might
    # be missing files among generated header files, so check all exported
    # directories and filter out invalid ones. Emits warning for such dirs.
    # TODO: fix soong to track all generated headers correctly
    for key in {'ExportedDirs', 'ExportedSystemDirs'}:
        if key in prop:
            prop[key] = remove_invalid_dirs(prop[key], bp_dir, module_name)

    for key in prop:
        if key in JSON_TO_BP:
            ret[JSON_TO_BP[key]] = prop[key]
        else:
            logging.warning('Unknown prop "%s" of module "%s"', key,
                            module_name)

    return ret

def is_64bit_arch(arch):
    return '64' in arch # arm64, x86_64

def remove_keys_from_dict(keys, d):
    # May contain subdictionaries (e.g. cfi), so recursively erase
    for k in list(d.keys()):
        if k in keys:
            del d[k]
        elif type(d[k]) == dict:
            remove_keys_from_dict(keys, d[k])

def reexport_vndk_header(name, arch_props):
    remove_keys_from_dict(EXPORTED_FLAGS_PROPS, arch_props)
    for arch in arch_props:
        arch_props[arch]['shared_libs'] = [name]
        arch_props[arch]['export_shared_lib_headers'] = [name]

def gen_bp_module(image, variation, name, version, target_arch, vndk_list, arch_props, bp_dir):
    # Generate Android.bp module for given snapshot.
    # If a vndk library with the same name exists, reuses exported flags of the vndk library,
    # instead of the snapshot's own flags.
    prop = {
        # These three are common for all snapshot modules.
        'version': str(version),
        'target_arch': target_arch,
        image: True,
        'arch': {},
    }

    reexport_vndk_name = name
    if reexport_vndk_name == "libc++_static":
        reexport_vndk_name = "libc++"

    if reexport_vndk_name in vndk_list:
        if variation == 'shared':
            logging.error("Module %s is both vendor snapshot shared and vndk" % name)
        reexport_vndk_header(reexport_vndk_name, arch_props)

    # Factor out common prop among architectures to minimize Android.bp.
    common_prop = None
    for arch in arch_props:
        if common_prop is None:
            common_prop = dict()
            for k in arch_props[arch]:
                common_prop[k] = arch_props[arch][k]
            continue
        for k in list(common_prop.keys()):
            if k not in arch_props[arch] or common_prop[k] != arch_props[arch][k]:
                del common_prop[k]

    # Some keys has to be arch_props to prevent 32-bit only modules from being
    # used as 64-bit modules, and vice versa.
    for arch_prop_key in ['src', 'cfi']:
        if arch_prop_key in common_prop:
            del common_prop[arch_prop_key]
    prop.update(common_prop)

    has32 = has64 = False
    stem32 = stem64 = ''

    for arch in arch_props:
        for k in common_prop:
            if k in arch_props[arch]:
                del arch_props[arch][k]
        prop['arch'][arch] = arch_props[arch]

        has64 |= is_64bit_arch(arch)
        has32 |= not is_64bit_arch(arch)

        # Record stem for snapshots.
        # We don't check existence of 'src'; src must exist for executables
        if variation == 'binary':
            if is_64bit_arch(arch):
                stem64 = os.path.basename(arch_props[arch]['src'])
            else:
                stem32 = os.path.basename(arch_props[arch]['src'])

    # header snapshots doesn't need compile_multilib. The other snapshots,
    # shared/static/object/binary snapshots, do need them
    if variation != 'header':
        if has32 and has64:
            prop['compile_multilib'] = 'both'
        elif has32:
            prop['compile_multilib'] = '32'
        elif has64:
            prop['compile_multilib'] = '64'
        else:
            raise RuntimeError("Module %s doesn't have prebuilts." % name)

    # For binary snapshots, prefer 64bit if their stem collide and installing
    # both is impossible
    if variation == 'binary' and stem32 == stem64:
        prop['compile_multilib'] = 'first'

    bp = '%s_snapshot_%s {\n' % (image, variation)
    bp += gen_bp_prop(prop, INDENT)
    bp += '}\n\n'
    return bp

def get_vndk_list(vndk_dir, target_arch):
    """Generates vndk_libs list, e.g. ['libbase', 'libc++', ...]
    This list is retrieved from vndk_dir/target_arch/configs/module_names.txt.
    If it doesn't exist, print an error message and return an empty list.
    """

    module_names_path = os.path.join(vndk_dir, target_arch, 'configs/module_names.txt')

    try:
        with open(module_names_path, 'r') as f:
            """The format of module_names.txt is a list of "{so_name} {module_name}", e.g.

                lib1.so lib1
                lib2.so lib2
                ...

            We extract the module name part.
            """
            return [l.split()[1] for l in f.read().strip('\n').split('\n')]
    except IOError as e:
        logging.error('Failed to read %s: %s' % (module_names_path, e.strerror))
    except IndexError as e:
        logging.error('Failed to parse %s: invalid format' % module_names_path)

    return []

def gen_bp_list_module(image, snapshot_version, vndk_list, target_arch, arch_props):
    """Generates a {image}_snapshot module which contains lists of snapshots.
    For vendor snapshot, vndk list is also included, extracted from vndk_dir.
    """

    bp = '%s_snapshot {\n' % image

    bp_props = dict()
    bp_props['name'] = '%s_snapshot' % image
    bp_props['version'] = str(snapshot_version)
    if image == 'vendor':
        bp_props['vndk_libs'] = vndk_list

    variant_to_property = {
        'shared': 'shared_libs',
        'static': 'static_libs',
        'header': 'header_libs',
        'binary': 'binaries',
        'object': 'objects',
    }

    # arch_bp_prop[arch][variant_prop] = list
    # e.g. arch_bp_prop['x86']['shared_libs'] == ['libfoo', 'libbar', ...]
    arch_bp_prop = dict()

    # Gather module lists per arch.
    # arch_props structure: arch_props[variant][module_name][arch]
    # e.g. arch_props['shared']['libc++']['x86']
    for variant in arch_props:
        variant_name = variant_to_property[variant]
        for name in arch_props[variant]:
            for arch in arch_props[variant][name]:
                if arch not in arch_bp_prop:
                    arch_bp_prop[arch] = dict()
                if variant_name not in arch_bp_prop[arch]:
                    arch_bp_prop[arch][variant_name] = []
                arch_bp_prop[arch][variant_name].append(name)

    bp_props['arch'] = arch_bp_prop
    bp += gen_bp_prop(bp_props, INDENT)

    bp += '}\n\n'
    return bp

def build_props(install_dir):
    # props[target_arch]["static"|"shared"|"binary"|"header"][name][arch] : json
    props = dict()

    # {target_arch}/{arch}/{variation}/{module}.json
    for root, _, files in os.walk(install_dir, followlinks = True):
        for file_name in sorted(files):
            if not file_name.endswith('.json'):
                continue
            full_path = os.path.join(root, file_name)
            rel_path = os.path.relpath(full_path, install_dir)

            target_arch = get_target_arch(rel_path)
            arch = get_arch(rel_path)
            variation = get_variation(rel_path)
            bp_dir = os.path.join(install_dir, target_arch)

            if not target_arch in props:
                props[target_arch] = dict()
            if not variation in props[target_arch]:
                props[target_arch][variation] = dict()

            with open(full_path, 'r') as f:
                prop = convert_json_to_bp_prop(f, bp_dir)
                # Remove .json after parsing?
                # os.unlink(full_path)

            if variation != 'header':
                prop['src'] = os.path.relpath(
                    rel_path[:-5],  # removing .json
                    target_arch)

            module_name = prop['name']

            # Is this sanitized variant?
            if 'sanitize' in prop:
                sanitizer_type = prop['sanitize']
                # module_name is {name}.{sanitizer_type}; trim sanitizer_type
                module_name = module_name[:-len(sanitizer_type) - 1]
                # Only leave props for the sanitize variant
                for k in list(prop.keys()):
                    if not k in SANITIZER_VARIANT_PROPS:
                        del prop[k]
                prop = {'name': module_name, sanitizer_type: prop}

            notice_path = 'NOTICE_FILES/' + module_name + '.txt'
            if os.path.exists(os.path.join(bp_dir, notice_path)):
                prop['notice'] = notice_path

            variation_dict = props[target_arch][variation]
            if not module_name in variation_dict:
                variation_dict[module_name] = dict()
            if not arch in variation_dict[module_name]:
                variation_dict[module_name][arch] = prop
            else:
                variation_dict[module_name][arch].update(prop)

    return props


def gen_bp_files(image, vndk_dir, install_dir, snapshot_version):
    """Generates Android.bp for each archtecture.
    Android.bp will contain a {image}_snapshot module having lists of VNDK and
    vendor snapshot libraries, and {image}_snapshot_{variant} modules which are
    prebuilt libraries of the snapshot.

    Args:
      image: string, name of partition (e.g. 'vendor', 'recovery')
      vndk_dir: string, directory to which vndk snapshot is installed
      install_dir: string, directory to which the snapshot will be installed
      snapshot_version: int, version of the snapshot
    """
    props = build_props(install_dir)

    for target_arch in sorted(props):
        androidbp = ''
        bp_dir = os.path.join(install_dir, target_arch)
        vndk_list = []
        if image == 'vendor':
            vndk_list = get_vndk_list(vndk_dir, target_arch)

        # Generate snapshot modules.
        for variation in sorted(props[target_arch]):
            for name in sorted(props[target_arch][variation]):
                androidbp += gen_bp_module(image, variation, name,
                                           snapshot_version, target_arch,
                                           vndk_list,
                                           props[target_arch][variation][name],
                                           bp_dir)

        # Generate {image}_snapshot module which contains the list of modules.
        androidbp += gen_bp_list_module(image, snapshot_version, vndk_list,
                                        target_arch, props[target_arch])
        with open(os.path.join(bp_dir, 'Android.bp'), 'w') as f:
            logging.info('Generating Android.bp to: {}'.format(f.name))
            f.write(androidbp)


def find_all_installed_files(install_dir):
    installed_files = dict()
    for root, _, files in os.walk(install_dir, followlinks = True):
        for file_name in sorted(files):
            if file_name.endswith('.json'):
                continue
            if file_name.endswith('Android.bp'):
                continue
            full_path = os.path.join(root, file_name)
            size = os.stat(full_path).st_size
            installed_files[full_path] = size

    logging.debug('')
    for f in sorted(installed_files.keys()):
        logging.debug(f)
    logging.debug('')
    logging.debug('found {} installed files'.format(len(installed_files)))
    logging.debug('')
    return installed_files


def find_files_in_props(target_arch, arch_install_dir, variation, name, props, file_to_info):
    logging.debug('{} {} {} {} {}'.format(
        target_arch, arch_install_dir, variation, name, props))

    def add_info(file, name, variation, arch, is_cfi, is_header):
        info = (name, variation, arch, is_cfi, is_header)
        info_list = file_to_info.get(file)
        if not info_list:
            info_list = []
            file_to_info[file] = info_list
        info_list.append(info)

    def find_file_in_list(dict, key, is_cfi):
        list = dict.get(key)
        logging.debug('    {} {}'.format(key, list))
        if list:
            for item in list:
                item_path = os.path.join(arch_install_dir, item)
                add_info(item_path, name, variation, arch, is_cfi, False)

    def find_file_in_dirs(dict, key, is_cfi, is_header):
        dirs = dict.get(key)
        logging.debug('    {} {}'.format(key, dirs))
        if dirs:
            for dir in dirs:
                dir_path = os.path.join(arch_install_dir, dir)
                logging.debug('        scanning {}'.format(dir_path))
                for root, _, files in os.walk(dir_path, followlinks = True):
                    for file_name in sorted(files):
                        item_path = os.path.join(root, file_name)
                        add_info(item_path, name, variation, arch, is_cfi, is_header)

    def find_file_in_dict(dict, is_cfi):
        logging.debug('    arch {}'.format(arch))
        logging.debug('    name {}'.format( name))
        logging.debug('    is_cfi {}'.format(is_cfi))

        src = dict.get('src')
        logging.debug('    src {}'.format(src))
        if src:
            src_path = os.path.join(arch_install_dir, src)
            add_info(src_path, name, variation, arch, is_cfi, False)

        notice = dict.get('notice')
        logging.debug('    notice {}'.format(notice))
        if notice:
            notice_path = os.path.join(arch_install_dir, notice)
            add_info(notice_path, name, variation, arch, is_cfi, False)

        find_file_in_list(dict, 'init_rc', is_cfi)
        find_file_in_list(dict, 'vintf_fragments', is_cfi)

        find_file_in_dirs(dict, 'export_include_dirs', is_cfi, True)
        find_file_in_dirs(dict, 'export_system_include_dirs', is_cfi, True)

    for arch in sorted(props):
        name = props[arch]['name']
        find_file_in_dict(props[arch], False)
        cfi = props[arch].get('cfi')
        if cfi:
            find_file_in_dict(cfi, True)


def find_all_props_files(install_dir):

    # This function builds a database of filename to module. This means that we
    # need to dive into the json to find the files that the vendor snapshot
    # provides, and link these back to modules that provide them.

    file_to_info = dict()

    props = build_props(install_dir)
    for target_arch in sorted(props):
        arch_install_dir = os.path.join(install_dir, target_arch)
        for variation in sorted(props[target_arch]):
            for name in sorted(props[target_arch][variation]):
                find_files_in_props(
                    target_arch,
                    arch_install_dir,
                    variation,
                    name,
                    props[target_arch][variation][name],
                    file_to_info)

    logging.debug('')
    for f in sorted(file_to_info.keys()):
        logging.debug(f)
    logging.debug('')
    logging.debug('found {} props files'.format(len(file_to_info)))
    logging.debug('')
    return file_to_info


def get_ninja_inputs(ninja_binary, ninja_build_file, modules):
    """Returns the set of input file path strings for the given modules.

    Uses the `ninja -t inputs` tool.

    Args:
        ninja_binary: The path to a ninja binary.
        ninja_build_file: The path to a .ninja file from a build.
        modules: The list of modules to scan for inputs.
    """
    inputs = set()
    cmd = [
        ninja_binary,
        "-f",
        ninja_build_file,
        "-t",
        "inputs",
        "-d",
    ] + list(modules)
    logging.debug('invoke ninja {}'.format(cmd))
    inputs = inputs.union(set(
        subprocess.check_output(cmd).decode().strip("\n").split("\n")))

    return inputs


def check_module_usage(install_dir, ninja_binary, image, ninja_file, goals,
                       output):
    all_installed_files = find_all_installed_files(install_dir)
    all_props_files = find_all_props_files(install_dir)

    ninja_inputs = get_ninja_inputs(ninja_binary, ninja_file, goals)
    logging.debug('')
    logging.debug('ninja inputs')
    for ni in ninja_inputs:
        logging.debug(ni)

    logging.debug('found {} ninja_inputs for goals {}'.format(
        len(ninja_inputs), goals))

    # Intersect the file_to_info dict with the ninja_inputs to determine
    # which items from the vendor snapshot are actually used by the goals.

    total_size = 0
    used_size = 0
    used_file_to_info = dict()

    for file, size in all_installed_files.items():
        total_size += size
        if file in ninja_inputs:
            logging.debug('used: {}'.format(file))
            used_size += size
            info = all_props_files.get(file)

            if info:
                used_file_to_info[file] = info
            else:
                logging.warning('No info for file {}'.format(file))
                used_file_to_info[file] = 'no info'

    logging.debug('Total size {}'.format(total_size))
    logging.debug('Used size {}'.format(used_size))
    logging.debug('')
    logging.debug('used items')

    used_modules = set()

    for f, i in sorted(used_file_to_info.items()):
        logging.debug('{} {}'.format(f, i))
        for m in i:
            (name, variation, arch, is_cfi, is_header) = m
            if not is_header:
                used_modules.add(name)

    with open(output, 'w') as f:
        f.write('%s_SNAPSHOT_MODULES := \\\n' % image.upper())
        for m in sorted(used_modules):
            f.write('  %s \\\n' % m)

def check_call(cmd):
    logging.debug('Running `{}`'.format(' '.join(cmd)))
    subprocess.check_call(cmd)


def fetch_artifact(branch, build, target, pattern, destination):
    """Fetches build artifacts from Android Build server.

    Args:
      branch: string, branch to pull build artifacts from
      build: string, build number to pull build artifacts from
      target: string, target name to pull build artifacts from
      pattern: string, pattern of build artifact file name
      destination: string, destination to pull build artifact to
    """
    fetch_artifact_path = '/google/data/ro/projects/android/fetch_artifact'
    cmd = [
        fetch_artifact_path, '--branch', branch, '--target', target, '--bid',
        build, pattern, destination
    ]
    check_call(cmd)

def install_artifacts(image, branch, build, target, local_dir, symlink,
                      install_dir):
    """Installs vendor snapshot build artifacts to {install_dir}/v{version}.

    1) Fetch build artifacts from Android Build server or from local_dir
    2) Unzip or create symlinks to build artifacts

    Args:
      image: string, img file for which the snapshot was created (vendor,
             recovery, etc.)
      branch: string or None, branch name of build artifacts
      build: string or None, build number of build artifacts
      target: string or None, target name of build artifacts
      local_dir: string or None, local dir to pull artifacts from
      symlink: boolean, whether to use symlinks instead of unzipping the
        vendor snapshot zip
      install_dir: string, directory to install vendor snapshot
      temp_artifact_dir: string, temp directory to hold build artifacts fetched
        from Android Build server. For 'local' option, is set to None.
    """
    artifact_pattern = image + '-*.zip'

    def unzip_artifacts(artifact_dir):
        artifacts = glob.glob(os.path.join(artifact_dir, artifact_pattern))
        for artifact in artifacts:
            logging.info('Unzipping Vendor snapshot: {}'.format(artifact))
            check_call(['unzip', '-qn', artifact, '-d', install_dir])

    if branch and build and target:
        with tempfile.TemporaryDirectory() as tmpdir:
            logging.info(
                'Fetching {pattern} from {branch} (bid: {build}, target: {target})'
                .format(
                    pattern=artifact_pattern,
                    branch=branch,
                    build=build,
                    target=target))
            fetch_artifact(branch, build, target, artifact_pattern, tmpdir)
            unzip_artifacts(tmpdir)
    elif local_dir:
        if symlink:
            # This assumes local_dir is the location of vendor-snapshot in the
            # build (e.g., out/soong/vendor-snapshot).
            #
            # Create the first level as proper directories and the next level
            # as symlinks.
            for item1 in os.listdir(local_dir):
                dest_dir = os.path.join(install_dir, item1)
                src_dir = os.path.join(local_dir, item1)
                if os.path.isdir(src_dir):
                    check_call(['mkdir', '-p', dest_dir])
                    # Create symlinks.
                    for item2 in os.listdir(src_dir):
                        src_item = os.path.join(src_dir, item2)
                        logging.info('Creating symlink from {} in {}'.format(
                            src_item, dest_dir))
                        os.symlink(src_item, os.path.join(dest_dir, item2))
        else:
            logging.info('Fetching local VNDK snapshot from {}'.format(
                local_dir))
            unzip_artifacts(local_dir)
    else:
        raise RuntimeError('Neither local nor remote fetch information given.')

def get_args():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'snapshot_version',
        type=int,
        help='Vendor snapshot version to install, e.g. "30".')
    parser.add_argument(
        '--image',
        help=('Image whose snapshot is being updated (e.g., vendor, '
              'recovery , ramdisk, etc.)'),
        default='vendor')
    parser.add_argument('--branch', help='Branch to pull build from.')
    parser.add_argument('--build', help='Build number to pull.')
    parser.add_argument('--target', help='Target to pull.')
    parser.add_argument(
        '--local',
        help=('Fetch local vendor snapshot artifacts from specified local '
              'directory instead of Android Build server. '
              'Example: --local /path/to/local/dir'))
    parser.add_argument(
        '--symlink',
        action='store_true',
        help='Use symlinks instead of unzipping vendor snapshot zip')
    parser.add_argument(
        '--install-dir',
        required=True,
        help=(
            'Base directory to which vendor snapshot artifacts are installed. '
            'Example: --install-dir vendor/<company name>/vendor_snapshot/v30'))
    parser.add_argument(
        '--overwrite',
        action='store_true',
        help=(
            'If provided, does not ask before overwriting the install-dir.'))
    parser.add_argument(
        '--check-module-usage',
        action='store_true',
        help='Check which modules are used.')
    parser.add_argument(
        '--check-module-usage-goal',
        action='append',
        help='Goal(s) for which --check-module-usage is calculated.')
    parser.add_argument(
        '--check-module-usage-ninja-file',
        help='Ninja file for which --check-module-usage is calculated.')
    parser.add_argument(
        '--check-module-usage-output',
        help='File to which to write the check-module-usage results.')
    parser.add_argument(
        '--vndk-dir',
        help='Path to installed vndk snapshot directory. Needed to retrieve '
             'the list of VNDK. prebuilts/vndk/v{ver} will be used by default.')

    parser.add_argument(
        '-v',
        '--verbose',
        action='count',
        default=0,
        help='Increase output verbosity, e.g. "-v", "-vv".')
    return parser.parse_args()


def main():
    """Program entry point."""
    args = get_args()

    verbose_map = (logging.WARNING, logging.INFO, logging.DEBUG)
    verbosity = min(args.verbose, 2)
    logging.basicConfig(
        format='%(levelname)-8s [%(filename)s:%(lineno)d] %(message)s',
        level=verbose_map[verbosity])

    if not args.install_dir:
        raise ValueError('Please provide --install-dir option.')
    install_dir = os.path.expanduser(args.install_dir)

    if args.check_module_usage:
        ninja_binary = './prebuilts/build-tools/linux-x86/bin/ninja'

        if not args.check_module_usage_goal:
            raise ValueError('Please provide --check-module-usage-goal option.')
        if not args.check_module_usage_ninja_file:
            raise ValueError(
                'Please provide --check-module-usage-ninja-file option.')
        if not args.check_module_usage_output:
            raise ValueError(
                'Please provide --check-module-usage-output option.')

        check_module_usage(install_dir, ninja_binary, args.image,
                           args.check_module_usage_ninja_file,
                           args.check_module_usage_goal,
                           args.check_module_usage_output)
        return

    local = None
    if args.local:
        local = os.path.expanduser(args.local)

    if local:
        if args.build or args.branch or args.target:
            raise ValueError(
                'When --local option is set, --branch, --build or --target cannot be '
                'specified.')
        elif not os.path.isdir(local):
            raise RuntimeError(
                'The specified local directory, {}, does not exist.'.format(
                    local))
    else:
        if not (args.build and args.branch and args.target):
            raise ValueError(
                'Please provide --branch, --build and --target. Or set --local '
                'option.')

    snapshot_version = args.snapshot_version

    if os.path.exists(install_dir):
        def remove_dir():
            logging.info('Removing {}'.format(install_dir))
            check_call(['rm', '-rf', install_dir])
        if args.overwrite:
            remove_dir()
        else:
            resp = input('Directory {} already exists. IT WILL BE REMOVED.\n'
                         'Are you sure? (yes/no): '.format(install_dir))
            if resp == 'yes':
                remove_dir()
            elif resp == 'no':
                logging.info('Cancelled snapshot install.')
                return
            else:
                raise ValueError('Did not understand: ' + resp)
    check_call(['mkdir', '-p', install_dir])

    if args.vndk_dir:
        vndk_dir = os.path.expanduser(args.vndk_dir)
    else:
        vndk_dir = 'prebuilts/vndk/v%d' % snapshot_version
        logging.debug('Using %s for vndk directory' % vndk_dir)

    install_artifacts(
        image=args.image,
        branch=args.branch,
        build=args.build,
        target=args.target,
        local_dir=local,
        symlink=args.symlink,
        install_dir=install_dir)
    gen_bp_files(args.image, vndk_dir, install_dir, snapshot_version)

if __name__ == '__main__':
    main()