#!/usr/bin/env python2.7
# Copyright 2019 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.

import errno
import json
import os
import re
import subprocess

from process import Process


class BuildEnv(object):
    """Represents a local build environment for Fuchsia.

    This class abstracts various repository, tool, and build details.

    Attributes:
      fuchsia_dir:      Path to Fuchsia source checkout.
      cli:              Associated CLI object.
      build_dir:        Path to the Fuchsia build output.
      symbolizer_exec:  Path to the Fuchsia symbolizer executable.
      llvm_symbolizer:  Path to the LLVM/Clang symbolizer library.
      build_id_dirs:    List of paths to symbolizer debug symbols.
      gsutil:           Path to the Google Cloud Storage utility.
  """

    def __init__(self, host, fuchsia_dir):
        assert host, 'Host not set.'
        if not fuchsia_dir:
            host.error(
                'FUCHSIA_DIR not set.', 'Have you sourced "scripts/fx-env.sh"?')
        self._fuchsia_dir = fuchsia_dir
        self._host = host
        self._build_dir = None
        self._symbolizer_exec = None
        self._llvm_symbolizer = None
        self._build_id_dirs = None
        self._gsutil = None
        self._fuzzers = []

    @property
    def fuchsia_dir(self):
        return self._fuchsia_dir

    @property
    def host(self):
        return self._host

    @property
    def build_dir(self):
        assert self._build_dir, 'Build directory not set'
        return self._build_dir

    @property
    def symbolizer_exec(self):
        assert self._symbolizer_exec, 'Symbolizer executable not set.'
        return self._symbolizer_exec

    @symbolizer_exec.setter
    def symbolizer_exec(self, symbolizer_exec):
        if not self.host.isfile(symbolizer_exec):
            self.host.error(
                'Invalid symbolizer executable: {}'.format(symbolizer_exec))
        self._symbolizer_exec = symbolizer_exec

    @property
    def llvm_symbolizer(self):
        assert self._llvm_symbolizer, 'LLVM symbolizer not set.'
        return self._llvm_symbolizer

    @llvm_symbolizer.setter
    def llvm_symbolizer(self, llvm_symbolizer):
        if not self.host.isfile(llvm_symbolizer):
            self.host.error(
                'Invalid LLVM symbolizer: {}'.format(llvm_symbolizer))
        self._llvm_symbolizer = llvm_symbolizer

    @property
    def build_id_dirs(self):
        assert self._build_id_dirs, 'Build ID directories not set.'
        return self._build_id_dirs

    @build_id_dirs.setter
    def build_id_dirs(self, build_id_dirs):
        for build_id_dir in build_id_dirs:
            if not self.host.isdir(build_id_dir):
                self.host.error(
                    'Invalid build ID directory: {}'.format(build_id_dir))
        self._build_id_dirs = build_id_dirs

    @property
    def gsutil(self):
        if not self._gsutil:
            try:
                self._gsutil = self.create_process(['which',
                                                    'gsutil']).check_output()
            except subprocess.CalledProcessError:
                self.host.error(
                    'Unable to find gsutil.',
                    'Try installing the Google Cloud SDK.')
        return self._gsutil

    @gsutil.setter
    def gsutil(self, gsutil):
        if not self.host.isfile(gsutil):
            self.host.error('Invalid GS utility: {}'.format(gsutil))
        self._gsutil = gsutil

    # Initialization routines

    def configure(self, build_dir):
        """Sets multiple properties based on the given build directory."""
        self._build_dir = self.path(build_dir)
        clang_dir = os.path.join(
            'prebuilt', 'third_party', 'clang', self.host.platform)
        self.symbolizer_exec = self.path(build_dir, 'host_x64', 'symbolize')
        self.llvm_symbolizer = self.path(clang_dir, 'bin', 'llvm-symbolizer')
        self.build_id_dirs = [
            self.path(clang_dir, 'lib', 'debug', '.build-id'),
            self.path(build_dir, '.build-id'),
            self.path(build_dir + '.zircon', '.build-id'),
        ]

    def add_fuzzer(self, package, executable):
        self._fuzzers.append((package, executable))

    def read_fuzzers(self, pathname):
        """Parses the available fuzzers from an fuzzers.json pathname."""
        with self.host.open(pathname, on_error=[
                'Failed to read fuzzers from {}.'.format(pathname),
                'Have you run "fx set ... --fuzz-with <sanitizer>"?'
        ]) as opened:
            fuzz_specs = json.load(opened)
        for fuzz_spec in fuzz_specs:
            package = fuzz_spec['fuzzers_package']
            for executable in fuzz_spec['fuzzers']:
                self._fuzzers.append((package, executable))

    def fuzzers(self, name=None):
        """Returns a (possibly filtered) list of fuzzer names.

        Takes a list of fuzzer names in the form `package`/`executable` and a name to filter
        on.  If the name is of the form 'x/y', the filtered list will include all
        the fuzzer names where 'x' is a substring of `package` and y is a substring
        of `executable`; otherwise it includes all the fuzzer names where `name` is a
        substring of either `package` or `executable`.

        Returns:
            A list of fuzzer names matching the given name.

        Raises:
            ValueError: Name is malformed, e.g. of the form 'x/y/z'.
    """
        if not name or name == '':
            return self._fuzzers
        names = name.split('/')
        if len(names) == 2 and (names[0], names[1]) in self._fuzzers:
            return [(names[0], names[1])]
        if len(names) == 1:
            as_package = set(self.fuzzers(name + '/'))
            as_executable = set(self.fuzzers('/' + name))
            return sorted(list(as_package | as_executable))
        elif len(names) != 2:
            raise ValueError('Malformed fuzzer name: ' + name)
        filtered = []
        for package, executable in self._fuzzers:
            if names[0] in package and names[1] in executable:
                filtered.append((package, executable))
        return sorted(filtered)

    # Other routines

    def path(self, *segments):
        """Returns absolute path to a path in the build environment."""
        joined = os.path.join(*segments)
        if not joined.startswith(self.fuchsia_dir):
            joined = os.path.join(self.fuchsia_dir, joined)
        return joined

    def find_device(self, device_name=None):
        """Returns the IPv6 address for a device."""
        cmd = [self.path('.jiri_root', 'bin', 'fx'), 'device-finder']
        if device_name:
            cmd += ['resolve', '-device-limit', '1', device_name]
        else:
            cmd += ['list']
        addrs = self.host.create_process(cmd).check_output().strip()
        if not addrs:
            self.host.error('Unable to find device.', 'Try "fx set-device".')
        addrs = addrs.split('\n')
        if len(addrs) != 1:
            self.host.error('Multiple devices found.', 'Try "fx set-device".')
        return addrs[0]

    def symbolize(self, raw):
        """Symbolizes backtraces in a log file using the current build.

        Attributes:
            raw: Bytes representing unsymbolized lines.

        Returns:
            Bytes representing symbolized lines.
        """
        cmd = [self.symbolizer_exec, '-llvm-symbolizer', self.llvm_symbolizer]
        for build_id_dir in self.build_id_dirs:
            cmd += ['-build-id-dir', build_id_dir]
        process = self.host.create_process(cmd)
        process.stdin = subprocess.PIPE
        process.stdout = subprocess.PIPE
        popened = process.popen()
        out, _ = popened.communicate(raw)
        if popened.returncode != 0:
            out = ''
        return re.sub(r'[0-9\[\]\.]*\[klog\] INFO: ', '', out)