# Copyright 2017 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from recipe_engine import recipe_api


class TarApi(recipe_api.RecipeApi):
    """Provides steps to tar and untar files."""

    COMPRESSION_OPTS = ["gzip", "bzip2", "xz", "lzma"]

    def __call__(self, step_name, cmd):
        full_cmd = [self._bsdtar_path] + list(cmd)
        return self.m.step(step_name, full_cmd)

    @property
    def _bsdtar_path(self):
        """Ensures that bsdtar is installed."""
        return self.m.ensure_tool("bsdtar", self.resource("tool_manifest.json"))

    def create(self, path, compression=None):
        """Returns TarArchive object that can be used to compress a set of files.

        Args:
          path: path of the archive file to be created.
          compression: str, one of COMPRESSION_OPTS or None to disable compression.
        """
        assert not compression or compression in TarApi.COMPRESSION_OPTS, (
            "compression must be one of %s",
            TarApi.COMPRESSION_OPTS,
        )
        return TarArchive(self.m, path, compression)

    def extract(self, step_name, path, directory=None, strip_components=None):
        """Uncompress |archive| file.

        Args:
          step_name: name of the step.
          path: absolute path to archive file.
          directory: directory to extract the archive in.
          strip_components: strip number of leading components from file names.
        """
        # We use long-form options whenever possible, but for options with
        # arguments, we have to use the short form. The recipe engine tests require
        # objects which might be placeholders (in this case |path|) to be their own
        # argument, and the version of tar we're using doesn't support
        # '--long-opt arg'. It only supports '--long-opt=arg' or short-form like
        # '-s arg'.
        cmd = [
            "--extract",
            "--verbose",
            "-f",
            path,
        ]
        if directory:
            cmd.extend(["-C", directory])
        if strip_components:
            cmd.extend(["--strip-components", str(int(strip_components))])
        return self(step_name, cmd)


class TarArchive:
    """Used to gather a list of files to tar."""

    def __init__(self, api, path, compression):
        self._api = api
        self._path = path
        self._compression = compression
        self._entries = {}

    @property
    def path(self):
        return self._path

    def add(self, path, directory=None):
        """Stages single file to be added to the package.

        Args:
          path: absolute path to a file, should be a child of |directory|.
          directory: ancestor directory of |path|. The name of the file
              inside the archive will not include |directory|. Defaults to $CWD.
        """
        if not directory:
            directory = self._api.context.cwd
        assert directory.is_parent_of(
            path
        ), "directory must be a parent of path. directory: %s.%s, path: %s.%s" % (
            directory.base,
            directory.pieces,
            path.base,
            path.pieces,
        )
        self._entries.setdefault(str(directory), []).append(str(path))

    def tar(self, step_name):
        """Step to tar all staged files."""
        cmd = ["--create", "-f", self._path]
        if self._compression:
            cmd.append("--%s" % self._compression)
        for directory in sorted(self._entries):
            cmd.extend(
                ["-C", directory]
                + [
                    self._api.path.relpath(p, directory)
                    for p in self._entries[directory]
                ]
            )

        step_result = self._api.tar(step_name, cmd)
        self._api.path.mock_add_paths(self._path)
        return step_result