# Copyright 2016 The Chromium 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 GSUtilApi(recipe_api.RecipeApi):
    """GSUtilApi provides support for GSUtil."""

    @recipe_api.non_step
    def join(self, *parts):
        """Constructs a GS path from composite parts."""
        return "/".join(p.strip("/") for p in parts)

    def upload_namespaced_file(
        self,
        source,
        bucket,
        subpath,
        namespace=None,
        metadata=None,
        no_clobber=True,
        unauthenticated_url=False,
        **kwargs,
    ):
        """Uploads a file to GCS under a subpath specific to the given build.

        Will upload the file to:
        gs://<bucket>/<build id>/<subpath or basename of file>

        Args:
            source (Path): A path to the file to upload.
            bucket (str): The name of the GCS bucket to upload to.
            subpath (str): The end of the destination path within the
                build-specific subdirectory.
            namespace (str or None): A unique ID for this build. Defaults to the
                current build ID or led run ID.
            metadata (dict): A dictionary of metadata values to upload along
                with the file.
            no_clobber (bool): Skip upload if destination path already exists in
                GCS.
            unauthenticated_url (bool): Whether to present a URL that requires
                no authentication in the GCP web UI.
        """
        kwargs.setdefault("link_name", subpath)
        return self.upload(
            bucket=bucket,
            src=source,
            dst=self.namespaced_gcs_path(subpath, namespace),
            metadata=metadata,
            no_clobber=no_clobber,
            unauthenticated_url=unauthenticated_url,
            name=f"upload {subpath} to {bucket}",
            **kwargs,
        )

    def upload_namespaced_directory(
        self, source, bucket, subpath, namespace=None, rsync=True, **kwargs
    ):
        """Uploads a directory to GCS under a subpath specific to the given build.

        Will upload the directory to:
        gs://<bucket>/<build id>/<subpath>

        Args:
            source (Path): A path to the file to upload.
            bucket (str): The name of the GCS bucket to upload to.
            subpath (str): The end of the destination path within the
                build-specific subdirectory.
            namespace (str or None): A unique ID for this build. Defaults to the
                current build ID or led run ID.
            rsync (bool): Whether to use rsync, which is idempotent but
                sometimes less reliable.
        """
        kwargs.setdefault("link_name", subpath)
        func = self.upload
        if rsync:
            func = self.rsync
        return func(
            bucket=bucket,
            src=source,
            dst=self.namespaced_gcs_path(subpath, namespace),
            recursive=True,
            multithreaded=True,
            no_clobber=True,
            name=f"upload {subpath} to {bucket}",
            **kwargs,
        )

    def namespaced_gcs_path(self, relative_path, namespace=None):
        if not namespace:
            namespace = self.m.buildbucket_util.id
        return f"builds/{namespace}/{relative_path}"

    def http_url(self, bucket, dest, unauthenticated_url=False):
        base = (
            "https://storage.googleapis.com"
            if unauthenticated_url
            else "https://storage.cloud.google.com"
        )
        return f"{base}/{bucket}/{self.m.url.quote(dest)}"

    def _directory_listing_url(self, bucket, dest):
        """Returns the URL for a GCS bucket subdirectory listing in the GCP console."""
        return (
            f"https://console.cloud.google.com/storage/browser/{bucket}/"
            f"{self.m.url.quote(dest)}"
        )

    def namespaced_directory_url(self, bucket, subpath="", namespace=None):
        return self._directory_listing_url(
            bucket,
            self.namespaced_gcs_path(subpath, namespace),
        )

    @staticmethod
    def _get_metadata_field(name, provider_prefix=None):
        """Returns: (str) the metadata field to use with Google Storage

        The Google Storage specification for metadata can be found at:
        https://developers.google.com/storage/docs/gsutil/addlhelp/WorkingWithObjectMetadata
        """
        # Already contains custom provider prefix
        if name.lower().startswith("x-"):
            return name

        # See if it's innately supported by Google Storage
        if name in (
            "Cache-Control",
            "Content-Disposition",
            "Content-Encoding",
            "Content-Language",
            "Content-MD5",
            "Content-Type",
            "Custom-Time",
        ):
            return name

        # Add provider prefix
        if not provider_prefix:
            provider_prefix = "x-goog-meta"
        return f"{provider_prefix}-{name}"

    @staticmethod
    def unauthenticated_url(url):
        """Transform an authenticated URL to an unauthenticated URL."""
        return url.replace(
            "https://storage.cloud.google.com/", "https://storage.googleapis.com/"
        )

    def _add_custom_time(self, metadata):
        if not metadata:
            metadata = {}
        metadata["Custom-Time"] = self.m.time.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
        return metadata

    def upload(
        self,
        bucket,
        src,
        dst,
        link_name="gsutil.upload",
        unauthenticated_url=False,
        recursive=False,
        no_clobber=False,
        gzip_exts=(),
        **kwargs,
    ):
        kwargs["metadata"] = self._add_custom_time(kwargs.pop("metadata", {}))
        args = ["cp"]
        if recursive:
            args.append("-r")
        if no_clobber:
            args.append("-n")
        if gzip_exts:
            args.extend(["-j"] + gzip_exts)
        args.extend([src, f"gs://{bucket}/{dst}"])
        if not recursive or no_clobber:
            # gsutil supports resumable uploads if we run the same command
            # again, but it's only safe to resume uploading if we're only
            # uploading a single file, or if we're operating in no_clobber mode.
            step = self.m.utils.retry(
                lambda: self._run(*args, **kwargs),
                max_attempts=3,
            )
        else:
            step = self._run(*args, **kwargs)
        if link_name:
            link_url = self.http_url(
                bucket, dst, unauthenticated_url=unauthenticated_url
            )
            step.presentation.links[link_name] = link_url
        return step

    def rsync(
        self,
        bucket,
        src,
        dst,
        link_name="gsutil.rsync",
        recursive=True,
        no_clobber=False,
        gzip_exts=(),
        **kwargs,
    ):
        kwargs["metadata"] = self._add_custom_time(kwargs.pop("metadata", {}))
        args = ["rsync"]
        if recursive:
            args.append("-r")
        if no_clobber:
            # This will skip files already existing in dst with a later
            # timestamp.
            args.append("-u")
        if gzip_exts:
            args.extend(["-j"] + gzip_exts)
        args.extend([src, f"gs://{bucket}/{dst}"])
        step = self.m.utils.retry(lambda: self._run(*args, **kwargs), max_attempts=3)
        if link_name:
            link_url = self._directory_listing_url(bucket, dst)
            step.presentation.links[link_name] = link_url
        return step

    def copy(
        self,
        src_bucket,
        src,
        dst_bucket,
        dst,
        link_name="gsutil.copy",
        unauthenticated_url=False,
        recursive=False,
        **kwargs,
    ):
        args = ["cp"]
        if recursive:
            args.append("-r")
        args.extend([f"gs://{src_bucket}/{src}", f"gs://{dst_bucket}/{dst}"])
        step = self._run(*args, **kwargs)
        if link_name:
            step.presentation.links[link_name] = self.http_url(
                dst_bucket, dst, unauthenticated_url=unauthenticated_url
            )
        return step

    def download(self, src_bucket, src, dest, recursive=False, **kwargs):
        """Downloads gcs bucket file to local disk.

        Args:
            src_bucket (str): gcs bucket name.
            src (str): gcs file or path name.
            recursive (bool): bool to indicate to copy recursively.
            dest (str): local file path root to copy to.
        """
        args = ["cp"]
        if recursive:
            args.append("-r")
        args.extend([f"gs://{src_bucket}/{src}", dest])
        return self._run(*args, **kwargs)

    @property
    def _gsutil_tool(self):
        return self.m.ensure_tool("gsutil", self.resource("tool_manifest.json"))

    def _run(self, *args, **kwargs):
        """Return a step to run arbitrary gsutil command."""
        assert self._gsutil_tool
        name = kwargs.pop("name", "gsutil " + args[0])
        infra_step = kwargs.pop("infra_step", True)
        cmd_prefix = [self._gsutil_tool]
        # Note that metadata arguments have to be passed before the command.
        metadata = kwargs.pop("metadata", [])
        if metadata:
            for k, v in sorted(metadata.items()):
                field = self._get_metadata_field(k)
                param = (field) if v is None else (f"{field}:{v}")
                cmd_prefix.extend(["-h", param])
        options = kwargs.pop("options", {})
        options["software_update_check_period"] = 0
        if options:
            for k, v in sorted(options.items()):
                cmd_prefix.extend(["-o", f"GSUtil:{k}={v}"])
        if kwargs.pop("multithreaded", False):
            cmd_prefix.extend(["-m"])

        # The `gsutil` executable is a Python script with a shebang, and Windows
        # doesn't support shebangs so we have to run it via Python.
        step_func = self.m.python3 if self.m.platform.is_win else self.m.step
        return step_func(name, cmd_prefix + list(args), infra_step=infra_step, **kwargs)