from pathlib import Path
import toml
from click.testing import CliRunner
from ctf.commands import basic_group

TEST_ENV = Path("tests/env")

def test_basic_test_cli():
    """
    Verifies that 'basic test' runs successfully and outputs 'hello from test'.
    """
    runner = CliRunner()
    result = runner.invoke(basic_group, ["test"])
    assert result.exit_code == 0
    assert "hello from test" in result.output

def test_basic_greet_cli():
    """
    Verifies that 'basic greet' runs successfully and greets the name argument.
    """
    runner = CliRunner()
    result = runner.invoke(basic_group, ["greet", "Alice"])
    assert result.exit_code == 0
    assert "hello Alice" in result.output

def test_basic_set_flag_format_cli():
    """
    Verifies that 'basic set-flag-format' CLI command writes the pattern to config.toml.
    """
    from ctf.utils import load_config
    
    runner = CliRunner()
    config_file = Path("/home/venus/code/ctf/config.toml")
    
    # Save the original config to restore later
    original_config = load_config(str(config_file))
    
    try:
        result = runner.invoke(basic_group, ["set-flag-format", "TEST_FLAG{[a-z]+}"])
        assert result.exit_code == 0
        assert "Flag format set to" in result.output
        
        # Verify it was written to config.toml
        updated_config = load_config(str(config_file))
        assert updated_config["Competition"]["flag_format"] == "TEST_FLAG{[a-z]+}"
    finally:
        # Restore original config
        from ctf.utils import write_config
        write_config(original_config, str(config_file))

def test_basic_set_flag_format_original_option_cli():
    """
    Verifies that 'basic set-flag-format' with --original/-o option prompts for selection and writes it.
    """
    from ctf.utils import load_config
    
    runner = CliRunner()
    config_file = Path("/home/venus/code/ctf/config.toml")
    
    # Save the original config to restore later
    original_config = load_config(str(config_file))
    
    try:
        # We pass -o SKY-1111-000 and input "2" to choose the second suggested pattern
        result = runner.invoke(basic_group, ["set-flag-format", "-o", "SKY-1111-000"], input="2\n")
        assert result.exit_code == 0
        comp_name = original_config.get("Competition", {}).get("competition", "")
        if comp_name:
            assert f"Suggested regex patterns for competition {comp_name}:" in result.output
        else:
            assert "Suggested regex patterns:" in result.output
        assert "Select a pattern index" in result.output
        assert "Flag format set to" in result.output
        
        # Verify it was written to config.toml
        updated_config = load_config(str(config_file))
        selected_pattern = updated_config["Competition"]["flag_format"]
        assert len(selected_pattern) > 0
    finally:
        # Restore original config
        from ctf.utils import write_config
        write_config(original_config, str(config_file))

def test_basic_set_flag_format_validation_cli():
    """
    Verifies validation rules:
    - Specifying both PATTERN and --original should fail.
    - Specifying neither PATTERN nor --original should fail.
    - Specifying empty/whitespace-only original flag should fail.
    """
    runner = CliRunner()
    
    # Both specified
    result1 = runner.invoke(basic_group, ["set-flag-format", "PAT", "-o", "SKY-1111-000"])
    assert result1.exit_code != 0
    assert "Cannot specify both PATTERN and --original/-o option." in result1.output
    
    # Neither specified
    result2 = runner.invoke(basic_group, ["set-flag-format"])
    assert result2.exit_code != 0
    assert "Either PATTERN positional argument or --original/-o option must be specified." in result2.output

    # Empty original
    result3 = runner.invoke(basic_group, ["set-flag-format", "-o", "   "])
    assert result3.exit_code != 0
    assert "Original flag cannot be empty or whitespace only." in result3.output

def test_basic_set_competition_cli():
    """
    Verifies that 'basic set-competition' updates the competition name in config.toml.
    """
    from ctf.utils import load_config
    
    runner = CliRunner()
    config_file = Path("/home/venus/code/ctf/config.toml")
    original_config = load_config(str(config_file))
    
    try:
        result = runner.invoke(basic_group, ["set-competition", "CyberCTF2026"])
        assert result.exit_code == 0
        assert "Competition name set to: CyberCTF2026" in result.output
        
        updated_config = load_config(str(config_file))
        assert updated_config["Competition"]["competition"] == "CyberCTF2026"
    finally:
        from ctf.utils import write_config
        write_config(original_config, str(config_file))

def test_basic_set_flag_format_warning_cli():
    """
    Verifies that if competition name is set and not present in the example flag,
    set-flag-format outputs a warning.
    """
    from ctf.utils import load_config, write_config
    
    runner = CliRunner()
    config_file = Path("/home/venus/code/ctf/config.toml")
    original_config = load_config(str(config_file))
    
    try:
        # Set competition name first
        temp_config = load_config(str(config_file))
        if "Competition" not in temp_config:
            temp_config["Competition"] = {}
        temp_config["Competition"]["competition"] = "SECURE"
        write_config(temp_config, str(config_file))
        
        # Now run set-flag-format with an example flag that has no "SECURE" substring
        # We also pass input "1" to satisfy the choice prompt
        result = runner.invoke(basic_group, ["set-flag-format", "-o", "CTF{easy_flag_123}"], input="1\n")
        assert result.exit_code == 0
        assert "Warning: Current competition name 'SECURE' was not found in the example flag." in result.output
    finally:
        write_config(original_config, str(config_file))