# 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 os
import platform
import signal
import subprocess
import sys
import time
from itertools import chain

import mozunit
import pytest

from mozlint.errors import LintersNotConfigured, NoValidLinter
from mozlint.result import Issue, ResultSummary
from mozlint.roller import LintRoller

here = os.path.abspath(os.path.dirname(__file__))


def test_roll_no_linters_configured(lint, files):
    with pytest.raises(LintersNotConfigured):
        lint.roll(files)


def test_roll_successful(lint, linters, files):
    lint.read(linters("string", "regex", "external"))

    result = lint.roll(files)
    assert len(result.issues) == 1
    assert result.failed == set([])

    path = list(result.issues.keys())[0]
    assert os.path.basename(path) == "foobar.js"

    errors = result.issues[path]
    assert isinstance(errors, list)
    assert len(errors) == 6

    container = errors[0]
    assert isinstance(container, Issue)
    assert container.rule == "no-foobar"


def test_roll_from_subdir(lint, linters):
    lint.read(linters("string", "regex", "external"))

    oldcwd = os.getcwd()
    try:
        os.chdir(os.path.join(lint.root, "files"))

        # Path relative to cwd works
        result = lint.roll("foobar.js")
        assert len(result.issues) == 1
        assert len(result.failed) == 0
        assert result.returncode == 1

        # Path relative to root doesn't work
        result = lint.roll(os.path.join("files", "foobar.js"))
        assert len(result.issues) == 0
        assert len(result.failed) == 0
        assert result.returncode == 0

        # Paths from vcs are always joined to root instead of cwd
        lint.mock_vcs([os.path.join("files", "foobar.js")])
        result = lint.roll(outgoing=True)
        assert len(result.issues) == 1
        assert len(result.failed) == 0
        assert result.returncode == 1

        result = lint.roll(workdir=True)
        assert len(result.issues) == 1
        assert len(result.failed) == 0
        assert result.returncode == 1

        result = lint.roll(rev='not public() and keyword("dummy revset expression")')
        assert len(result.issues) == 1
        assert len(result.failed) == 0
        assert result.returncode == 1
    finally:
        os.chdir(oldcwd)


def test_roll_catch_exception(lint, linters, files, capfd):
    lint.read(linters("raises"))

    lint.roll(files)  # assert not raises
    out, err = capfd.readouterr()
    assert "LintException" in err


def test_roll_with_global_excluded_path(lint, linters, files):
    lint.exclude = ["**/foobar.js"]
    lint.read(linters("string", "regex", "external"))
    result = lint.roll(files)

    assert len(result.issues) == 0
    assert result.failed == set([])


def test_roll_with_local_excluded_path(lint, linters, files):
    lint.read(linters("excludes"))
    result = lint.roll(files)

    assert "**/foobar.js" in lint.linters[0]["local_exclude"]
    assert len(result.issues) == 0
    assert result.failed == set([])


def test_roll_with_no_files_to_lint(lint, linters, capfd):
    lint.read(linters("string", "regex", "external"))
    lint.mock_vcs([])
    result = lint.roll([], workdir=True)
    assert isinstance(result, ResultSummary)
    assert len(result.issues) == 0
    assert len(result.failed) == 0

    out, err = capfd.readouterr()
    assert "warning: no files linted" in out


def test_roll_with_invalid_extension(lint, linters, filedir):
    lint.read(linters("external"))
    result = lint.roll(os.path.join(filedir, "foobar.py"))
    assert len(result.issues) == 0
    assert result.failed == set([])


def test_roll_with_failure_code(lint, linters, files):
    lint.read(linters("badreturncode"))

    result = lint.roll(files, num_procs=1)
    assert len(result.issues) == 0
    assert result.failed == set(["BadReturnCodeLinter"])


def test_roll_warnings(lint, linters, files):
    lint.read(linters("warning"))
    result = lint.roll(files)
    assert len(result.issues) == 0
    assert result.total_issues == 0
    assert len(result.suppressed_warnings) == 1
    assert result.total_suppressed_warnings == 2

    lint.lintargs["show_warnings"] = True
    result = lint.roll(files)
    assert len(result.issues) == 1
    assert result.total_issues == 2
    assert len(result.suppressed_warnings) == 0
    assert result.total_suppressed_warnings == 0


