Collection and Content Assertions

/**
 * Asserts that the iterable contains the specified element
 * @param iterable - Iterable to search in
 * @param element - Element to find
 * @param message - Optional custom failure message
 */
fun <T> assertContains(iterable: Iterable<T>, element: T, message: String? = null)

import kotlin.test.*

@Test
fun testIterableContains() {
    val numbers = listOf(1, 2, 3, 4, 5)
    assertContains(numbers, 3)
    assertContains(numbers, 1, "Should contain first element")
    
    val names = setOf("Alice", "Bob", "Charlie")
    assertContains(names, "Bob")
    
    // Works with any Iterable
    val sequence = sequenceOf("a", "b", "c")
    assertContains(sequence, "b", "Sequence should contain 'b'")
}

/**
 * Asserts that the array contains the specified element
 * @param array - Array to search in
 * @param element - Element to find
 * @param message - Optional custom failure message
 */
fun <T> assertContains(array: Array<T>, element: T, message: String? = null)

// Primitive array variants
fun assertContains(array: ByteArray, element: Byte, message: String? = null)
fun assertContains(array: ShortArray, element: Short, message: String? = null)
fun assertContains(array: IntArray, element: Int, message: String? = null)
fun assertContains(array: LongArray, element: Long, message: String? = null)
fun assertContains(array: BooleanArray, element: Boolean, message: String? = null)
fun assertContains(array: CharArray, element: Char, message: String? = null)

// Unsigned array variants
fun assertContains(array: UByteArray, element: UByte, message: String? = null)
fun assertContains(array: UShortArray, element: UShort, message: String? = null)
fun assertContains(array: UIntArray, element: UInt, message: String? = null)
fun assertContains(array: ULongArray, element: ULong, message: String? = null)

@Test
fun testArrayContains() {
    // Generic arrays
    val stringArray = arrayOf("hello", "world", "test")
    assertContains(stringArray, "world")
    
    // Primitive arrays
    val numbers = intArrayOf(10, 20, 30, 40)
    assertContains(numbers, 20, "Should contain 20")
    
    val bytes = byteArrayOf(1, 2, 3)
    assertContains(bytes, 2.toByte())
    
    val chars = charArrayOf('a', 'b', 'c')
    assertContains(chars, 'b', "Should contain character 'b'")
    
    // Unsigned arrays
    val uints = uintArrayOf(1u, 2u, 3u)
    assertContains(uints, 2u)
}

/**
 * Asserts that the range contains the specified value
 */
fun assertContains(range: IntRange, value: Int, message: String? = null)
fun assertContains(range: LongRange, value: Long, message: String? = null)
fun assertContains(range: CharRange, value: Char, message: String? = null)
fun assertContains(range: UIntRange, value: UInt, message: String? = null)
fun assertContains(range: ULongRange, value: ULong, message: String? = null)
fun <T : Comparable<T>> assertContains(range: ClosedRange<T>, value: T, message: String? = null)
fun <T : Comparable<T>> assertContains(range: OpenEndRange<T>, value: T, message: String? = null)

@Test
fun testRangeContains() {
    val ageRange = 18..65
    assertContains(ageRange, 25, "Age should be in valid range")
    assertContains(ageRange, 18, "Should include start of range")
    assertContains(ageRange, 65, "Should include end of range")
    
    val charRange = 'a'..'z'
    assertContains(charRange, 'm', "Should contain middle character")
    
    // Custom comparable range
    val dateRange = LocalDate.of(2023, 1, 1)..LocalDate.of(2023, 12, 31)
    assertContains(dateRange, LocalDate.of(2023, 6, 15), "Date should be in 2023")
}

/**
 * Asserts that the map contains the specified key
 * @param map - Map to search in
 * @param key - Key to find
 * @param message - Optional custom failure message
 */
fun <K, V> assertContains(map: Map<K, V>, key: K, message: String? = null)

@Test
fun testMapContains() {
    val config = mapOf(
        "host" to "localhost",
        "port" to 8080,
        "ssl" to true
    )
    
    assertContains(config, "host", "Config should contain host setting")
    assertContains(config, "port")
    assertContains(config, "ssl")
    
    // Works with any map type
    val mutableMap = mutableMapOf("a" to 1, "b" to 2)
    assertContains(mutableMap, "a")
}

