import subprocess

import pytest

from .conftest import GIT2CPP_TEST_WASM


def test_tag_list_empty(repo_init_with_commit, git2cpp_path, tmp_path):
    """Test listing tags when there are no tags."""
    assert (tmp_path / "initial.txt").exists()

    cmd = [git2cpp_path, "tag"]
    p = subprocess.run(cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p.returncode == 0
    assert p.stdout == ""


def test_tag_create_lightweight(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
    """Test creating a lightweight tag."""
    assert (tmp_path / "initial.txt").exists()

    # Create a lightweight tag
    create_cmd = [git2cpp_path, "tag", "v1.0.0"]
    subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, text=True, check=True)

    # List tags to verify it was created
    list_cmd = [git2cpp_path, "tag"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout


def test_tag_create_annotated(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
    """Test creating an annotated tag."""
    assert (tmp_path / "initial.txt").exists()

    # Create an annotated tag
    create_cmd = [git2cpp_path, "tag", "-m", "Release version 1.0", "v1.0.0"]
    subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, text=True, check=True)

    # List tags to verify it was created
    list_cmd = [git2cpp_path, "tag", "-n", "1"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout
    assert "Release version 1.0" in p_list.stdout


def test_tag_create_on_specific_commit(
    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
):
    """Test creating a tag on a specific commit."""
    assert (tmp_path / "initial.txt").exists()

    # Get the commit SHA before creating new commit
    old_head_cmd = [git2cpp_path, "rev-parse", "HEAD"]
    p_old_head = subprocess.run(old_head_cmd, capture_output=True, cwd=tmp_path, text=True)
    old_head_sha = p_old_head.stdout.strip()

    # Create a commit first
    file_path = tmp_path / "test_file.txt"
    file_path.write_text("test content")

    add_cmd = [git2cpp_path, "add", "test_file.txt"]
    subprocess.run(add_cmd, cwd=tmp_path, check=True)

    commit_cmd = [git2cpp_path, "commit", "-m", "test commit"]
    subprocess.run(commit_cmd, cwd=tmp_path, check=True)

    # Get new HEAD commit SHA
    new_head_cmd = [git2cpp_path, "rev-parse", "HEAD"]
    p_new_head = subprocess.run(new_head_cmd, capture_output=True, cwd=tmp_path, text=True)
    new_head_sha = p_new_head.stdout.strip()

    # Verify we actually created a new commit
    assert old_head_sha != new_head_sha

    # Create tag on HEAD
    tag_cmd = [git2cpp_path, "tag", "v1.0.0", "HEAD"]
    subprocess.run(tag_cmd, capture_output=True, cwd=tmp_path, check=True)

    # Verify tag exists
    list_cmd = [git2cpp_path, "tag"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout

    # Get commit SHA that the tag points to
    tag_sha_cmd = [git2cpp_path, "rev-parse", "v1.0.0^{commit}"]
    p_tag_sha = subprocess.run(tag_sha_cmd, capture_output=True, cwd=tmp_path, text=True)
    tag_sha = p_tag_sha.stdout.strip()

    # Verify tag points to new HEAD, not old HEAD
    assert tag_sha == new_head_sha
    assert tag_sha != old_head_sha


def test_tag_delete(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
    """Test deleting a tag."""
    assert (tmp_path / "initial.txt").exists()

    # Create a tag
    create_cmd = [git2cpp_path, "tag", "v1.0.0"]
    subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, text=True, check=True)

    # Delete the tag
    delete_cmd = [git2cpp_path, "tag", "-d", "v1.0.0"]
    p_delete = subprocess.run(delete_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_delete.returncode == 0
    assert "Deleted tag 'v1.0.0'" in p_delete.stdout

    # Verify tag is gone
    list_cmd = [git2cpp_path, "tag"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" not in p_list.stdout


def test_tag_delete_nonexistent(repo_init_with_commit, git2cpp_path, tmp_path):
    """Test deleting a tag that doesn't exist."""
    assert (tmp_path / "initial.txt").exists()

    # Try to delete non-existent tag
    delete_cmd = [git2cpp_path, "tag", "-d", "nonexistent"]
    p_delete = subprocess.run(delete_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_delete.returncode != 0
    assert "not found" in p_delete.stderr


@pytest.mark.parametrize("list_flag", ["", "-l", "--list"])
def test_tag_list(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, list_flag):
    """Test listing tags with -l or --list flag."""
    assert (tmp_path / "initial.txt").exists()

    # Create a tag
    tag_cmd = [git2cpp_path, "tag", "v1.0.0"]
    subprocess.run(tag_cmd, capture_output=True, cwd=tmp_path, text=True)

    # List tags
    list_cmd = [git2cpp_path, "tag", list_flag]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout


def test_tag_list_with_pattern(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
    """Test listing tags with a pattern."""
    assert (tmp_path / "initial.txt").exists()

    # Create tags with different prefixes
    tag_cmd_1 = [git2cpp_path, "tag", "v1.0.0"]
    subprocess.run(tag_cmd_1, capture_output=True, cwd=tmp_path, text=True)

    tag_cmd_2 = [git2cpp_path, "tag", "v1.0.1"]
    subprocess.run(tag_cmd_2, capture_output=True, cwd=tmp_path, text=True)

    tag_cmd_3 = [git2cpp_path, "tag", "release-1.0"]
    subprocess.run(tag_cmd_3, capture_output=True, cwd=tmp_path, text=True)

    # List only tags matching pattern
    list_cmd = [git2cpp_path, "tag", "-l", "v1.0*"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout
    assert "v1.0.1" in p_list.stdout
    assert "release-1.0" not in p_list.stdout


def test_tag_list_with_message_lines(
    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
):
    """Test listing tags with message lines (-n flag)."""
    assert (tmp_path / "initial.txt").exists()

    # Create an annotated tag with a message
    create_cmd = [
        git2cpp_path,
        "tag",
        "-m",
        "First line\nSecond line\nThird line\nForth line",
        "v1.0.0",
    ]
    p_create = subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_create.returncode == 0

    # List tags with message lines
    list_cmd = [git2cpp_path, "tag", "-n", "3", "-l"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout
    assert "First line" in p_list.stdout
    assert "Second line" in p_list.stdout
    assert "Third line" in p_list.stdout
    assert "Forth line" not in p_list.stdout


@pytest.mark.parametrize("force_flag", ["-f", "--force"])
def test_tag_force_replace(
    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, force_flag
):
    """Test replacing an existing tag with -f or --force flag."""
    assert (tmp_path / "initial.txt").exists()

    # Create initial tag
    create_cmd_1 = [git2cpp_path, "tag", "v1.0.0"]
    subprocess.run(create_cmd_1, capture_output=True, cwd=tmp_path, text=True, check=True)

    # Try to create same tag without force (should fail)
    create_cmd_2 = [git2cpp_path, "tag", "v1.0.0"]
    p_create_2 = subprocess.run(create_cmd_2, capture_output=True, cwd=tmp_path)
    assert p_create_2.returncode != 0

    # Create same tag with force (should succeed)
    create_cmd_3 = [git2cpp_path, "tag", force_flag, "v1.0.0"]
    p_create_3 = subprocess.run(create_cmd_3, capture_output=True, cwd=tmp_path, text=True)
    assert p_create_3.returncode == 0


def test_tag_nogit(git2cpp_path, tmp_path):
    """Test tag command outside a git repository."""
    cmd = [git2cpp_path, "tag"]
    p = subprocess.run(cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p.returncode != 0


def test_tag_annotated_no_message(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
    """Test creating an annotated tag without a message should fail."""
    assert (tmp_path / "initial.txt").exists()

    # Create a commit with a known message
    file_path = tmp_path / "test_file.txt"
    file_path.write_text("test content")

    add_cmd = [git2cpp_path, "add", "test_file.txt"]
    subprocess.run(add_cmd, cwd=tmp_path, check=True)

    commit_cmd = [git2cpp_path, "commit", "-m", "my specific commit message"]
    subprocess.run(commit_cmd, cwd=tmp_path, check=True)

    if GIT2CPP_TEST_WASM:
        pytest.skip("Not possible to pass empty argument to wasm")

    # Create tag with empty message (should create lightweight tag)
    create_cmd = [git2cpp_path, "tag", "-m", "", "v1.0.0"]
    subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, check=True)

    # List tag with messages - lightweight tag shows commit message
    list_cmd = [git2cpp_path, "tag", "-n", "1"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout
    # Lightweight tag shows the commit message, not a tag message
    assert "my specific commit message" in p_list.stdout


def test_tag_multiple_create_and_list(
    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
):
    """Test creating multiple tags and listing them."""
    assert (tmp_path / "initial.txt").exists()

    # Create multiple tags
    tags = ["v1.0.0", "v1.0.1", "v1.1.0", "v2.0.0"]
    for tag in tags:
        create_cmd = [git2cpp_path, "tag", tag]
        subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, check=True)

    # List all tags
    list_cmd = [git2cpp_path, "tag"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0

    # Verify all tags are in the list
    for tag in tags:
        assert tag in p_list.stdout


def test_tag_on_new_commit(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
    """Test creating tags on new commits."""
    assert (tmp_path / "initial.txt").exists()

    # Tag the current commit
    tag_cmd_1 = [git2cpp_path, "tag", "before-change"]
    subprocess.run(tag_cmd_1, cwd=tmp_path, check=True)

    # Make a new commit
    file_path = tmp_path / "new_file.txt"
    file_path.write_text("new content")

    add_cmd = [git2cpp_path, "add", "new_file.txt"]
    subprocess.run(add_cmd, cwd=tmp_path, check=True)

    commit_cmd = [git2cpp_path, "commit", "-m", "new commit"]
    subprocess.run(commit_cmd, cwd=tmp_path, check=True)

    # Tag the new commit
    tag_cmd_2 = [git2cpp_path, "tag", "after-change"]
    subprocess.run(tag_cmd_2, cwd=tmp_path, check=True)

    # List tags
    list_cmd = [git2cpp_path, "tag"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "before-change" in p_list.stdout
    assert "after-change" in p_list.stdout


def test_tag_create_annotated_with_a_flag(
    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
):
    """Test creating an annotated tag using -a flag."""
    assert (tmp_path / "initial.txt").exists()

    # Create an annotated tag using -a and -m
    create_cmd = [git2cpp_path, "tag", "-a", "-m", "Release version 1.0", "v1.0.0"]
    subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, text=True, check=True)

    # List tags with message lines to verify it was created as an annotated tag
    list_cmd = [git2cpp_path, "tag", "-n", "1"]
    p_list = subprocess.run(list_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_list.returncode == 0
    assert "v1.0.0" in p_list.stdout
    assert "Release version 1.0" in p_list.stdout


def test_tag_annotate_flag_requires_message(
    repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path
):
    """Test that -a/--annotate without -m fails."""
    assert (tmp_path / "initial.txt").exists()

    create_cmd = [git2cpp_path, "tag", "-a", "v1.0.0"]
    p = subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p.returncode != 0
    assert "requires -m" in p.stderr


def test_tag_errors(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):
    assert (tmp_path / "initial.txt").exists()

    # Test that -a/--annotate without -m fails.
    create_cmd = [git2cpp_path, "tag", "-a", "v1.0.0"]
    p_create = subprocess.run(create_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_create.returncode != 0
    assert "requires -m" in p_create.stderr

    # Test that command fails when no message
    del_cmd = [git2cpp_path, "tag", "-d"]
    p_del = subprocess.run(del_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_del.returncode != 0