"""E2E tests for upstream verification during version command."""

from __future__ import annotations

import contextlib
from pathlib import PureWindowsPath
from typing import TYPE_CHECKING, cast

import pytest
from git import Repo
from pytest_lazy_fixtures.lazy_fixture import lf as lazy_fixture

from semantic_release.hvcs.github import Github

from tests.const import MAIN_PROG_NAME, VERSION_SUBCMD
from tests.fixtures.example_project import change_to_ex_proj_dir
from tests.fixtures.repos.trunk_based_dev import (
    repo_w_trunk_only_conventional_commits,
)
from tests.fixtures.repos.trunk_based_dev.repo_w_tags import (
    build_trunk_only_repo_w_tags,
)
from tests.util import (
    add_text_to_file,
    assert_exit_code,
    assert_successful_exit_code,
    temporary_working_directory,
)

if TYPE_CHECKING:
    from pathlib import Path

    from requests_mock import Mocker

    from tests.conftest import RunCliFn
    from tests.fixtures.example_project import ExProjectDir, UpdatePyprojectTomlFn
    from tests.fixtures.git_repo import (
        BuildSpecificRepoFn,
        CommitConvention,
        GetCfgValueFromDefFn,
        GetGitRepo4DirFn,
        GetVersionsFromRepoBuildDefFn,
    )


@pytest.mark.parametrize(
    "repo_fixture_name, build_repo_fn",
    [
        (
            repo_fixture_name,
            lazy_fixture(build_repo_fn_name),
        )
        for repo_fixture_name, build_repo_fn_name in [
            (
                repo_w_trunk_only_conventional_commits.__name__,
                build_trunk_only_repo_w_tags.__name__,
            ),
        ]
    ],
)
@pytest.mark.usefixtures(change_to_ex_proj_dir.__name__)
def test_version_upstream_check_success_no_changes(
    repo_fixture_name: str,
    run_cli: RunCliFn,
    build_repo_fn: BuildSpecificRepoFn,
    example_project_dir: ExProjectDir,
    git_repo_for_directory: GetGitRepo4DirFn,
    post_mocker: Mocker,
    get_cfg_value_from_def: GetCfgValueFromDefFn,
    get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
    pyproject_toml_file: Path,
    update_pyproject_toml: UpdatePyprojectTomlFn,
):
    remote_name = "origin"
    # Create a bare remote (simulating origin)
    local_origin = Repo.init(str(example_project_dir / "local_origin"), bare=True)

    # build target repo into a temporary directory
    target_repo_dir = example_project_dir / repo_fixture_name
    commit_type: CommitConvention = (
        repo_fixture_name.split("commits", 1)[0].split("_")[-2]  # type: ignore[assignment]
    )
    target_repo_definition = build_repo_fn(
        repo_name=repo_fixture_name,
        commit_type=commit_type,
        dest_dir=target_repo_dir,
    )
    target_git_repo = git_repo_for_directory(target_repo_dir)

    # Configure the source repo to use the bare remote (removing any existing 'origin')
    with contextlib.suppress(AttributeError):
        target_git_repo.delete_remote(target_git_repo.remotes[remote_name])

    target_git_repo.create_remote(remote_name, str(local_origin.working_dir))

    # Remove last release before pushing to upstream
    tag_format_str = cast(
        "str", get_cfg_value_from_def(target_repo_definition, "tag_format_str")
    )
    latest_tag = tag_format_str.format(
        version=get_versions_from_repo_build_def(target_repo_definition)[-1]
    )
    target_git_repo.git.tag("-d", latest_tag)
    target_git_repo.git.reset("--hard", "HEAD~1")

    # TODO: when available, switch this to use hvcs=none or similar config to avoid token use for push
    update_pyproject_toml(
        "tool.semantic_release.remote.ignore_token_for_push",
        True,
        target_repo_dir / pyproject_toml_file,
    )
    target_git_repo.git.commit(amend=True, no_edit=True, all=True)

    # push the current state to establish the remote (cannot push tags and branches at the same time)
    target_git_repo.git.push(remote_name, all=True)  # all branches
    target_git_repo.git.push(remote_name, tags=True)  # all tags

    # ensure bare remote HEAD points to the active branch so clones can checkout
    local_origin.git.symbolic_ref(
        "HEAD", f"refs/heads/{target_git_repo.active_branch.name}"
    )

    # current remote tags
    remote_origin_tags_before = {tag.name for tag in local_origin.tags}

    # Clone the repo to simulate a local workspace
    test_repo = Repo.clone_from(
        f"file://{local_origin.working_dir}",
        str(example_project_dir / "repo_clone"),
        no_local=True,
    )
    with test_repo.config_writer("repository") as config:
        config.set_value("core", "hookspath", "")
        config.set_value("commit", "gpgsign", False)
        config.set_value("tag", "gpgsign", False)

    current_head_sha = test_repo.head.commit.hexsha

    # Act: run PSR on the cloned repo - it should verify upstream and succeed
    with temporary_working_directory(str(test_repo.working_dir)):
        cli_cmd = [MAIN_PROG_NAME, "--strict", VERSION_SUBCMD]
        result = run_cli(cli_cmd[1:], env={Github.DEFAULT_ENV_TOKEN_NAME: "1234"})

    remote_origin_tags_after = {tag.name for tag in local_origin.tags}

    # Evaluate
    assert_successful_exit_code(result, cli_cmd)

    # Verify release occurred as expected
    with test_repo:
        assert latest_tag in test_repo.tags, "Expected release tag to be created"
        assert current_head_sha in [
            parent.hexsha for parent in test_repo.head.commit.parents
        ], "Expected new commit to be created on HEAD"
        different_tags = remote_origin_tags_after.difference(remote_origin_tags_before)
        assert latest_tag in different_tags, "Expected new tag to be pushed to remote"

    # Verify VCS release was created
    expected_vcs_url_post = 1
    assert expected_vcs_url_post == post_mocker.call_count  # one vcs release created