/**
 * Asserts that the char sequence contains the specified char
 * @param charSequence - String to search in
 * @param char - Character to find
 * @param ignoreCase - Whether to ignore case when comparing
 * @param message - Optional custom failure message
 */
fun assertContains(charSequence: CharSequence, char: Char, ignoreCase: Boolean = false, message: String? = null)

/**
 * Asserts that the char sequence contains the specified substring
 * @param charSequence - String to search in
 * @param other - Substring to find
 * @param ignoreCase - Whether to ignore case when comparing
 * @param message - Optional custom failure message
 */
fun assertContains(charSequence: CharSequence, other: CharSequence, ignoreCase: Boolean = false, message: String? = null)

/**
 * Asserts that the char sequence contains a match for the regex
 * @param charSequence - String to search in
 * @param regex - Regular expression to match
 * @param message - Optional custom failure message
 */
fun assertContains(charSequence: CharSequence, regex: Regex, message: String? = null)

@Test
fun testStringContains() {
    val text = "Hello World"
    
    // Character search
    assertContains(text, 'W', message = "Should contain 'W'")
    assertContains(text, 'w', ignoreCase = true, "Should contain 'w' ignoring case")
    
    // Substring search
    assertContains(text, "World", "Should contain 'World'")
    assertContains(text, "hello", ignoreCase = true, "Should contain 'hello' ignoring case")
    
    // Regex search
    val emailPattern = Regex("""\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b""")
    val email = "Contact us at support@example.com for help"
    assertContains(email, emailPattern, "Should contain valid email")
    
    // Phone number pattern
    val phoneText = "Call us at (555) 123-4567"
    val phonePattern = Regex("""\(\d{3}\) \d{3}-\d{4}""")
    assertContains(phoneText, phonePattern, "Should contain phone number")
}

/**
 * Asserts that the expected iterable is structurally equal to the actual iterable
 * Two iterables are structurally equal if they have the same size and elements
 * at corresponding positions are equal
 * @param expected - Expected iterable content
 * @param actual - Actual iterable to compare
 * @param message - Optional custom failure message
 */
fun <T> assertContentEquals(expected: Iterable<T>?, actual: Iterable<T>?, message: String? = null)

/**
 * Asserts that the expected sequence is structurally equal to the actual sequence
 */
fun <T> assertContentEquals(expected: Sequence<T>?, actual: Sequence<T>?, message: String? = null)

@Test
fun testIterableContentEquals() {
    val list1 = listOf(1, 2, 3)
    val list2 = mutableListOf(1, 2, 3)
    
    // Different list types, same content
    assertContentEquals(list1, list2, "Lists should have same content")
    
    // Sequences
    val seq1 = sequenceOf("a", "b", "c")
    val seq2 = listOf("a", "b", "c").asSequence()
    assertContentEquals(seq1, seq2, "Sequences should have same content")
    
    // Null handling
    assertContentEquals(null, null, "Both null should be equal")
    
    // Order matters
    val ordered1 = listOf(1, 2, 3)
    val ordered2 = listOf(3, 2, 1)
    // This would fail: assertContentEquals(ordered1, ordered2)
}

/**
 * Asserts that arrays are structurally equal (same size, equal elements at corresponding indices)
 */
fun <T> assertContentEquals(expected: Array<T>?, actual: Array<T>?, message: String? = null)

// Primitive array variants
fun assertContentEquals(expected: ByteArray?, actual: ByteArray?, message: String? = null)
fun assertContentEquals(expected: ShortArray?, actual: ShortArray?, message: String? = null)
fun assertContentEquals(expected: IntArray?, actual: IntArray?, message: String? = null)
fun assertContentEquals(expected: LongArray?, actual: LongArray?, message: String? = null)
fun assertContentEquals(expected: BooleanArray?, actual: BooleanArray?, message: String? = null)
fun assertContentEquals(expected: CharArray?, actual: CharArray?, message: String? = null)
fun assertContentEquals(expected: FloatArray?, actual: FloatArray?, message: String? = null)
fun assertContentEquals(expected: DoubleArray?, actual: DoubleArray?, message: String? = null)

