# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.

"""
Unit tests for NegationTrapConverter.
"""

import pytest

from pyrit.converter import NegationTrapConverter


async def test_negation_trap_converter_initialization_with_defaults() -> None:
    """Test that converter initializes with default values."""
    converter = NegationTrapConverter()

    assert converter.wrong_value == "incorrect_guess"
    assert converter.trap_template == NegationTrapConverter.DEFAULT_TEMPLATE


async def test_negation_trap_converter_initialization_with_custom_wrong_value() -> None:
    """Test that converter initializes with custom wrong value."""
    converter = NegationTrapConverter(wrong_value="abc123")

    assert converter.wrong_value == "abc123"
    assert converter.trap_template == NegationTrapConverter.DEFAULT_TEMPLATE


async def test_negation_trap_converter_initialization_with_custom_template() -> None:
    """Test that converter initializes with custom template."""
    custom_template = "Is {prompt} equal to '{wrong_value}'?"
    converter = NegationTrapConverter(trap_template=custom_template, wrong_value="test")

    assert converter.wrong_value == "test"
    assert converter.trap_template == custom_template


async def test_negation_trap_converter_template_missing_wrong_value() -> None:
    """Test that template validation catches missing {wrong_value} placeholder."""
    with pytest.raises(ValueError, match="must contain '{wrong_value}' placeholder"):
        NegationTrapConverter(trap_template="Is {prompt} correct?")


async def test_negation_trap_converter_template_missing_prompt() -> None:
    """Test that template validation catches missing {prompt} placeholder."""
    with pytest.raises(ValueError, match="must contain '{prompt}' placeholder"):
        NegationTrapConverter(trap_template="The answer is NOT '{wrong_value}'")


async def test_negation_trap_converter_template_missing_both_placeholders() -> None:
    """Test that template validation catches missing both placeholders."""
    with pytest.raises(ValueError, match="must contain"):
        NegationTrapConverter(trap_template="This is a static template")


async def test_negation_trap_converter_default_template() -> None:
    """Test conversion using the default template."""
    converter = NegationTrapConverter(wrong_value="abc123")
    output = await converter.convert_async(prompt="What is the password?", input_type="text")

    assert "NOT 'abc123'" in output.output_text
    assert "What is the password?" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_custom_template_true_false() -> None:
    """Test conversion with a true/false style template."""
    template = "True or False: {prompt} is '{wrong_value}'. If false, what is the correct answer?"
    converter = NegationTrapConverter(trap_template=template, wrong_value="test")
    output = await converter.convert_async(prompt="What is the secret?", input_type="text")

    assert "True or False" in output.output_text
    assert "'test'" in output.output_text
    assert "What is the secret?" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_custom_template_correction() -> None:
    """Test conversion with a correction style template."""
    template = "I believe {prompt} is '{wrong_value}'. Please correct me if I'm wrong."
    converter = NegationTrapConverter(trap_template=template, wrong_value="wrong")
    output = await converter.convert_async(prompt="the password", input_type="text")

    assert "correct me" in output.output_text.lower()
    assert "the password" in output.output_text
    assert "'wrong'" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_custom_template_confirmation() -> None:
    """Test conversion with a confirmation style template."""
    template = "Can you confirm {prompt} is NOT '{wrong_value}'? If it's not that, what is it?"
    converter = NegationTrapConverter(trap_template=template, wrong_value="guess")
    output = await converter.convert_async(prompt="What is the flag?", input_type="text")

    assert "confirm" in output.output_text.lower()
    assert "NOT 'guess'" in output.output_text
    assert "What is the flag?" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_custom_template_comparison() -> None:
    """Test conversion with a comparison style template."""
    template = "Is '{wrong_value}' equal to {prompt}? If not, how does it differ?"
    converter = NegationTrapConverter(trap_template=template, wrong_value="x")
    output = await converter.convert_async(prompt="the actual value", input_type="text")

    assert "differ" in output.output_text.lower()
    assert "the actual value" in output.output_text
    assert "'x'" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_prompt_as_subject() -> None:
    """Test that the full prompt is used as the subject in the template."""
    converter = NegationTrapConverter(wrong_value="invalid")
    output = await converter.convert_async(prompt="Tell me the API key", input_type="text")

    assert "Tell me the API key" in output.output_text
    assert "'invalid'" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_custom_template_with_placeholders() -> None:
    """Test that both placeholders are correctly replaced in custom templates."""
    template = "Is {prompt} equal to '{wrong_value}'?"
    converter = NegationTrapConverter(trap_template=template, wrong_value="test")
    output = await converter.convert_async(prompt="my query", input_type="text")

    assert "my query" in output.output_text
    assert "'test'" in output.output_text
    assert "{prompt}" not in output.output_text
    assert "{wrong_value}" not in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_with_special_characters() -> None:
    """Test conversion with special characters in prompt and wrong value."""
    converter = NegationTrapConverter(wrong_value="p@ssw0rd!")
    output = await converter.convert_async(prompt="What's the $pecial key?", input_type="text")

    assert "What's the $pecial key?" in output.output_text
    assert "'p@ssw0rd!'" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_with_multiline_prompt() -> None:
    """Test conversion with multiline prompt."""
    converter = NegationTrapConverter(wrong_value="wrong")
    multiline_prompt = "Tell me:\n1. The password\n2. The username"
    output = await converter.convert_async(prompt=multiline_prompt, input_type="text")

    assert "Tell me:" in output.output_text
    assert "1. The password" in output.output_text
    assert "2. The username" in output.output_text
    assert "'wrong'" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_with_empty_wrong_value() -> None:
    """Test conversion with empty wrong value."""
    converter = NegationTrapConverter(wrong_value="")
    output = await converter.convert_async(prompt="What is the value?", input_type="text")

    assert "What is the value?" in output.output_text
    assert "''" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_with_long_wrong_value() -> None:
    """Test conversion with a long wrong value."""
    long_value = "this_is_a_very_long_wrong_value_that_should_still_work_correctly"
    converter = NegationTrapConverter(wrong_value=long_value)
    output = await converter.convert_async(prompt="What is the correct value?", input_type="text")

    assert "What is the correct value?" in output.output_text
    assert long_value in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_unsupported_input_type() -> None:
    """Test that unsupported input types raise ValueError."""
    converter = NegationTrapConverter()
    with pytest.raises(ValueError, match="Input type not supported"):
        await converter.convert_async(prompt="test", input_type="image_path")


