import subprocess


def test_rm_basic_file(commit_env_config, git2cpp_path, tmp_path):
    """Test basic rm operation to remove a file"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create a test file
    test_file = tmp_path / "test_file.txt"
    test_file.write_text("test content")

    # Add and commit the file
    add_cmd = [git2cpp_path, "add", "test_file.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add test file"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Remove the file
    rm_cmd = [git2cpp_path, "rm", "test_file.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Verify the file was removed from working tree
    assert not test_file.exists()

    # Check git status
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" in p_status.stdout
    assert "deleted" in p_status.stdout


def test_rm_multiple_files(commit_env_config, git2cpp_path, tmp_path):
    """Test removing multiple files at once"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create test files
    file1 = tmp_path / "file1.txt"
    file1.write_text("content 1")
    file2 = tmp_path / "file2.txt"
    file2.write_text("content 2")

    # Add and commit files
    add_cmd = [git2cpp_path, "add", "file1.txt", "file2.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add test files"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Remove both files
    rm_cmd = [git2cpp_path, "rm", "file1.txt", "file2.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Verify both files were removed
    assert not file1.exists()
    assert not file2.exists()

    # Check git status
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" in p_status.stdout
    assert "deleted" in p_status.stdout


def test_rm_directory_without_recursive_flag(commit_env_config, git2cpp_path, tmp_path):
    """Test that rm fails when trying to remove a directory without -r flag"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create a directory with a file
    test_dir = tmp_path / "test_dir"
    test_dir.mkdir()
    test_file = test_dir / "file.txt"
    test_file.write_text("content")

    # Add and commit the file
    add_cmd = [git2cpp_path, "add", "test_dir/file.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add test directory"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Try to remove directory without -r flag - should fail
    rm_cmd = [git2cpp_path, "rm", "test_dir"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode != 0
    assert "not removing" in p_rm.stderr and "recursively without -r" in p_rm.stderr

    # Verify directory still exists
    assert test_dir.exists()
    assert test_file.exists()


def test_rm_directory_with_recursive_flag(commit_env_config, git2cpp_path, tmp_path):
    """Test removing a directory with -r flag"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create a directory with files
    test_dir = tmp_path / "test_dir"
    test_dir.mkdir()
    file1 = test_dir / "file1.txt"
    file1.write_text("content 1")
    file2 = test_dir / "file2.txt"
    file2.write_text("content 2")

    # Add and commit the files
    add_cmd = [git2cpp_path, "add", "test_dir/file1.txt", "test_dir/file2.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add test directory"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Remove directory with -r flag - should succeed
    rm_cmd = [git2cpp_path, "rm", "-r", "test_dir"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Check git status
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" in p_status.stdout
    assert "deleted" in p_status.stdout


def test_rm_and_commit(commit_env_config, git2cpp_path, tmp_path):
    """Test removing a file and committing the change"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create a test file
    test_file = tmp_path / "to_remove.txt"
    test_file.write_text("content to remove")

    # Add and commit the file
    add_cmd = [git2cpp_path, "add", "to_remove.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add file to remove"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Remove the file
    rm_cmd = [git2cpp_path, "rm", "to_remove.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Check status before commit
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" in p_status.stdout
    assert "deleted" in p_status.stdout

    # Commit the removal
    commit_cmd2 = [git2cpp_path, "commit", "-m", "Remove file"]
    p_commit2 = subprocess.run(commit_cmd2, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit2.returncode == 0

    # Verify the file is gone
    assert not test_file.exists()

    # Check status after commit
    status_cmd2 = [git2cpp_path, "status", "--long"]
    p_status2 = subprocess.run(status_cmd2, capture_output=True, cwd=tmp_path, text=True)
    assert p_status2.returncode == 0
    assert "to_remove.txt" not in p_status2.stdout


def test_rm_nonexistent_file(git2cpp_path, tmp_path):
    """Test that rm fails when file doesn't exist"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Try to remove a file that doesn't exist
    rm_cmd = [git2cpp_path, "rm", "nonexistent.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode != 0


def test_rm_untracked_file(git2cpp_path, tmp_path):
    """Test that rm fails when trying to remove an untracked file"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create an untracked file
    untracked_file = tmp_path / "untracked.txt"
    untracked_file.write_text("untracked content")

    # Try to remove untracked file - should fail
    rm_cmd = [git2cpp_path, "rm", "untracked.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode != 0


def test_rm_staged_file(git2cpp_path, tmp_path):
    """Test removing a file that was added but not yet committed"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create a test file
    test_file = tmp_path / "staged.txt"
    test_file.write_text("staged content")

    # Add the file (but don't commit)
    add_cmd = [git2cpp_path, "add", "staged.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    # Remove the file
    rm_cmd = [git2cpp_path, "rm", "staged.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Verify the file was removed
    assert not test_file.exists()

    # Check git status - should show nothing staged
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" not in p_status.stdout
    assert "staged.txt" not in p_status.stdout


def test_rm_file_in_subdirectory(commit_env_config, git2cpp_path, tmp_path):
    """Test removing a file in a subdirectory"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create subdirectory
    test_dir = tmp_path / "test"
    test_dir.mkdir()
    test_file = test_dir / "test.txt"
    test_file.write_text("test content")

    # Add and commit the file
    add_cmd = [git2cpp_path, "add", "test/test.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add file in subdirectory"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Remove the file
    rm_cmd = [git2cpp_path, "rm", "test/test.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Verify the file was removed
    assert not test_file.exists()

    # Check git status
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" in p_status.stdout
    assert "deleted" in p_status.stdout


def test_rm_nogit(git2cpp_path, tmp_path):
    """Test that rm fails when not in a git repository"""
    # Create a test file outside a git repo
    test_file = tmp_path / "test.txt"
    test_file.write_text("test content")

    # Try to rm without being in a git repo
    rm_cmd = [git2cpp_path, "rm", "test.txt"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode != 0


def test_rm_nested_directory_recursive(commit_env_config, git2cpp_path, tmp_path):
    """Test removing a nested directory structure with -r flag"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create nested directory structure
    nested_dir = tmp_path / "level1" / "level2"
    nested_dir.mkdir(parents=True)
    file1 = tmp_path / "level1" / "file1.txt"
    file1.write_text("content 1")
    file2 = nested_dir / "file2.txt"
    file2.write_text("content 2")

    # Add and commit the files
    add_cmd = [git2cpp_path, "add", "level1/file1.txt", "level1/level2/file2.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add nested structure"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Remove the directory tree with -r flag
    rm_cmd = [git2cpp_path, "rm", "-r", "level1"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Check git status
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" in p_status.stdout
    assert "deleted" in p_status.stdout


def test_rm_mixed_files_and_directory(commit_env_config, git2cpp_path, tmp_path):
    """Test removing both individual files and directories in one command"""
    cmd_init = [git2cpp_path, "init", "."]
    p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)
    assert p_init.returncode == 0

    # Create a file and a directory with contents
    single_file = tmp_path / "single.txt"
    single_file.write_text("single file")

    test_dir = tmp_path / "remove_dir"
    test_dir.mkdir()
    dir_file = test_dir / "file.txt"
    dir_file.write_text("file in dir")

    # Add and commit everything
    add_cmd = [git2cpp_path, "add", "single.txt", "remove_dir/file.txt"]
    p_add = subprocess.run(add_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_add.returncode == 0

    commit_cmd = [git2cpp_path, "commit", "-m", "Add mixed content"]
    p_commit = subprocess.run(commit_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_commit.returncode == 0

    # Remove both file and directory
    rm_cmd = [git2cpp_path, "rm", "-r", "single.txt", "remove_dir"]
    p_rm = subprocess.run(rm_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_rm.returncode == 0

    # Verify everything was removed
    assert not single_file.exists()

    # Check git status
    status_cmd = [git2cpp_path, "status", "--long"]
    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
    assert p_status.returncode == 0
    assert "Changes to be committed" in p_status.stdout
    assert "deleted" in p_status.stdout