@pytest.mark.parametrize(
    "repo_fixture_name, build_repo_fn",
    [
        (
            repo_fixture_name,
            lazy_fixture(build_repo_fn_name),
        )
        for repo_fixture_name, build_repo_fn_name in [
            (
                repo_w_trunk_only_conventional_commits.__name__,
                build_trunk_only_repo_w_tags.__name__,
            ),
        ]
    ],
)
@pytest.mark.usefixtures(change_to_ex_proj_dir.__name__)
def test_version_upstream_check_success_no_changes_untracked_branch(
    repo_fixture_name: str,
    run_cli: RunCliFn,
    build_repo_fn: BuildSpecificRepoFn,
    example_project_dir: ExProjectDir,
    git_repo_for_directory: GetGitRepo4DirFn,
    post_mocker: Mocker,
    get_cfg_value_from_def: GetCfgValueFromDefFn,
    get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
    pyproject_toml_file: Path,
    update_pyproject_toml: UpdatePyprojectTomlFn,
):
    """Test that PSR succeeds when the upstream branch is untracked but unchanged."""
    remote_name = "origin"
    # Create a bare remote (simulating origin)
    local_origin = Repo.init(str(example_project_dir / "local_origin"), bare=True)

    # build target repo into a temporary directory
    target_repo_dir = example_project_dir / repo_fixture_name
    commit_type: CommitConvention = (
        repo_fixture_name.split("commits", 1)[0].split("_")[-2]  # type: ignore[assignment]
    )
    target_repo_definition = build_repo_fn(
        repo_name=repo_fixture_name,
        commit_type=commit_type,
        dest_dir=target_repo_dir,
    )
    target_git_repo = git_repo_for_directory(target_repo_dir)

    # Configure the source repo to use the bare remote (removing any existing 'origin')
    with contextlib.suppress(AttributeError):
        target_git_repo.delete_remote(target_git_repo.remotes[remote_name])

    target_git_repo.create_remote(remote_name, str(local_origin.working_dir))

    # Remove last release before pushing to upstream
    tag_format_str = cast(
        "str", get_cfg_value_from_def(target_repo_definition, "tag_format_str")
    )
    latest_tag = tag_format_str.format(
        version=get_versions_from_repo_build_def(target_repo_definition)[-1]
    )
    target_git_repo.git.tag("-d", latest_tag)
    target_git_repo.git.reset("--hard", "HEAD~1")

    # TODO: when available, switch this to use hvcs=none or similar config to avoid token use for push
    update_pyproject_toml(
        "tool.semantic_release.remote.ignore_token_for_push",
        True,
        target_repo_dir / pyproject_toml_file,
    )
    target_git_repo.git.commit(amend=True, no_edit=True, all=True)

    # push the current state to establish the remote (cannot push tags and branches at the same time)
    target_git_repo.git.push(remote_name, all=True)  # all branches
    target_git_repo.git.push(remote_name, tags=True)  # all tags

    # ensure bare remote HEAD points to the active branch so clones can checkout
    local_origin.git.symbolic_ref(
        "HEAD", f"refs/heads/{target_git_repo.active_branch.name}"
    )

    # Simulate CI environment after someone pushes to the repo
    ci_commit_sha = target_git_repo.head.commit.hexsha
    ci_branch = target_git_repo.active_branch.name

    # current remote tags
    remote_origin_tags_before = {tag.name for tag in local_origin.tags}

    # Simulate a CI environment by fetching the repo to a new location
    test_repo = Repo.init(str(example_project_dir / "ci_repo"))
    with test_repo.config_writer("repository") as config:
        config.set_value("core", "hookspath", "")
        config.set_value("commit", "gpgsign", False)
        config.set_value("tag", "gpgsign", False)

    # Configure and retrieve the repository (see GitHub actions/checkout@v5)
    test_repo.git.remote(
        "add",
        remote_name,
        f"file:///{PureWindowsPath(local_origin.working_dir).as_posix()}",
    )
    test_repo.git.fetch("--depth=1", remote_name, ci_commit_sha)

    # Simulate CI environment and recommended workflow (in docs)
    # NOTE: this could be done in 1 step, but most CI pipelines are doing it in 2 steps
    # 1. Checkout the commit sha (detached head)
    test_repo.git.checkout(ci_commit_sha, force=True)
    # 2. Forcefully set the branch to the current detached head
    test_repo.git.checkout("-B", ci_branch)

    # Act: run PSR on the cloned repo - it should verify upstream and succeed
    with temporary_working_directory(str(test_repo.working_dir)):
        cli_cmd = [MAIN_PROG_NAME, "--strict", VERSION_SUBCMD]
        result = run_cli(cli_cmd[1:], env={Github.DEFAULT_ENV_TOKEN_NAME: "1234"})

    remote_origin_tags_after = {tag.name for tag in local_origin.tags}

    # Evaluate
    assert_successful_exit_code(result, cli_cmd)

    # Verify release occurred as expected
    with test_repo:
        assert latest_tag in test_repo.tags, "Expected release tag to be created"
        assert ci_commit_sha in [
            parent.hexsha for parent in test_repo.head.commit.parents
        ], "Expected new commit to be created on HEAD"
        different_tags = remote_origin_tags_after.difference(remote_origin_tags_before)
        assert latest_tag in different_tags, "Expected new tag to be pushed to remote"

    # Verify VCS release was created
    expected_vcs_url_post = 1
    assert expected_vcs_url_post == post_mocker.call_count  # one vcs release created


