import pytest  # used for our unit tests
from aiplatform.metadata.metadata import _get_experiment_schema_version

# function to test
# -*- coding: utf-8 -*-

# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

# Simulate google.cloud.aiplatform.metadata.constants for testing
class _FakeConstants:
    # Basic test: SYSTEM_EXPERIMENT points to a valid key in SCHEMA_VERSIONS
    SYSTEM_EXPERIMENT = "experiment"
    SCHEMA_VERSIONS = {
        "experiment": "v1",
        "experiment_v2": "v2",
        "": "v0",
        "long_key_" + "x"*990: "v_large",
    }

constants = _FakeConstants
from aiplatform.metadata.metadata import _get_experiment_schema_version

# unit tests

# ----------- Basic Test Cases -----------

def test_basic_valid_schema_version():
    """Test that the function returns the correct version for the default SYSTEM_EXPERIMENT"""
    codeflash_output = _get_experiment_schema_version() # 835ns -> 471ns (77.3% faster)

def test_basic_change_system_experiment():
    """Test that changing SYSTEM_EXPERIMENT returns the correct schema version"""
    constants.SYSTEM_EXPERIMENT = "experiment_v2"
    codeflash_output = _get_experiment_schema_version() # 450ns -> 410ns (9.76% faster)
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset for other tests

def test_basic_empty_string_key():
    """Test that SYSTEM_EXPERIMENT as empty string returns the correct schema version"""
    constants.SYSTEM_EXPERIMENT = ""
    codeflash_output = _get_experiment_schema_version() # 368ns -> 389ns (5.40% slower)
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset

def test_basic_multiple_versions():
    """Test that switching SYSTEM_EXPERIMENT between multiple valid keys works"""
    constants.SYSTEM_EXPERIMENT = "experiment"
    codeflash_output = _get_experiment_schema_version() # 381ns -> 368ns (3.53% faster)
    constants.SYSTEM_EXPERIMENT = "experiment_v2"
    codeflash_output = _get_experiment_schema_version() # 212ns -> 194ns (9.28% faster)
    constants.SYSTEM_EXPERIMENT = ""  # test empty
    codeflash_output = _get_experiment_schema_version() # 163ns -> 163ns (0.000% faster)
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset

# ----------- Edge Test Cases -----------








def test_edge_long_key():
    """Test that a very long key name works correctly"""
    long_key = "long_key_" + "x"*990
    constants.SYSTEM_EXPERIMENT = long_key
    codeflash_output = _get_experiment_schema_version() # 783ns -> 499ns (56.9% faster)
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset


def test_large_scale_many_schema_versions():
    """Test with a large SCHEMA_VERSIONS dict (up to 1000 elements)"""
    # Create 1000 keys, each mapping to a string value
    large_dict = {f"exp_{i}": f"v{i}" for i in range(1000)}
    large_dict["experiment"] = "v1"  # Ensure original key is present
    original = constants.SCHEMA_VERSIONS
    constants.SCHEMA_VERSIONS = large_dict
    # Pick a few keys to test
    for i in [0, 500, 999]:
        constants.SYSTEM_EXPERIMENT = f"exp_{i}"
        codeflash_output = _get_experiment_schema_version() # 1.13μs -> 779ns (44.8% faster)
    # Test original key
    constants.SYSTEM_EXPERIMENT = "experiment"
    codeflash_output = _get_experiment_schema_version() # 160ns -> 158ns (1.27% faster)
    constants.SCHEMA_VERSIONS = original
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset


def test_large_scale_all_keys_are_numbers():
    """Test SCHEMA_VERSIONS where all keys are integers, SYSTEM_EXPERIMENT is int"""
    large_dict = {i: f"v{i}" for i in range(1000)}
    original = constants.SCHEMA_VERSIONS
    constants.SCHEMA_VERSIONS = large_dict
    for i in [0, 500, 999]:
        constants.SYSTEM_EXPERIMENT = i
        codeflash_output = _get_experiment_schema_version() # 1.11μs -> 819ns (35.4% faster)
    constants.SCHEMA_VERSIONS = original
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset

def test_large_scale_all_values_are_objects():
    """Test SCHEMA_VERSIONS where all values are objects (e.g., tuples)"""
    large_dict = {f"exp_{i}": (i, f"v{i}") for i in range(1000)}
    original = constants.SCHEMA_VERSIONS
    constants.SCHEMA_VERSIONS = large_dict
    for i in [0, 500, 999]:
        constants.SYSTEM_EXPERIMENT = f"exp_{i}"
        codeflash_output = _get_experiment_schema_version() # 839ns -> 740ns (13.4% faster)
    constants.SCHEMA_VERSIONS = original
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset

def test_large_scale_performance():
    """Test that function call is fast even with large SCHEMA_VERSIONS"""
    import time
    large_dict = {f"exp_{i}": f"v{i}" for i in range(1000)}
    large_dict["experiment"] = "v1"
    original = constants.SCHEMA_VERSIONS
    constants.SCHEMA_VERSIONS = large_dict
    constants.SYSTEM_EXPERIMENT = "exp_999"
    start = time.time()
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 427ns -> 373ns (14.5% faster)
    end = time.time()
    constants.SCHEMA_VERSIONS = original
    constants.SYSTEM_EXPERIMENT = "experiment"  # Reset
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from aiplatform.metadata.metadata import _get_experiment_schema_version

