import pytest
from keras.src.metrics.iou_metrics import OneHotIoU

# ------------------- UNIT TESTS FOR get_config -------------------

# 1. BASIC TEST CASES

def test_get_config_basic_minimal():
    """Test with only required arguments, all others default."""
    metric = OneHotIoU(num_classes=2, target_class_ids=[1])
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_basic_all_args():
    """Test with all arguments specified, including non-defaults."""
    metric = OneHotIoU(
        num_classes=4,
        target_class_ids=[0, 2, 3],
        name="iou_metric",
        dtype="float32",
        ignore_class=255,
        sparse_y_pred=True,
        axis=2,
    )
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_basic_name_and_dtype_none():
    """Test with name and dtype explicitly set to None."""
    metric = OneHotIoU(
        num_classes=3, target_class_ids=[1, 2], name=None, dtype=None
    )
    codeflash_output = metric.get_config(); config = codeflash_output

# 2. EDGE TEST CASES


def test_get_config_negative_axis():
    """Test with negative axis values."""
    metric = OneHotIoU(num_classes=5, target_class_ids=[2], axis=-3)
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_ignore_class_negative():
    """Test with negative ignore_class (common for 'void' classes)."""
    metric = OneHotIoU(num_classes=3, target_class_ids=[1], ignore_class=-1)
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_large_target_class_ids():
    """Test with large values in target_class_ids (but valid)."""
    metric = OneHotIoU(num_classes=100, target_class_ids=[0, 50, 99])
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_dtype_types():
    """Test with various dtype values."""
    for dtype in ["float16", "float32", "float64", "int32", "int64"]:
        metric = OneHotIoU(num_classes=2, target_class_ids=[0], dtype=dtype)
        codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_name_empty_string():
    """Test with name as empty string."""
    metric = OneHotIoU(num_classes=2, target_class_ids=[0], name="")
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_target_class_ids_tuple():
    """Test with target_class_ids as a tuple (should be converted to list)."""
    metric = OneHotIoU(num_classes=3, target_class_ids=(1, 2))
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_sparse_y_pred_types():
    """Test with both True and False for sparse_y_pred."""
    for val in [True, False]:
        metric = OneHotIoU(num_classes=2, target_class_ids=[0], sparse_y_pred=val)
        codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_axis_zero():
    """Test with axis set to 0."""
    metric = OneHotIoU(num_classes=2, target_class_ids=[0], axis=0)
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_ignore_class_none_explicit():
    """Test with ignore_class explicitly set to None."""
    metric = OneHotIoU(num_classes=2, target_class_ids=[0], ignore_class=None)
    codeflash_output = metric.get_config(); config = codeflash_output

# 3. LARGE SCALE TEST CASES

def test_get_config_large_num_classes_and_target_ids():
    """Test with large num_classes and many target_class_ids."""
    num_classes = 1000
    target_class_ids = list(range(0, 1000, 10))  # 0, 10, ..., 990 (100 elements)
    metric = OneHotIoU(
        num_classes=num_classes,
        target_class_ids=target_class_ids,
        name="large_test",
        dtype="float64",
        ignore_class=999,
        sparse_y_pred=True,
        axis=1,
    )
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_large_target_class_ids_only():
    """Test with a large list for target_class_ids, but small num_classes."""
    target_class_ids = list(range(50))
    metric = OneHotIoU(num_classes=50, target_class_ids=target_class_ids)
    codeflash_output = metric.get_config(); config = codeflash_output

def test_get_config_many_instances_unique_configs():
    """Test creating many instances with unique configs and verifying each."""
    # Create 100 different configs
    for i in range(100):
        metric = OneHotIoU(
            num_classes=10 + i,
            target_class_ids=[i % (10 + i)],
            name=f"metric_{i}",
            dtype="float32",
            ignore_class=None if i % 2 == 0 else i,
            sparse_y_pred=bool(i % 2),
            axis=i % 5 - 2,
        )
        codeflash_output = metric.get_config(); config = codeflash_output
        if i % 2 == 0:
            pass
        else:
            pass

# 4. REGRESSION/INVARIANCE TESTS

def test_get_config_idempotency():
    """Test that get_config returns the same dict on repeated calls."""
    metric = OneHotIoU(num_classes=3, target_class_ids=[1, 2], name="idempotent")
    codeflash_output = metric.get_config(); config1 = codeflash_output
    codeflash_output = metric.get_config(); config2 = codeflash_output

def test_get_config_no_side_effects():
    """Test that get_config does not mutate internal state."""
    metric = OneHotIoU(num_classes=2, target_class_ids=[0, 1])
    before = dict(metric.__dict__)
    codeflash_output = metric.get_config(); _ = codeflash_output
    after = dict(metric.__dict__)

# 5. TYPE/VALIDATION TESTS

def test_get_config_target_class_ids_type():
    """Test that target_class_ids is always a list in config."""
    metric = OneHotIoU(num_classes=3, target_class_ids=(1, 2))
    codeflash_output = metric.get_config(); config = codeflash_output
    metric2 = OneHotIoU(num_classes=3, target_class_ids=[1, 2])
    codeflash_output = metric2.get_config(); config2 = codeflash_output

def test_get_config_axis_type():
    """Test that axis is always int in config."""
    metric = OneHotIoU(num_classes=2, target_class_ids=[0], axis=3)
    codeflash_output = metric.get_config(); config = codeflash_output
    metric2 = OneHotIoU(num_classes=2, target_class_ids=[0], axis=-2)
    codeflash_output = metric2.get_config(); config2 = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