def test_roll_code_review(monkeypatch, linters, files):
    monkeypatch.setenv("CODE_REVIEW", "1")
    lint = LintRoller(root=here, show_warnings=False)
    lint.read(linters("warning"))
    result = lint.roll(files)
    assert len(result.issues) == 1
    assert result.total_issues == 2
    assert len(result.suppressed_warnings) == 0
    assert result.total_suppressed_warnings == 0
    assert result.returncode == 1


def test_roll_code_review_warnings_disabled(monkeypatch, linters, files):
    monkeypatch.setenv("CODE_REVIEW", "1")
    lint = LintRoller(root=here, show_warnings=False)
    lint.read(linters("warning_no_code_review"))
    result = lint.roll(files)
    assert len(result.issues) == 0
    assert result.total_issues == 0
    assert lint.result.fail_on_warnings is True
    assert len(result.suppressed_warnings) == 1
    assert result.total_suppressed_warnings == 2
    assert result.returncode == 0


def test_roll_code_review_warnings_soft(linters, files):
    lint = LintRoller(root=here, show_warnings="soft")
    lint.read(linters("warning_no_code_review"))
    result = lint.roll(files)
    assert len(result.issues) == 1
    assert result.total_issues == 2
    assert lint.result.fail_on_warnings is False
    assert len(result.suppressed_warnings) == 0
    assert result.total_suppressed_warnings == 0
    assert result.returncode == 0


def fake_run_worker(config, paths, **lintargs):
    result = ResultSummary(lintargs["root"])
    result.issues["count"].append(1)
    return result


@pytest.mark.skipif(
    platform.system() == "Windows",
    reason="monkeypatch issues with multiprocessing on Windows",
)
@pytest.mark.parametrize("num_procs", [1, 4, 8, 16])
def test_number_of_jobs(monkeypatch, lint, linters, files, num_procs):
    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)

    linters = linters("string", "regex", "external")
    lint.read(linters)
    num_jobs = len(lint.roll(files, num_procs=num_procs).issues["count"])

    if len(files) >= num_procs:
        assert num_jobs == num_procs * len(linters)
    else:
        assert num_jobs == len(files) * len(linters)


@pytest.mark.skipif(
    platform.system() == "Windows",
    reason="monkeypatch issues with multiprocessing on Windows",
)
@pytest.mark.parametrize("max_paths,expected_jobs", [(1, 12), (4, 6), (16, 6)])
def test_max_paths_per_job(monkeypatch, lint, linters, files, max_paths, expected_jobs):
    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)

    files = files[:4]
    assert len(files) == 4

    linters = linters("string", "regex", "external")[:3]
    assert len(linters) == 3

    lint.MAX_PATHS_PER_JOB = max_paths
    lint.read(linters)
    num_jobs = len(lint.roll(files, num_procs=2).issues["count"])
    assert num_jobs == expected_jobs


@pytest.mark.skipif(
    platform.system() == "Windows",
    reason="monkeypatch issues with multiprocessing on Windows",
)
@pytest.mark.parametrize("num_procs", [1, 4, 8, 16])
def test_number_of_jobs_global(monkeypatch, lint, linters, files, num_procs):
    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)

    linters = linters("global")
    lint.read(linters)
    num_jobs = len(lint.roll(files, num_procs=num_procs).issues["count"])

    assert num_jobs == 1


@pytest.mark.skipif(
    platform.system() == "Windows",
    reason="monkeypatch issues with multiprocessing on Windows",
)
@pytest.mark.parametrize("max_paths", [1, 4, 16])
def test_max_paths_per_job_global(monkeypatch, lint, linters, files, max_paths):
    monkeypatch.setattr(sys.modules[lint.__module__], "_run_worker", fake_run_worker)

    files = files[:4]
    assert len(files) == 4

    linters = linters("global")[:1]
    assert len(linters) == 1

    lint.MAX_PATHS_PER_JOB = max_paths
    lint.read(linters)
    num_jobs = len(lint.roll(files, num_procs=2).issues["count"])
    assert num_jobs == 1


