from typing import Dict, Optional, Union

# imports
import pytest  # used for our unit tests
from aiplatform.training_jobs import _ForecastingTrainingJob


# Function under test: _create_window_config
def _create_window_config(
    column: Optional[str] = None,
    stride_length: Optional[int] = None,
    max_count: Optional[int] = None,
) -> Optional[Dict[str, Union[int, str]]]:
    """Creates a window config from training job arguments."""
    configs = {'column': column, 'strideLength': stride_length, 'maxCount': max_count}
    present_configs = {k: v for (k, v) in configs.items() if v is not None}
    if not present_configs:
        return None
    if len(present_configs) > 1:
        raise ValueError('More than one windowing strategy provided. Make sure only one of window_column, window_stride_length, or window_max_count is specified.')
    return present_configs

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

# 1. BASIC TEST CASES























#------------------------------------------------
from typing import Dict, Optional, Union

# imports
import pytest
from aiplatform.training_jobs import _ForecastingTrainingJob

# Unit tests for _create_window_config

# 1. Basic Test Cases

def test_none_arguments_returns_none():
    # All arguments None should return None
    codeflash_output = _ForecastingTrainingJob._create_window_config() # 1.56μs -> 481ns (225% faster)

def test_only_column_returns_column_dict():
    # Only column provided
    codeflash_output = _ForecastingTrainingJob._create_window_config(column="my_col"); result = codeflash_output # 1.91μs -> 748ns (156% faster)

def test_only_stride_length_returns_stride_length_dict():
    # Only stride_length provided
    codeflash_output = _ForecastingTrainingJob._create_window_config(stride_length=5); result = codeflash_output # 1.69μs -> 634ns (167% faster)

def test_only_max_count_returns_max_count_dict():
    # Only max_count provided
    codeflash_output = _ForecastingTrainingJob._create_window_config(max_count=10); result = codeflash_output # 1.64μs -> 597ns (174% faster)

# 2. Edge Test Cases

def test_multiple_arguments_raises_value_error_column_and_stride():
    # Both column and stride_length provided
    with pytest.raises(ValueError) as excinfo:
        _ForecastingTrainingJob._create_window_config(column="c", stride_length=1) # 2.12μs -> 1.10μs (93.7% faster)

def test_multiple_arguments_raises_value_error_column_and_max_count():
    # Both column and max_count provided
    with pytest.raises(ValueError) as excinfo:
        _ForecastingTrainingJob._create_window_config(column="c", max_count=1) # 2.17μs -> 1.02μs (112% faster)

def test_multiple_arguments_raises_value_error_stride_and_max_count():
    # Both stride_length and max_count provided
    with pytest.raises(ValueError) as excinfo:
        _ForecastingTrainingJob._create_window_config(stride_length=1, max_count=1) # 2.05μs -> 1.02μs (101% faster)

def test_all_arguments_raises_value_error():
    # All three provided
    with pytest.raises(ValueError) as excinfo:
        _ForecastingTrainingJob._create_window_config(column="c", stride_length=1, max_count=1) # 2.18μs -> 1.00μs (117% faster)






def test_column_special_characters():
    # Edge: column contains special characters
    special_col = "!@#$%^&*()_+-=~`"
    codeflash_output = _ForecastingTrainingJob._create_window_config(column=special_col); result = codeflash_output # 1.56μs -> 601ns (159% faster)

def test_column_unicode():
    # Edge: column is unicode
    unicode_col = "列名"
    codeflash_output = _ForecastingTrainingJob._create_window_config(column=unicode_col); result = codeflash_output # 1.54μs -> 576ns (168% faster)

def test_large_stride_length():
    # Edge: stride_length is very large (close to 1000)
    codeflash_output = _ForecastingTrainingJob._create_window_config(stride_length=999); result = codeflash_output # 1.52μs -> 587ns (159% faster)

def test_large_max_count():
    # Edge: max_count is very large (close to 1000)
    codeflash_output = _ForecastingTrainingJob._create_window_config(max_count=999); result = codeflash_output # 1.58μs -> 551ns (186% faster)

def test_column_none_and_others_none():
    # Edge: column explicitly None, others None
    codeflash_output = _ForecastingTrainingJob._create_window_config(column=None, stride_length=None, max_count=None); result = codeflash_output # 1.54μs -> 632ns (143% faster)

# 3. Large Scale Test Cases

def test_column_long_string():
    # Large: column is a very long string (1000 chars)
    long_col = "a" * 1000
    codeflash_output = _ForecastingTrainingJob._create_window_config(column=long_col); result = codeflash_output # 1.63μs -> 642ns (154% faster)

def test_stride_length_large_value():
    # Large: stride_length is a large integer (close to 1e6 but within reasonable int range)
    large_stride = 999_999
    codeflash_output = _ForecastingTrainingJob._create_window_config(stride_length=large_stride); result = codeflash_output # 1.67μs -> 644ns (159% faster)

def test_max_count_large_value():
    # Large: max_count is a large integer (close to 1e6 but within reasonable int range)
    large_count = 999_999
    codeflash_output = _ForecastingTrainingJob._create_window_config(max_count=large_count); result = codeflash_output # 1.55μs -> 594ns (161% faster)

def test_column_very_long_unicode_string():
    # Large: column is a long unicode string (500 chars)
    long_unicode_col = "列" * 500
    codeflash_output = _ForecastingTrainingJob._create_window_config(column=long_unicode_col); result = codeflash_output # 1.54μs -> 595ns (159% faster)

def test_stride_length_max_python_int():
    # Large: stride_length is maximum Python int (simulate large, but not memory-excessive)
    import sys
    max_int = sys.maxsize
    codeflash_output = _ForecastingTrainingJob._create_window_config(stride_length=max_int); result = codeflash_output # 1.62μs -> 584ns (177% faster)

def test_max_count_max_python_int():
    # Large: max_count is maximum Python int (simulate large, but not memory-excessive)
    import sys
    max_int = sys.maxsize
    codeflash_output = _ForecastingTrainingJob._create_window_config(max_count=max_int); result = codeflash_output # 1.57μs -> 561ns (180% faster)

# Determinism test (same input, same output)
def test_determinism():
    # Calling with same arguments twice should yield same result
    args = {"column": "foo"}
    codeflash_output = _ForecastingTrainingJob._create_window_config(**args); r1 = codeflash_output # 1.54μs -> 557ns (177% faster)
    codeflash_output = _ForecastingTrainingJob._create_window_config(**args); r2 = codeflash_output # 607ns -> 291ns (109% faster)

# Type robustness: test with float and bool (should be accepted as is, since function doesn't type-check)
def test_stride_length_float():
    # stride_length as float
    codeflash_output = _ForecastingTrainingJob._create_window_config(stride_length=3.14); result = codeflash_output # 1.59μs -> 574ns (176% faster)

def test_max_count_bool():
    # max_count as bool
    codeflash_output = _ForecastingTrainingJob._create_window_config(max_count=True); result = codeflash_output # 1.55μs -> 564ns (174% faster)

# Test with explicit None for all arguments
def test_all_explicit_none():
    codeflash_output = _ForecastingTrainingJob._create_window_config(column=None, stride_length=None, max_count=None) # 1.54μs -> 624ns (147% faster)

# Test with whitespace string as column
def test_column_whitespace_string():
    codeflash_output = _ForecastingTrainingJob._create_window_config(column="   "); result = codeflash_output # 1.55μs -> 617ns (152% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.