# function to test
from keras.src.api_export import keras_export
from keras.src.metrics.iou_metrics import OneHotIoU


# Dummy base class for testing (since _IoUBase is not defined in the prompt)
class _IoUBase:
    def __init__(
        self,
        name=None,
        num_classes=None,
        ignore_class=None,
        sparse_y_true=True,
        sparse_y_pred=True,
        axis=-1,
        dtype=None,
    ):
        self.name = name
        self.num_classes = num_classes
        self.ignore_class = ignore_class
        self.sparse_y_true = sparse_y_true
        self.sparse_y_pred = sparse_y_pred
        self.axis = axis
        self._dtype = dtype

@keras_export("keras.metrics.IoU")
class IoU(_IoUBase):
    def __init__(
        self,
        num_classes,
        target_class_ids,
        name=None,
        dtype=None,
        ignore_class=None,
        sparse_y_true=True,
        sparse_y_pred=True,
        axis=-1,
    ):
        super().__init__(
            name=name,
            num_classes=num_classes,
            ignore_class=ignore_class,
            sparse_y_true=sparse_y_true,
            sparse_y_pred=sparse_y_pred,
            axis=axis,
            dtype=dtype,
        )
        if max(target_class_ids) >= num_classes:
            raise ValueError(
                f"Target class id {max(target_class_ids)} "
                "is out of range, which is "
                f"[{0}, {num_classes})."
            )
        self.target_class_ids = list(target_class_ids)
from keras.src.metrics.iou_metrics import OneHotIoU

# unit tests

# ----------- BASIC TEST CASES -----------

def test_get_config_basic_all_fields():
    # Test with all fields set to non-default values
    obj = OneHotIoU(
        num_classes=3,
        target_class_ids=[0, 2],
        name="iou_metric",
        dtype="float32",
        ignore_class=1,
        sparse_y_pred=True,
        axis=2
    )
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_basic_defaults():
    # Test with only required arguments (all optional/defaults)
    obj = OneHotIoU(num_classes=5, target_class_ids=[1, 3])
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_basic_single_target_class():
    # Test with a single target class id
    obj = OneHotIoU(num_classes=2, target_class_ids=[1])
    codeflash_output = obj.get_config(); config = codeflash_output

# ----------- EDGE TEST CASES -----------


def test_get_config_axis_negative():
    # Edge: axis is negative and not default
    obj = OneHotIoU(num_classes=3, target_class_ids=[0], axis=-2)
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_axis_zero():
    # Edge: axis is zero
    obj = OneHotIoU(num_classes=3, target_class_ids=[1], axis=0)
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_dtype_variants():
    # Edge: dtype is set to various types
    for dtype in [None, "float16", "float64", "int32"]:
        obj = OneHotIoU(num_classes=2, target_class_ids=[0], dtype=dtype)
        codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_ignore_class_negative():
    # Edge: ignore_class is negative
    obj = OneHotIoU(num_classes=3, target_class_ids=[0], ignore_class=-1)
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_name_special_characters():
    # Edge: name with special characters
    obj = OneHotIoU(num_classes=2, target_class_ids=[0], name="iou@#$_metric")
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_mutation_protection():
    # Edge: Changing returned config dict does not affect the object
    obj = OneHotIoU(num_classes=4, target_class_ids=[1,2])
    codeflash_output = obj.get_config(); config = codeflash_output
    config["num_classes"] = 99
    codeflash_output = obj.get_config(); config2 = codeflash_output

def test_get_config_target_class_ids_list_type():
    # Edge: target_class_ids must always be a list in config, even if tuple in input
    obj = OneHotIoU(num_classes=3, target_class_ids=(1,2))
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_sparse_y_pred_types():
    # Edge: sparse_y_pred can be True or False
    for val in [True, False]:
        obj = OneHotIoU(num_classes=2, target_class_ids=[0], sparse_y_pred=val)
        codeflash_output = obj.get_config(); config = codeflash_output

# ----------- LARGE SCALE TEST CASES -----------

def test_get_config_large_num_classes_and_targets():
    # Large: many classes and many target_class_ids
    num_classes = 999
    target_class_ids = list(range(0, 999, 3))  # ~333 target classes
    obj = OneHotIoU(num_classes=num_classes, target_class_ids=target_class_ids)
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_large_name():
    # Large: very long name
    long_name = "iou_" + "x"*900
    obj = OneHotIoU(num_classes=5, target_class_ids=[1], name=long_name)
    codeflash_output = obj.get_config(); config = codeflash_output

def test_get_config_large_config_dict_size():
    # Large: config dict should not grow with data, only with parameter count
    obj = OneHotIoU(num_classes=1000, target_class_ids=list(range(1000)))
    codeflash_output = obj.get_config(); config = codeflash_output
    # The config dict should have only the expected keys
    expected_keys = {
        "num_classes",
        "target_class_ids",
        "name",
        "dtype",
        "ignore_class",
        "sparse_y_pred",
        "axis",
    }

def test_get_config_performance_large():
    # Large: ensure get_config runs efficiently for large input
    import time
    num_classes = 999
    target_class_ids = list(range(999))
    obj = OneHotIoU(num_classes=num_classes, target_class_ids=target_class_ids)
    start = time.time()
    codeflash_output = obj.get_config(); config = codeflash_output
    end = time.time()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.