# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

import json
import os
from json.decoder import JSONDecodeError

import mozpack.path as mozpath
from mozfile import which
from mozlint import result
from mozlint.util.implementation import LintProcess
from mozpack.files import FileFinder

SHELLCHECK_NOT_FOUND = """
Unable to locate shellcheck, please ensure it is installed and in
your PATH or set the SHELLCHECK environment variable.

https://shellcheck.net or your system's package manager.
""".strip()

results = []


class ShellcheckProcess(LintProcess):
    def process_line(self, line):
        try:
            data = json.loads(line)
        except JSONDecodeError as e:
            print(f"Unable to load shellcheck output ({e}): {line}")
            return

        for entry in data:
            res = {
                "path": entry["file"],
                "message": entry["message"],
                "level": "error",
                "lineno": entry["line"],
                "column": entry["column"],
                "rule": entry["code"],
            }
            results.append(result.from_config(self.config, **res))


def determine_shell_from_script(path):
    """Returns a string identifying the shell used.

    Returns None if not identifiable.

    Copes with the following styles:
    #!bash
    #!/bin/bash
    #!/usr/bin/env bash
    """
    with open(path) as f:
        head = f.readline()

        if not head.startswith("#!"):
            return

        # allow for parameters to the shell
        shebang = head.split()[0]

        # if the first entry is a variant of /usr/bin/env
        if "env" in shebang:
            shebang = head.split()[1]

        if shebang.endswith("sh"):
            # Strip first to avoid issues with #!bash
            return shebang.strip("#!").split("/")[-1]
    # make it clear we return None, rather than fall through.
    return


def find_shell_scripts(config, paths):
    found = dict()

    root = config["root"]
    exclude = [mozpath.join(root, e) for e in config.get("exclude", [])]

    if config.get("extensions"):
        pattern = "**/*.{}".format(config.get("extensions")[0])
    else:
        pattern = "**/*.sh"

    files = []
    for path in paths:
        path = mozpath.normsep(path)
        ignore = [
            e[len(path) :].lstrip("/")
            for e in exclude
            if mozpath.commonprefix((path, e)) == path
        ]
        finder = FileFinder(path, ignore=ignore)
        files.extend([os.path.join(path, p) for p, f in finder.find(pattern)])

    for filename in files:
        shell = determine_shell_from_script(filename)
        if shell:
            found[filename] = shell
    return found


def run_process(config, cmd):
    proc = ShellcheckProcess(config, cmd)
    proc.run()
    try:
        proc.wait()
    except KeyboardInterrupt:
        proc.kill()


def get_shellcheck_binary():
    """
    Returns the path of the first shellcheck binary available
    if not found returns None
    """
    binary = os.environ.get("SHELLCHECK")
    if binary:
        return binary

    return which("shellcheck")


def lint(paths, config, **lintargs):
    log = lintargs["log"]
    binary = get_shellcheck_binary()

    if not binary:
        print(SHELLCHECK_NOT_FOUND)
        if "MOZ_AUTOMATION" in os.environ:
            return 1
        return []

    config["root"] = lintargs["root"]

    files = find_shell_scripts(config, paths)

    base_command = [binary, "-f", "json"]
    if config.get("excludecodes"):
        base_command.extend(["-e", ",".join(config.get("excludecodes"))])

    for f in files:
        cmd = list(base_command)
        cmd.extend(["-s", files[f], f])
        log.debug(f"Command: {cmd}")
        run_process(config, cmd)
    return results