# function to test
# -*- coding: utf-8 -*-

# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

# --- Minimal stub for google.cloud.aiplatform.metadata.constants ---
# This is necessary for the tests to run, since we cannot import the real package here.
# In a real environment, these would come from the actual library.

class _ConstantsStub:
    # SYSTEM_EXPERIMENT is the key for the current experiment schema version
    SYSTEM_EXPERIMENT = "experiment"
    # SCHEMA_VERSIONS maps system keys to their schema versions
    SCHEMA_VERSIONS = {
        "experiment": "v1.0",
        "legacy_experiment": "v0.9",
        "future_experiment": "v2.0"
    }

# Simulate the import
constants = _ConstantsStub
from aiplatform.metadata.metadata import _get_experiment_schema_version

# ------------------- UNIT TESTS -------------------

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

def test_basic_returns_expected_version():
    """Test that the function returns the correct version for the default experiment."""
    codeflash_output = _get_experiment_schema_version() # 393ns -> 369ns (6.50% faster)

def test_basic_returns_string_type():
    """Test that the function always returns a string."""
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 362ns -> 367ns (1.36% slower)

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




def test_edge_schema_versions_has_non_string(monkeypatch):
    """Test behavior when SCHEMA_VERSIONS contains a non-string version value."""
    original_versions = constants.SCHEMA_VERSIONS.copy()
    monkeypatch.setitem(constants.SCHEMA_VERSIONS, constants.SYSTEM_EXPERIMENT, 1234)
    try:
        codeflash_output = _get_experiment_schema_version(); result = codeflash_output
    finally:
        constants.SCHEMA_VERSIONS = original_versions

def test_edge_schema_versions_has_empty_string(monkeypatch):
    """Test behavior when SCHEMA_VERSIONS contains an empty string as version."""
    original_versions = constants.SCHEMA_VERSIONS.copy()
    monkeypatch.setitem(constants.SCHEMA_VERSIONS, constants.SYSTEM_EXPERIMENT, "")
    try:
        codeflash_output = _get_experiment_schema_version(); result = codeflash_output
    finally:
        constants.SCHEMA_VERSIONS = original_versions


def test_large_scale_many_schema_versions(monkeypatch):
    """Test with a large SCHEMA_VERSIONS dictionary."""
    # Create a large dictionary
    large_dict = {f"exp_{i}": f"v{i}.0" for i in range(1000)}
    # Set SYSTEM_EXPERIMENT to a random key
    large_dict["exp_999"] = "v999.0"
    monkeypatch.setattr(constants, "SCHEMA_VERSIONS", large_dict)
    monkeypatch.setattr(constants, "SYSTEM_EXPERIMENT", "exp_999")
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 793ns -> 512ns (54.9% faster)

def test_large_scale_schema_versions_with_long_strings(monkeypatch):
    """Test with very long string values in SCHEMA_VERSIONS."""
    long_version = "v" + "1" * 500  # 501 characters
    monkeypatch.setitem(constants.SCHEMA_VERSIONS, constants.SYSTEM_EXPERIMENT, long_version)
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 497ns -> 403ns (23.3% faster)

def test_large_scale_schema_versions_with_many_keys(monkeypatch):
    """Test that the function is deterministic with many keys and a valid SYSTEM_EXPERIMENT."""
    # Create 999 dummy entries, plus the real one
    many_keys = {f"dummy_{i}": f"v{i}.0" for i in range(999)}
    many_keys["experiment"] = "v1.0"
    monkeypatch.setattr(constants, "SCHEMA_VERSIONS", many_keys)
    monkeypatch.setattr(constants, "SYSTEM_EXPERIMENT", "experiment")
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 467ns -> 390ns (19.7% faster)

def test_large_scale_schema_versions_with_similar_keys(monkeypatch):
    """Test that the function does not confuse similar keys."""
    similar_keys = {f"experiment_{i}": f"v{i}.0" for i in range(10)}
    similar_keys["experiment"] = "v1.0"
    monkeypatch.setattr(constants, "SCHEMA_VERSIONS", similar_keys)
    monkeypatch.setattr(constants, "SYSTEM_EXPERIMENT", "experiment")
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 448ns -> 394ns (13.7% faster)

# ---- MUTATION TESTING GUARANTEE ----

def test_mutation_wrong_key(monkeypatch):
    """Test that changing SYSTEM_EXPERIMENT to a different key returns the correct version."""
    monkeypatch.setattr(constants, "SYSTEM_EXPERIMENT", "legacy_experiment")
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 401ns -> 380ns (5.53% faster)

def test_mutation_wrong_value(monkeypatch):
    """Test that changing the value for SYSTEM_EXPERIMENT changes the return value."""
    original_versions = constants.SCHEMA_VERSIONS.copy()
    monkeypatch.setitem(constants.SCHEMA_VERSIONS, constants.SYSTEM_EXPERIMENT, "vX.Y")
    codeflash_output = _get_experiment_schema_version(); result = codeflash_output # 409ns -> 382ns (7.07% faster)
    constants.SCHEMA_VERSIONS = original_versions