@pytest.mark.parametrize(
    "repo_fixture_name, build_repo_fn",
    [
        (
            repo_fixture_name,
            lazy_fixture(build_repo_fn_name),
        )
        for repo_fixture_name, build_repo_fn_name in [
            (
                repo_w_trunk_only_conventional_commits.__name__,
                build_trunk_only_repo_w_tags.__name__,
            ),
        ]
    ],
)
@pytest.mark.usefixtures(change_to_ex_proj_dir.__name__)
def test_version_no_upstream_check_on_no_version_commit(
    repo_fixture_name: str,
    run_cli: RunCliFn,
    build_repo_fn: BuildSpecificRepoFn,
    example_project_dir: ExProjectDir,
    git_repo_for_directory: GetGitRepo4DirFn,
    post_mocker: Mocker,
    get_cfg_value_from_def: GetCfgValueFromDefFn,
    get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
    pyproject_toml_file: Path,
    update_pyproject_toml: UpdatePyprojectTomlFn,
):
    """
    Test that PSR succeeds when no version commit is needed, so the upstream check is skipped.

    This replicates the scenario that occurred on python-semantic-release/publish-action@v10.5.1
    where the version command was run and no version commit was needed, but it failed because
    it attempted to check the upstream branch anyway and we hard coded HEAD~1 because it expects
    a version commit to be created. This is the only reason why you would check the upstream branch
    because pushing a tag to the remote can happen even if the upstream branch has changed.
    """
    remote_name = "origin"
    # Create a bare remote (simulating origin)
    local_origin = Repo.init(str(example_project_dir / "local_origin"), bare=True)

    # build target repo into a temporary directory
    target_repo_dir = example_project_dir / repo_fixture_name
    commit_type: CommitConvention = (
        repo_fixture_name.split("commits", 1)[0].split("_")[-2]  # type: ignore[assignment]
    )
    target_repo_definition = build_repo_fn(
        repo_name=repo_fixture_name,
        commit_type=commit_type,
        dest_dir=target_repo_dir,
    )
    target_git_repo = git_repo_for_directory(target_repo_dir)

    # Configure the source repo to use the bare remote (removing any existing 'origin')
    with contextlib.suppress(AttributeError):
        target_git_repo.delete_remote(target_git_repo.remotes[remote_name])

    target_git_repo.create_remote(remote_name, str(local_origin.working_dir))

    # Remove last release before pushing to upstream
    tag_format_str = cast(
        "str", get_cfg_value_from_def(target_repo_definition, "tag_format_str")
    )
    latest_tag = tag_format_str.format(
        version=get_versions_from_repo_build_def(target_repo_definition)[-1]
    )
    target_git_repo.git.tag("-d", latest_tag)
    target_git_repo.git.reset("--hard", "HEAD~1")

    # Remove any version variables to ensure no version commit is needed
    update_pyproject_toml(
        "tool.semantic_release.version_variables",
        None,
        target_repo_dir / pyproject_toml_file,
    )
    update_pyproject_toml(
        "tool.semantic_release.version_toml",
        None,
        target_repo_dir / pyproject_toml_file,
    )
    # TODO: when available, switch this to use hvcs=none or similar config to avoid token use for push
    update_pyproject_toml(
        "tool.semantic_release.remote.ignore_token_for_push",
        True,
        target_repo_dir / pyproject_toml_file,
    )
    target_git_repo.git.commit(amend=True, no_edit=True, all=True)

    # push the current state to establish the remote (cannot push tags and branches at the same time)
    target_git_repo.git.push(remote_name, all=True)  # all branches
    target_git_repo.git.push(remote_name, tags=True)  # all tags

    # ensure bare remote HEAD points to the active branch so clones can checkout
    local_origin.git.symbolic_ref(
        "HEAD", f"refs/heads/{target_git_repo.active_branch.name}"
    )

    # Simulate CI environment after someone pushes to the repo
    ci_commit_sha = target_git_repo.head.commit.hexsha
    ci_branch = target_git_repo.active_branch.name

    # current remote tags
    remote_origin_tags_before = {tag.name for tag in local_origin.tags}

    # Simulate a CI environment by fetching the repo to a new location
    test_repo = Repo.init(str(example_project_dir / "ci_repo"))
    with test_repo.config_writer("repository") as config:
        config.set_value("core", "hookspath", "")
        config.set_value("commit", "gpgsign", False)
        config.set_value("tag", "gpgsign", False)

    # Configure and retrieve the repository (see GitHub actions/checkout@v5)
    test_repo.git.remote(
        "add",
        remote_name,
        f"file:///{PureWindowsPath(local_origin.working_dir).as_posix()}",
    )
    test_repo.git.fetch("--depth=1", remote_name, ci_commit_sha)

    # Simulate CI environment and recommended workflow (in docs)
    # NOTE: this could be done in 1 step, but most CI pipelines are doing it in 2 steps
    # 1. Checkout the commit sha (detached head)
    test_repo.git.checkout(ci_commit_sha, force=True)
    # 2. Forcefully set the branch to the current detached head
    test_repo.git.checkout("-B", ci_branch)

    # Act: run PSR on the cloned repo - it should verify upstream and succeed
    with temporary_working_directory(str(test_repo.working_dir)):
        # We don't use `--no-commit` here because we want to test that the upstream check is skipped
        # when PSR determines that no version commit is needed. If we used `--no-commit`, it would skip the
        # upstream check because it would think that a version commit was not needed.
        cli_cmd = [
            MAIN_PROG_NAME,
            "--strict",
            VERSION_SUBCMD,
            "--no-changelog",
            "--skip-build",
        ]
        result = run_cli(cli_cmd[1:], env={Github.DEFAULT_ENV_TOKEN_NAME: "1234"})

    remote_origin_tags_after = {tag.name for tag in local_origin.tags}

    # Evaluate
    assert_successful_exit_code(result, cli_cmd)

    # Verify release occurred as expected
    with test_repo:
        assert latest_tag in test_repo.tags, "Expected release tag to be created"
        assert (
            ci_commit_sha == test_repo.head.commit.hexsha
        ), "Expected no new commit to be created on HEAD"
        different_tags = remote_origin_tags_after.difference(remote_origin_tags_before)
        assert latest_tag in different_tags, "Expected new tag to be pushed to remote"

    # Verify VCS release was created
    expected_vcs_url_post = 1
    assert expected_vcs_url_post == post_mocker.call_count  # one vcs release created