@pytest.mark.skipif(
    platform.system() == "Windows",
    reason="signal.CTRL_C_EVENT isn't causing a KeyboardInterrupt on Windows",
)
def test_keyboard_interrupt():
    # We use two linters so we'll have two jobs. One (string.yml) will complete
    # quickly. The other (slow.yml) will run slowly.  This way the first worker
    # will be be stuck blocking on the ProcessPoolExecutor._call_queue when the
    # signal arrives and the other still be doing work.
    cmd = [sys.executable, "runcli.py", "-l=string", "-l=slow", "files/foobar.js"]
    env = os.environ.copy()
    env["PYTHONPATH"] = os.pathsep.join(sys.path)
    proc = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        cwd=here,
        env=env,
        universal_newlines=True,
    )
    time.sleep(1)
    proc.send_signal(signal.SIGINT)

    out = proc.communicate()[0]
    print(out)
    assert "warning: not all files were linted" in out
    assert "2 problems" in out
    assert "Traceback" not in out


def test_support_files(lint, linters, filedir, monkeypatch, files):
    jobs = []

    # Replace the original _generate_jobs with a new one that simply
    # adds jobs to a list (and then doesn't return anything).
    orig_generate_jobs = lint._generate_jobs

    def fake_generate_jobs(*args, **kwargs):
        jobs.extend([job[1] for job in orig_generate_jobs(*args, **kwargs)])
        return []

    monkeypatch.setattr(lint, "_generate_jobs", fake_generate_jobs)

    linter_path = linters("support_files")[0]
    lint.read(linter_path)
    lint.root = filedir

    # Modified support files only lint entire root if --outgoing or --workdir
    # are used.
    path = os.path.join(filedir, "foobar.js")
    vcs_path = os.path.join(filedir, "foobar.py")

    lint.mock_vcs([vcs_path])
    lint.roll(path)
    actual_files = sorted(chain(*jobs))
    assert actual_files == [path]

    expected_files = sorted(files)

    jobs = []
    lint.roll(path, workdir=True)
    actual_files = sorted(chain(*jobs))
    assert actual_files == expected_files

    jobs = []
    lint.roll(path, outgoing=True)
    actual_files = sorted(chain(*jobs))
    assert actual_files == expected_files

    jobs = []
    lint.roll(path, rev='draft() and keyword("dummy revset expression")')
    actual_files = sorted(chain(*jobs))
    assert actual_files == expected_files

    # Lint config file is implicitly added as a support file
    lint.mock_vcs([linter_path])
    jobs = []
    lint.roll(path, outgoing=True, workdir=True)
    actual_files = sorted(chain(*jobs))
    assert actual_files == expected_files

    # Avoid linting the entire root when `--fix` is passed.
    lint.mock_vcs([vcs_path])
    lint.lintargs["fix"] = True

    jobs = []
    lint.roll(path, outgoing=True)
    actual_files = sorted(chain(*jobs))
    assert actual_files == sorted([path, vcs_path]), (
        "`--fix` with `--outgoing` on a `support-files` change should "
        "avoid linting the entire root."
    )

    jobs = []
    lint.roll(path, workdir=True)
    actual_files = sorted(chain(*jobs))
    assert actual_files == sorted([path, vcs_path]), (
        "`--fix` with `--workdir` on a `support-files` change should "
        "avoid linting the entire root."
    )

    jobs = []
    lint.roll(path, rev='draft() and keyword("dummy revset expression")')
    actual_files = sorted(chain(*jobs))
    assert actual_files == sorted([path, vcs_path]), (
        "`--fix` with `--rev` on a `support-files` change should "
        "avoid linting the entire root."
    )


def test_setup(lint, linters, filedir, capfd):
    with pytest.raises(NoValidLinter):
        lint.setup()

    lint.read(linters("setup", "setupfailed", "setupraised"))
    lint.setup()
    out, err = capfd.readouterr()
    assert "setup passed" in out
    assert "setup failed" in out
    assert "setup raised" in out
    assert "error: problem with lint setup, skipping" in out
    assert lint.result.failed_setup == set(["SetupFailedLinter", "SetupRaisedLinter"])


if __name__ == "__main__":
    mozunit.main()
