"""
                     The LLVM Compiler Infrastructure

This file is distributed under the University of Illinois Open Source
License. See LICENSE.TXT for details.

Sync lldb and related source from a local machine to a remote machine.

This facilitates working on the lldb sourcecode on multiple machines
and multiple OS types, verifying changes across all.

Provides helper support for adding lldb test paths to the python path.
"""

from __future__ import print_function
from __future__ import absolute_import

# System modules
import os
import platform
import subprocess
import sys

# Third-party modules

# LLDB modules


def add_lldb_test_paths(check_dir):
    # pylint: disable=line-too-long
    """Adds lldb test-related paths to the python path.

    Starting with the given directory and working upward through
    each parent directory up to the root, it looks for the lldb
    test directory.  When found, the lldb test directory and its
    child test_runner/lib directory will be added to the python
    system path.

    Instructions for use:

    This method supports a simple way of getting pylint to be able
    to reliably lint lldb python test scripts (including the test
    infrastructure itself).  To do so, add the following to a
    .pylintrc file in your home directory:

    [Master]
    init-hook='import os; import sys; sys.path.append(os.path.expanduser("~/path/to/lldb/packages/Python/lldbsuite/test")); import lldb_pylint_helper; lldb_pylint_helper.add_lldb_test_paths(os.getcwd()); print("sys.path={}\n".format(sys.path))'

    Replace ~/path/to/lldb with a valid path to your local lldb source
    tree.  Note you can have multiple lldb source trees on your system, and
    this will work just fine.  The path in your .pylintrc is just needed to
    find the paths needed for pylint in whatever lldb source tree you're in.
    pylint will use the python files in whichever tree it is run from.

    Note it is critical that the init-hook line be contained on a single line.
    You can remove the print line at the end once you know the pythonpath is
    getting set up the way you expect.

    With these changes, you will be able to run the following, for example.

    cd lldb/sourcetree/1-of-many/test/lang/c/anonymous
    pylint TestAnonymous.py

    This will work, and include all the lldb/sourcetree/1-of-many lldb-specific
    python directories to your path.

    You can then run it in another lldb source tree on the same machine like
    so:

    cd lldb/sourcetree/2-of-many/test/functionalities/inferior-assert
    pyline TestInferiorAssert.py

    and this will properly lint that file, using the lldb-specific python
    directories from the 2-of-many source tree.

    Note at the time I'm writing this, our tests are in pretty sad shape
    as far as a stock pylint setup goes.  But we need to start somewhere :-)

    @param check_dir specifies a directory that will be used to start
    looking for the lldb test infrastructure python library paths.
    """
    # Add the test-related packages themselves.
    add_lldb_test_package_paths(check_dir)

    # Add the lldb directory itself
    add_lldb_module_directory()


def add_lldb_module_directory():
    """
    Desired Approach:

    Part A: find an lldb

    1. Walk up the parent chain from the current directory, looking for
    a directory matching *build*.  If we find that, use it as the
    root of a directory search for an lldb[.exe] executable.

    2. If 1 fails, use the path and look for an lldb[.exe] in there.

    If Part A ends up with an lldb, go to part B.  Otherwise, give up
    on the lldb python module path.

    Part B: use the output from 'lldb[.exe] -P' to find the lldb dir.

    Current approach:
    If Darwin, use 'xcrun lldb -P'; others: find lldb on path.

    Drawback to current approach:
    If the tester is changing the SB API (adding new methods), pylint
    will not know about them as it is using the wrong lldb python module.
    In practice, this should be minor.
    """
    try:
        lldb_module_path = None

        if platform.system() == 'Darwin':
            # Use xcrun to find the selected lldb.
            lldb_module_path = subprocess.check_output(["xcrun", "lldb", "-P"])
        elif platform.system() == 'Windows':
            lldb_module_path = subprocess.check_output(
                ["lldb.exe", "-P"], shell=True)
        else:
            # Use the shell to run lldb from the path.
            lldb_module_path = subprocess.check_output(
                ["lldb", "-P"], shell=True)

        # Trim the result.
        if lldb_module_path is not None:
            lldb_module_path = lldb_module_path.strip()

        # If we have a result, add it to the path
        if lldb_module_path is not None and len(lldb_module_path) > 0:
            sys.path.insert(0, lldb_module_path)
    # pylint: disable=broad-except
    except Exception as exception:
        print("failed to find python path: {}".format(exception))


def add_lldb_test_package_paths(check_dir):
    """Adds the lldb test infrastructure modules to the python path.

    See add_lldb_test_paths for more details.

    @param check_dir the directory of the test.
    """

    def child_dirs(parent_dir):
        return [os.path.join(parent_dir, child)
                for child in os.listdir(parent_dir)
                if os.path.isdir(os.path.join(parent_dir, child))]

    check_dir = os.path.realpath(check_dir)
    while check_dir and len(check_dir) > 0:
        # If the current directory contains a packages/Python
        # directory, add that directory to the path.
        packages_python_child_dir = os.path.join(
            check_dir, "packages", "Python")
        if os.path.exists(packages_python_child_dir):
            sys.path.insert(0, packages_python_child_dir)
            sys.path.insert(0, os.path.join(
                packages_python_child_dir, "test_runner", "lib"))

            # Handle third_party module/package directory.
            third_party_module_dir = os.path.join(
                check_dir, "third_party", "Python", "module")
            for child_dir in child_dirs(third_party_module_dir):
                # Yes, we embed the module in the module parent dir
                sys.path.insert(0, child_dir)

            # We're done.
            break

        # Continue looking up the parent chain until we have no more
        # directories to check.
        new_check_dir = os.path.dirname(check_dir)
        # We're done when the new check dir is not different
        # than the current one.
        if new_check_dir == check_dir:
            break
        check_dir = new_check_dir