@pytest.mark.parametrize(
    "repo_fixture_name, build_repo_fn",
    [
        (
            repo_fixture_name,
            lazy_fixture(build_repo_fn_name),
        )
        for repo_fixture_name, build_repo_fn_name in [
            (
                repo_w_trunk_only_conventional_commits.__name__,
                build_trunk_only_repo_w_tags.__name__,
            ),
        ]
    ],
)
@pytest.mark.usefixtures(change_to_ex_proj_dir.__name__)
def test_version_upstream_check_fails_when_upstream_changed(
    repo_fixture_name: str,
    run_cli: RunCliFn,
    build_repo_fn: BuildSpecificRepoFn,
    example_project_dir: ExProjectDir,
    git_repo_for_directory: GetGitRepo4DirFn,
    post_mocker: Mocker,
    get_cfg_value_from_def: GetCfgValueFromDefFn,
    get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
    pyproject_toml_file: Path,
    update_pyproject_toml: UpdatePyprojectTomlFn,
    file_in_repo: str,
):
    remote_name = "origin"
    # Create a bare remote (simulating origin)
    local_origin = Repo.init(str(example_project_dir / "local_origin"), bare=True)

    # build target repo into a temporary directory
    target_repo_dir = example_project_dir / repo_fixture_name
    commit_type: CommitConvention = (
        repo_fixture_name.split("commits", 1)[0].split("_")[-2]  # type: ignore[assignment]
    )
    target_repo_definition = build_repo_fn(
        repo_name=repo_fixture_name,
        commit_type=commit_type,
        dest_dir=target_repo_dir,
    )
    target_git_repo = git_repo_for_directory(target_repo_dir)

    # Configure the source repo to use the bare remote (removing any existing 'origin')
    with contextlib.suppress(AttributeError):
        target_git_repo.delete_remote(target_git_repo.remotes[remote_name])

    target_git_repo.create_remote(remote_name, f"file://{local_origin.working_dir}")

    # Remove last release before pushing to upstream
    tag_format_str = cast(
        "str", get_cfg_value_from_def(target_repo_definition, "tag_format_str")
    )
    latest_tag = tag_format_str.format(
        version=get_versions_from_repo_build_def(target_repo_definition)[-1]
    )
    target_git_repo.git.tag("-d", latest_tag)
    target_git_repo.git.reset("--hard", "HEAD~1")

    # TODO: when available, switch this to use hvcs=none or similar config to avoid token use for push
    update_pyproject_toml(
        "tool.semantic_release.remote.ignore_token_for_push",
        True,
        target_repo_dir / pyproject_toml_file,
    )
    target_git_repo.git.commit(amend=True, no_edit=True, all=True)

    # push the current state to establish the remote (cannot push tags and branches at the same time)
    target_git_repo.git.push(remote_name, all=True)  # all branches
    target_git_repo.git.push(remote_name, tags=True)  # all tags

    # ensure bare remote HEAD points to the branch name used in the pushed repo
    local_origin.git.symbolic_ref(
        "HEAD", f"refs/heads/{target_git_repo.active_branch.name}"
    )

    # current remote tags
    remote_origin_tags_before = {tag.name for tag in local_origin.tags}

    # Clone the repo to simulate a local workspace
    test_repo = Repo.clone_from(
        f"file://{local_origin.working_dir}",
        str(example_project_dir / "repo_clone"),
        no_local=True,
    )
    with test_repo.config_writer("repository") as config:
        config.set_value("core", "hookspath", "")
        config.set_value("commit", "gpgsign", False)
        config.set_value("tag", "gpgsign", False)

    # Apply new commit to the original repo to simulate another developer pushing to upstream
    add_text_to_file(target_git_repo, str(target_repo_dir / file_in_repo))
    target_git_repo.index.add([str(file_in_repo)])
    target_git_repo.index.commit("feat: upstream change by another developer")
    target_git_repo.git.push(remote_name, target_git_repo.active_branch.name)

    # Act: run PSR - it should detect upstream changed and fail
    with temporary_working_directory(str(test_repo.working_dir)):
        cli_cmd = [MAIN_PROG_NAME, "--strict", VERSION_SUBCMD]
        result = run_cli(cli_cmd[1:], env={Github.DEFAULT_ENV_TOKEN_NAME: "1234"})

    remote_origin_tags_after = {tag.name for tag in local_origin.tags}

    # Evaluate
    assert_exit_code(1, result, cli_cmd)
    expected_err_msg = (
        f"Upstream branch '{remote_name}/{test_repo.active_branch.name}' has changed!"
    )
    # Verify error message mentions upstream
    assert (
        expected_err_msg in result.stderr
    ), f"Expected '{expected_err_msg}' in error output, got: {result.stderr}"

    assert (
        remote_origin_tags_before == remote_origin_tags_after
    ), "Expected no new tags to be pushed to remote"

    # Verify no VCS release was created
    expected_vcs_url_post = 0
    assert expected_vcs_url_post == post_mocker.call_count  # no vcs release created