// Unsigned array variants
fun assertContentEquals(expected: UByteArray?, actual: UByteArray?, message: String? = null)
fun assertContentEquals(expected: UShortArray?, actual: UShortArray?, message: String? = null)
fun assertContentEquals(expected: UIntArray?, actual: UIntArray?, message: String? = null)
fun assertContentEquals(expected: ULongArray?, actual: ULongArray?, message: String? = null)

@Test
fun testArrayContentEquals() {
    // Generic arrays
    val array1 = arrayOf("hello", "world")
    val array2 = arrayOf("hello", "world")
    assertContentEquals(array1, array2, "String arrays should match")
    
    // Primitive arrays
    val ints1 = intArrayOf(1, 2, 3, 4, 5)
    val ints2 = intArrayOf(1, 2, 3, 4, 5)
    assertContentEquals(ints1, ints2, "Int arrays should match")
    
    val chars1 = charArrayOf('a', 'b', 'c')
    val chars2 = "abc".toCharArray()
    assertContentEquals(chars1, chars2, "Char arrays should match")
    
    // Floating point arrays (exact equality)
    val doubles1 = doubleArrayOf(1.0, 2.0, Double.NaN)
    val doubles2 = doubleArrayOf(1.0, 2.0, Double.NaN)
    assertContentEquals(doubles1, doubles2, "Double arrays with NaN should match")
    
    // Null handling
    assertContentEquals(null, null as IntArray?, "Null arrays should be equal")
}

@Test
fun testDataProcessing() {
    val input = listOf("apple", "banana", "cherry")
    val processed = input.map { it.uppercase() }
    
    val expected = listOf("APPLE", "BANANA", "CHERRY")
    assertContentEquals(expected, processed, "Should uppercase all strings")
    
    // Array transformation
    val numbers = intArrayOf(1, 2, 3, 4, 5)
    val doubled = numbers.map { it * 2 }.toIntArray()
    val expectedDoubled = intArrayOf(2, 4, 6, 8, 10)
    assertContentEquals(expectedDoubled, doubled, "Should double all numbers")
}

data class Person(val name: String, val age: Int)

@Test
fun testCustomObjectCollections() {
    val people1 = listOf(
        Person("Alice", 30),
        Person("Bob", 25)
    )
    
    val people2 = mutableListOf<Person>().apply {
        add(Person("Alice", 30))
        add(Person("Bob", 25))
    }
    
    assertContentEquals(people1, people2, "Person lists should match")
    
    // With arrays
    val peopleArray1 = arrayOf(Person("Charlie", 35))
    val peopleArray2 = arrayOf(Person("Charlie", 35))
    assertContentEquals(peopleArray1, peopleArray2, "Person arrays should match")
}

@Test
fun testSearchOperations() {
    val inventory = listOf("apples", "bananas", "oranges", "grapes")
    
    // Test contains operation
    assertContains(inventory, "bananas", "Inventory should contain bananas")
    
    // Test filtering results
    val fruitsWithA = inventory.filter { it.contains('a') }
    val expectedWithA = listOf("apples", "bananas", "oranges", "grapes")
    assertContentEquals(expectedWithA, fruitsWithA, "Should find all fruits with 'a'")
    
    // Test map operations
    val prices = mapOf("apple" to 1.50, "banana" to 0.75, "orange" to 2.00)
    assertContains(prices, "apple", "Price list should contain apple")
    
    val expensiveItems = prices.filter { it.value > 1.0 }.keys
    assertContains(expensiveItems, "apple")
    assertContains(expensiveItems, "orange")
}

@Test
fun testComplexStringPatterns() {
    val logEntry = "2023-12-01 14:30:25 [INFO] User john.doe@example.com logged in from 192.168.1.100"
    
    // Test multiple patterns
    assertContains(logEntry, Regex("""\d{4}-\d{2}-\d{2}"""), "Should contain date")
    assertContains(logEntry, Regex("""\d{2}:\d{2}:\d{2}"""), "Should contain time")
    assertContains(logEntry, Regex("""\[INFO\]"""), "Should contain log level")
    assertContains(logEntry, Regex("""\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"""), "Should contain email")
    assertContains(logEntry, Regex("""\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b"""), "Should contain IP address")
}