#
# 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 describing a sysroot."""


import glob
import os
import shutil


class Sysroot(object):
    """A wrapper around basic os/file system operations as pertains to a
    sysroot.

    Provides access to copying in files to a sysroot, making directories, or
    writing new files without needing to know exactly where the sysroot is
    based.

    Attributes:
        path - The path at which the sysroot is based.
        copy_newer_only - only copy files if the src is newer.
    """

    def __init__(self, path, copy_newer_only=False):
        self.path = path
        if not os.path.isdir(path):
            os.makedirs(path)
        self._copy_newer_only = copy_newer_only

    def Destroy(self):
        """Remove the sysroot and all subdirs."""
        shutil.rmtree(self.path)

    def __str__(self):
        return self.path

    def Path(self, *args):
        """Get an absolute path given a path relative to the sysroot."""
        return os.path.join(self.path, *args)

    def Makedirs(self, *path):
        """Make directories under the sysroot.

        Only creates directories if they don't already exist.
        """
        if not self.HasDir(*path):
            os.makedirs(self.Path(*path))

    def HasDir(self, *path):
        """Checks if the sysroot has a given directory."""
        return os.path.isdir(self.Path(*path))

    def _src_is_newer(self, src, real_dest):
        """Returns True is the src should replace the dest."""
        if self._copy_newer_only == False:
            return True
        # If the src doesn't exist, we force the copy such that
        # the caller can raise the appropriate exception.
        if not os.path.exists(src):
            return True
        if not os.path.exists(real_dest):
            return True
        src_st = os.stat(src)
        return src_st.st_mtime - os.stat(real_dest).st_mtime > 0

    def _copy_times(self, src, real_dest):
        """Nearly synchronizes the atime and mtime of the src and dest.

        To enable reliable copy_newer_only behavior, we always set
        the mtime to 1 second later than the original to offset
        precision issues. Because of those issues, it is beneficial
        to call _copy_times even after copy2 or copystat.
        """
        if os.path.islink(src):
            # Until os.futime/os.lutime, symlink times cannot be changed.
            return
        src_st = os.lstat(src)
        os.utime(real_dest, (src_st.st_atime, src_st.st_mtime + 1))

    def AddFile(self, src, dest=''):
        """Copies a file from src to dest.

        Args:
            src: the file to copy.
            dest: where to copy to. If a directory, uses the filename from src.
                The dest directory must already exist.
        Raises:
            IOError if the copy fails.
        """

        try:
            tgt = self.Path(dest)
            if self._src_is_newer(src, tgt):
                shutil.copy2(src, tgt)
                self._copy_times(src, tgt)
        except (IOError, OSError) as e:
            raise IOError(('Failed to add file {0} to '
                           'sysroot {1} dest {2}: {3}').format(
                               src, self, dest, e))

    def AddSymlink(self, src, dest=''):
        """Creates a symlink at dest using src.

        Args:
            src - the symlink to copy.
            dest - where to create a symlink. If a directory, uses the filename
                from src.  The dest directory must already exist.

        Raises:
            IOError if the symlink fails.
        """
        try:
            tgt = self.Path(dest)
            if self._src_is_newer(src, tgt):
                linkto = os.readlink(src)
                os.symlink(linkto, tgt)
        except (IOError, OSError) as e:
            raise IOError(('Failed to add symlink {0} to '
                           'sysroot {1} dest {2}: {3}').format(
                               src, self, dest, e))

    def AddDir(self, src, dest='', recurse=True, filter_func=None,
               symlinks=False):
        """Copies all folders and files from external src to dest in sysroot.

        This function does not use shutil.copytree since that function
        does not support copying (and merging) into existing folders, but
        the implementation is based on the copytree implementation provided
        in the python documentation.

        Does not require dest dir to exist.

        Args:
            src - dir to copy files from (absolute path)
            dest - (optional) dir to copy files to (relative to self.path).
                Default ''.
            recurse - (optional) True to recursively add subdirs. Default True.
            filter - (optional) a function for filenames that returns true if
                the file should be copied, false otherwise. Default identity
                function.
            symlinks - (optional) True to copy symlinks as symlinks. Default
                False.

        Returns:
            List of added files

        Raises:
            IOError if any part of the copy fails.
        """
        # Default filter is to not filter anything.
        filter_func = filter_func or bool

        # Copy the dir.
        self.Makedirs(dest)
        shutil.copystat(src, self.Path(dest))

        # Copy the files.
        names = os.listdir(src)
        errors = []
        added = []
        for name in names:
            srcname = os.path.join(src, name)
            destname = os.path.join(dest, name)
            try:
                if symlinks and os.path.islink(srcname):
                    self.AddSymlink(srcname, destname)
                    added.append(destname)
                elif os.path.isdir(srcname):
                    if recurse:
                        added += self.AddDir(srcname, destname, recurse,
                                             filter_func, symlinks)
                elif filter_func(name):
                    added.append(destname)
                    self.AddFile(srcname, destname)
            except IOError as e:
                errors.append('Failed to copy {0} to {1}: {2}'.format(srcname,
                                                                      destname,
                                                                      e))

        if errors:
            raise IOError(str(errors))
        return added

    def AddGlob(self, src, dest='', recurse=False, filter_func=None,
                symlinks=False):
        """Copies matching folders and files from external src to dest in
        sysroot.

        This function uses AddDir and AddFile above.

        Does not require dest dir to exist.

        Args:
            src - glob to copy files from (absolute glob path)
            dest - (optional) dir to copy files to (relative to self.path).
                Default ''.
            recurse - (optional) True to recursively add subdirs. Default False.
            filter - (optional) a function for filenames that returns true if
                the file should be copied, false otherwise. Default identity
                function.
            symlinks - (optional) True to copy symlinks as symlinks. Default
                False.

        Returns:
            List of added files

        Raises:
            IOError if any part of the copy fails.
        """
        # Default filter is to not filter anything.
        filter_func = filter_func or bool

        added = []
        for srcname in glob.glob(src):
            name = os.path.basename(srcname)
            destname = os.path.join(dest, name)
            if symlinks and os.path.islink(srcname):
                if filter_func(name):
                    self.AddSymlink(srcname, destname)
                    added.append(destname)
            elif os.path.isdir(srcname):
                if recurse:
                    added += self.AddDir(srcname, destname, recurse=True,
                                         symlinks=symlinks)
            elif filter_func(name):
                added.append(destname)
                self.Makedirs(os.path.dirname(destname))
                self.AddFile(srcname, destname)

        if len(added) == 0:
            raise IOError(('Failed to add glob {0} to '
                           'sysroot {1} dest {2}: no matching files').format(
                               src, self, dest))

        return added

    def WriteFile(self, dest, contents):
        """Write a new file in the sysroot.

        Args:
            dest - the path (relative to the sysroot) to add the file to.
            contents - the desired contents of the file.
        Raises:
            IOError if the write fails.
        """
        try:
            self.Makedirs(os.path.dirname(dest))
            with open(self.Path(dest), 'w') as f:
                f.write(contents)
        except IOError as e:
            raise IOError('Failed to write file {1} in sysroot {2}: {3}'.format(
                dest, self, e))