# pylint: disable=missing-function-docstring

"""Test for diff_cover.git_diff"""

import pytest

from diff_cover.command_runner import CommandError
from diff_cover.git_diff import GitDiffTool


@pytest.fixture
def process(mocker):
    process_ = mocker.Mock()
    process_.returncode = 0
    return process_


@pytest.fixture(autouse=True)
def subprocess(mocker, process):
    subprocess_ = mocker.patch("diff_cover.command_runner.subprocess")
    subprocess_.Popen.return_value = process
    return subprocess_


@pytest.fixture
def tool():
    return GitDiffTool(range_notation="...", ignore_whitespace=False)


@pytest.fixture
def set_git_diff_output(process):
    def _inner(stdout, stderr, returncode=0):
        process.communicate.return_value = (stdout, stderr)
        process.returncode = returncode

    return _inner


@pytest.fixture
def check_diff_committed(subprocess, set_git_diff_output):
    def _inner(diff_range_notation, ignore_whitespace):
        tool_ = GitDiffTool(
            range_notation=diff_range_notation, ignore_whitespace=ignore_whitespace
        )

        set_git_diff_output("test output", "")
        output = tool_.diff_committed()

        # Expect that we get the correct output
        assert output == "test output"

        # Expect that the correct command was executed
        expected = [
            "git",
            "-c",
            "diff.mnemonicprefix=no",
            "-c",
            "diff.noprefix=no",
            "diff",
            "--no-color",
            "--no-ext-diff",
            "-U0",
        ]
        if ignore_whitespace:
            expected.append("--ignore-all-space")
            expected.append("--ignore-blank-lines")
        expected.append(f"origin/main{diff_range_notation}HEAD")
        subprocess.Popen.assert_called_with(
            expected, stdout=subprocess.PIPE, stderr=subprocess.PIPE
        )

    return _inner


def test_diff_committed(check_diff_committed):
    check_diff_committed("...", ignore_whitespace=False)
    check_diff_committed("...", ignore_whitespace=True)
    check_diff_committed("..", ignore_whitespace=False)
    check_diff_committed("..", ignore_whitespace=True)


def test_diff_unstaged(set_git_diff_output, tool, subprocess):
    set_git_diff_output("test output", "")
    output = tool.diff_unstaged()

    # Expect that we get the correct output
    assert output == "test output"

    # Expect that the correct command was executed
    expected = [
        "git",
        "-c",
        "diff.mnemonicprefix=no",
        "-c",
        "diff.noprefix=no",
        "diff",
        "--no-color",
        "--no-ext-diff",
        "-U0",
    ]
    subprocess.Popen.assert_called_with(
        expected, stdout=subprocess.PIPE, stderr=subprocess.PIPE
    )


def test_diff_staged(tool, subprocess, set_git_diff_output):
    set_git_diff_output("test output", "")
    output = tool.diff_staged()

    # Expect that we get the correct output
    assert output == "test output"

    # Expect that the correct command was executed
    expected = [
        "git",
        "-c",
        "diff.mnemonicprefix=no",
        "-c",
        "diff.noprefix=no",
        "diff",
        "--no-color",
        "--no-ext-diff",
        "-U0",
        "--cached",
    ]
    subprocess.Popen.assert_called_with(
        expected, stdout=subprocess.PIPE, stderr=subprocess.PIPE
    )


def test_diff_missing_branch_error(set_git_diff_output, tool, subprocess):
    # Override the default compare branch
    set_git_diff_output("test output", "fatal error", 1)
    with pytest.raises(CommandError):
        tool.diff_committed(compare_branch="release")

    set_git_diff_output(
        "test output",
        "ambiguous argument 'origin/main...HEAD': "
        "unknown revision or path not in the working tree.",
        1,
    )
    with pytest.raises(ValueError):
        tool.diff_committed(compare_branch="release")


def test_diff_committed_compare_branch(set_git_diff_output, tool, subprocess):
    # Override the default compare branch
    set_git_diff_output("test output", "")
    output = tool.diff_committed(compare_branch="release")

    # Expect that we get the correct output
    assert output == "test output"

    # Expect that the correct command was executed
    expected = [
        "git",
        "-c",
        "diff.mnemonicprefix=no",
        "-c",
        "diff.noprefix=no",
        "diff",
        "--no-color",
        "--no-ext-diff",
        "-U0",
        "release...HEAD",
    ]
    subprocess.Popen.assert_called_with(
        expected, stdout=subprocess.PIPE, stderr=subprocess.PIPE
    )


def test_errors(set_git_diff_output, tool):
    set_git_diff_output("test output", "fatal error", 1)

    with pytest.raises(CommandError):
        tool.diff_unstaged()

    with pytest.raises(CommandError):
        tool.diff_staged()

    with pytest.raises(CommandError):
        tool.diff_unstaged()


@pytest.mark.parametrize(
    "output,expected",
    [
        ("", []),
        ("\n", []),
        ("a.py\n", ["a.py"]),
        ("a.py\nb.py\n", ["a.py", "b.py"]),
    ],
)
def test_untracked(tool, set_git_diff_output, output, expected):
    set_git_diff_output(output, b"")
    assert tool.untracked() == expected