#
# Copyright (C) 2016 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.
#

"""A class to assist with sysroots."""


import os
import shutil


def _FilterHeaders(filename):
    return filename.endswith('.h')


class SysrootUtil(object):
    """A class to assist with setting up sysroots.

    Attributes:
        sysroot - the sysroot this instance helps with.
    """

    # Includes to provide in the sysroot.
    # (lib, recurse, filter)
    DEFAULT_INCLUDES = [
        ('bionic/libc/include', True, _FilterHeaders),
        ('bionic/libc/kernel/uapi/asm-generic/..', True, _FilterHeaders),
        ('bionic/libc/kernel/uapi/linux/..', True, _FilterHeaders),
        ('external/zlib', False, _FilterHeaders),
        ('system/core/include', True, _FilterHeaders)
    ]
    DEFAULT_ARCH_INCLUDES = {
        'arm': [('bionic/libc/kernel/uapi/asm-arm', True, _FilterHeaders),
                ('bionic/libc/arch-arm/include', True, _FilterHeaders)],
        'mips': [('bionic/libc/kernel/uapi/asm-mips', True, _FilterHeaders),
                 ('bionic/libc/arch-mips/include', True, _FilterHeaders)],
        'x86': [('bionic/libc/kernel/uapi/asm-x86', True, _FilterHeaders),
                ('bionic/libc/arch-x86/include', True, _FilterHeaders)],
    }

    # Libs to provide in the sysroot.
    STATIC_PATH_FORMAT = '{0}_intermediates/{0}.a'
    DEFAULT_STATIC_LIBS = ['libc', 'libc++_static', 'libm', 'libz']
    DEFAULT_SHARED_LIBS = ['crtbegin_so.o',
                           'crtbegin_dynamic.o',
                           'crtbegin_static.o',
                           'crtend_android.o',
                           'crtend_so.o',
                           'libc.so',
                           'libc++.so',
                           'libdl.so',
                           'libm.so',
                           'libz.so']

    DEFAULT_LIB_RENAMES = {
        'libc++.so': 'libstdc++.so',
        'libc++_static.a': 'libstdc++.a'
    }

    # Some defaults for where things go.
    DEFAULT_INCLUDE_DIR = os.path.join('usr', 'include')
    DEFAULT_LIB_DIR = os.path.join('usr', 'lib')
    ADDITIONAL_INCLUDE_EXTENSION = 'brillo'

    # Libcxx gets special treatment.
    LIBCXX_HEADERS = 'external/libcxx/include'
    LIBCXX_INCLUDE_DIR = os.path.join(DEFAULT_INCLUDE_DIR, 'c++')

    # pkg-config constants.
    PC_DIR = os.path.join('usr', 'share', 'pkgconfig')
    # For this format:
    # {0} - lib name
    # {1} - version
    # {2} - dependencies
    # {3} - normalized lib name ('lib' prefix removed)
    # Note that if this format changes where to expect things,
    # also change the AddProvidedLib function.
    PC_FILE_FORMAT = ('prefix=/usr\n'
                      'exec_prefix=${{prefix}}\n'
                      'libdir=${{exec_prefix}}/lib\n'
                      'includedir=${{exec_prefix}}/include/' +
                      ADDITIONAL_INCLUDE_EXTENSION + '/{0}\n'
                      '\n'
                      'Name: {0}\n'
                      'Description: {0} for Brillo\n'
                      'Version: {1}\n'
                      'Requires: {2}\n'
                      'Libs: -L${{libdir}} -l{3}\n'
                      'Cflags: -I${{includedir}}\n')

    def __init__(self, sysroot, platform):
        self.sysroot = sysroot
        self.platform = platform

    def _FormatForCopy(self, src, dest):
        """Helper to account for special formatting signals.

        Given a path to copy from and path to copy to, returns a pair suitable
        to input into sysroot.AddDir.

        Special format A/B/.. designates wanting only B when A has several
        subdirs.

        Args:
            src: the path to copy from. Relative to the OS.
            dest: the path to copy to. Relative to the sysroot.

        Returns:
            (result_src, result_dest), src and dest transformed and ready
            to be passed into sysroot.AddDir.
        """
        result_src = self.platform.os.path(src)
        result_dest = dest
        if src.endswith('/..'):
            basename = os.path.basename(src[:-3])
            result_src = os.path.join(result_src, basename)
            result_dest = os.path.join(result_dest, basename)
        return (result_src, result_dest)

    def _AddPkgConfigFile(self, lib, deps, version):
        """Writes a .pc file for a lib in the sysroot.

        Args:
            lib: the name of the library for this .pc file.
            deps: a space separated string of library names this library
                depends on.
            version: the version of this library.

        Raises:
            IOError if the file write fails.
        """
        dest_dir = self.PC_DIR

        normalized_lib = lib
        if lib.startswith('lib'):
            normalized_lib = lib[3:]
        self.sysroot.WriteFile(
            os.path.join(dest_dir, lib + '.pc'),
            self.PC_FILE_FORMAT.format(lib, version, deps, normalized_lib))

    def AddSharedLib(self, lib_src, name, deps, includes, suffix=None):
        """Adds a library to the sysroot.

        Copies in the .so file, copies in includes, and generates a pkg-config
        file.

        Args:
            lib_src: path where prebuilt shared libs can be found.
            name: the name of the library to add.
            deps: a space-separated string of library names lib is dependent on.
            includes: a list of directories with headers for lib.
            suffix: (optional) a suffix to append to the lib name when added
                to the sysroot.

        Raises:
            IOError: If there are any issues adding the necessary files
                to the sysroot.
        """
        suffixed_name = name
        if suffix:
            suffixed_name += '-' + suffix

        # Set up destinations.
        # NOTE: if these change, also update the PC_FILE_FORMAT.
        lib_dest = self.DEFAULT_LIB_DIR
        include_dest = os.path.join(self.DEFAULT_INCLUDE_DIR,
                                    self.ADDITIONAL_INCLUDE_EXTENSION,
                                    suffixed_name)
        self.sysroot.Makedirs(lib_dest)
        self.sysroot.Makedirs(include_dest)

        errors = []

        # Get the .so file.
        try:
            self.sysroot.AddFile(os.path.join(lib_src, name + '.so'),
                                 os.path.join(lib_dest, suffixed_name + '.so'))
        except IOError as e:
            errors.append('.so file: {}'.format(e))

        # Copy includes (.h files only) over to sysroot.
        for include in includes:
            (src, dest) = self._FormatForCopy(include, include_dest)
            try:
                self.sysroot.AddDir(src, dest, filter_func=_FilterHeaders)
            except IOError as e:
                errors.append('include {}: {}'.format(include, e))

        # Write the .pc file.
        try:
            self._AddPkgConfigFile(suffixed_name, deps,
                                   self.platform.os.version)
        except IOError as e:
            errors.append('.pc file: {}'.format(e))

        if errors:
            raise IOError('Failed to add components for {}: {}'.format(
                suffixed_name, errors))

    def AddSharedLibsFromCSV(self, lib_src, csv_file, suffix=None):
        """Add libraries read from a csv file to the sysroot.

        CSV file format is one line header, followed by lines of the form
            libname, deps, include_dirs

        Args:
            lib_src: path where prebuilt shared libs can be found.
            csv_file: path to the file to add libs from.
            suffix: (optional) a suffix to append to all the lib names when
                added to the sysroot.

        Raises:
            IOError: if file can't be found or adding any lib fails.
            ValueError: if any line in the file doesn't meet format
                expectations.
        """
        libs = []
        try:
            with open(csv_file) as pkg_list:
                # Skip the header line
                pkg_list.readline()
                # Read in all the remaining lines
                for line in pkg_list:
                    lib_details = [pkg.strip() for pkg in line.split(',')]
                    if len(lib_details) != 3:
                        raise ValueError(('Line in package csv file "{0}" has '
                                          'the incorrect number of items '
                                          '(expected 3): {1}').format(csv_file,
                                                                      line))
                    libs.append(lib_details)
        except IOError as e:
            raise IOError('Failed to open lib list: {0}'.format(e))

        errors = []
        for (name, deps, include_str) in libs:
            try:
                self.AddSharedLib(lib_src, name, deps, include_str.split(),
                                  suffix)
            except IOError as e:
                errors.append(e)

        if errors:
            raise IOError('Failed to add libs from csv {0}: {1}'.format(
                csv_file, errors))

    def SetupBaseSysroot(self, arch, shared_libs, static_libs,
                         base_sysroot=None):
        """Sets up a sysroot dir from defaults.

        Standard includes and lib files are added to
        <sysroot>/usr/{include, lib}.

        Args:
            arch: the architecture to setup a sysroot for.
            shared_libs: path where prebuilt shared libs can be found.
            static_libs: path where prebuilt static libs can be found.
            base_sysroot: (optional). If provided, copies all files of the
                sysroot found at this path, with priority over other files.

        Raises:
            IOError: if anything fails, specifying which things failed.
        """
        errors = []

        # Copy in includes.
        self.sysroot.Makedirs(self.DEFAULT_INCLUDE_DIR)
        for (include, recurse, filter_func) in (
                self.DEFAULT_INCLUDES + self.DEFAULT_ARCH_INCLUDES[arch]):
            (src, dest) = self._FormatForCopy(include, self.DEFAULT_INCLUDE_DIR)
            try:
                self.sysroot.AddDir(src, dest, recurse, filter_func)
            except IOError as e:
                errors.append('{}: {}'.format(include, e))

        # Handle libcxx.
        (src, dest) = self._FormatForCopy(self.LIBCXX_HEADERS,
                                          self.LIBCXX_INCLUDE_DIR)
        try:
            self.sysroot.AddDir(src, dest)
        except IOError as e:
            errors.append(self.LIBCXX_HEADERS)

        # Copy in libs.
        self.sysroot.Makedirs(self.DEFAULT_LIB_DIR)
        for lib in self.DEFAULT_SHARED_LIBS:
            try:
                self.sysroot.AddFile(os.path.join(shared_libs, lib),
                                     self.DEFAULT_LIB_DIR)
            except IOError as e:
                errors.append(lib)
        for lib in self.DEFAULT_STATIC_LIBS:
            try:
                self.sysroot.AddFile(
                    os.path.join(static_libs,
                                 self.STATIC_PATH_FORMAT.format(lib)),
                    self.DEFAULT_LIB_DIR)
            except IOError as e:
                errors.append(lib)

        # Do some renaming.
        for (src, dest) in self.DEFAULT_LIB_RENAMES.iteritems():
            try:
                shutil.move(self.sysroot.Path(self.DEFAULT_LIB_DIR, src),
                            self.sysroot.Path(self.DEFAULT_LIB_DIR, dest))
            except IOError as e:
                errors.append('rename {0} --> {1}'.format(src, dest))

        # Base our sysroot on another.
        # We do this after copying in defaults to give this base priority.
        if base_sysroot:
            try:
                self.sysroot.AddDir(base_sysroot)
            except IOError as e:
                errors.append(base_sysroot)

        if errors:
            raise IOError(
                'Failed to add {0} during sysroot setup.'.format(errors))