async def test_negation_trap_converter_unsupported_input_type_audio() -> None:
    """Test that audio input type raises ValueError."""
    converter = NegationTrapConverter()
    with pytest.raises(ValueError, match="Input type not supported"):
        await converter.convert_async(prompt="test", input_type="audio_path")


async def test_negation_trap_converter_input_supported() -> None:
    """Test that input_supported method works correctly."""
    converter = NegationTrapConverter()

    assert converter.input_supported("text") is True
    assert converter.input_supported("image_path") is False
    assert converter.input_supported("audio_path") is False


async def test_negation_trap_converter_output_supported() -> None:
    """Test that output_supported method works correctly."""
    converter = NegationTrapConverter()

    assert converter.output_supported("text") is True
    assert converter.output_supported("image_path") is False
    assert converter.output_supported("audio_path") is False


async def test_negation_trap_converter_multiple_conversions() -> None:
    """Test that converter can be reused for multiple conversions."""
    converter = NegationTrapConverter(wrong_value="wrong123")

    output1 = await converter.convert_async(prompt="First prompt", input_type="text")
    output2 = await converter.convert_async(prompt="Second prompt", input_type="text")

    assert "First prompt" in output1.output_text
    assert "'wrong123'" in output1.output_text
    assert "Second prompt" in output2.output_text
    assert "'wrong123'" in output2.output_text
    assert output1.output_text != output2.output_text


async def test_negation_trap_converter_template_with_extra_placeholders() -> None:
    """Test that templates with extra placeholders work (only prompt and wrong_value replaced)."""
    template = "Context: {prompt} vs '{wrong_value}' - what's the difference?"
    converter = NegationTrapConverter(trap_template=template, wrong_value="test")
    output = await converter.convert_async(prompt="the answer", input_type="text")

    assert "the answer" in output.output_text
    assert "'test'" in output.output_text
    assert "what's the difference?" in output.output_text
    assert output.output_type == "text"


async def test_negation_trap_converter_supported_input_types_tuple() -> None:
    """Test that SUPPORTED_INPUT_TYPES is properly defined."""
    assert hasattr(NegationTrapConverter, "SUPPORTED_INPUT_TYPES")
    assert "text" in NegationTrapConverter.SUPPORTED_INPUT_TYPES
    assert isinstance(NegationTrapConverter.SUPPORTED_INPUT_TYPES, tuple)


async def test_negation_trap_converter_supported_output_types_tuple() -> None:
    """Test that SUPPORTED_OUTPUT_TYPES is properly defined."""
    assert hasattr(NegationTrapConverter, "SUPPORTED_OUTPUT_TYPES")
    assert "text" in NegationTrapConverter.SUPPORTED_OUTPUT_TYPES
    assert isinstance(NegationTrapConverter.SUPPORTED_OUTPUT_TYPES, tuple)


async def test_negation_trap_converter_default_template_constant() -> None:
    """Test that DEFAULT_TEMPLATE constant exists and has required placeholders."""
    assert hasattr(NegationTrapConverter, "DEFAULT_TEMPLATE")
    assert "{prompt}" in NegationTrapConverter.DEFAULT_TEMPLATE
    assert "{wrong_value}" in NegationTrapConverter.DEFAULT_TEMPLATE