/**
 * ElementSerializerTest - Unit tests for Element serialization
 */
using Implexus.Storage;

public static int main(string[] args) {
    int passed = 0;
    int failed = 0;

    // Test 1: Null element
    if (test_null_element()) {
        passed++;
        stdout.puts("PASS: test_null_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_null_element\n");
    }

    // Test 2: Boolean elements
    if (test_bool_element()) {
        passed++;
        stdout.puts("PASS: test_bool_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_bool_element\n");
    }

    // Test 3: Int64 elements
    if (test_int64_element()) {
        passed++;
        stdout.puts("PASS: test_int64_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_int64_element\n");
    }

    // Test 4: UInt64 elements
    if (test_uint64_element()) {
        passed++;
        stdout.puts("PASS: test_uint64_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_uint64_element\n");
    }

    // Test 5: Double elements
    if (test_double_element()) {
        passed++;
        stdout.puts("PASS: test_double_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_double_element\n");
    }

    // Test 6: String elements
    if (test_string_element()) {
        passed++;
        stdout.puts("PASS: test_string_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_string_element\n");
    }

    // Test 7: Binary elements
    if (test_binary_element()) {
        passed++;
        stdout.puts("PASS: test_binary_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_binary_element\n");
    }

    // Test 8: Array elements
    if (test_array_element()) {
        passed++;
        stdout.puts("PASS: test_array_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_array_element\n");
    }

    // Test 9: Dictionary/Properties elements
    if (test_dictionary_element()) {
        passed++;
        stdout.puts("PASS: test_dictionary_element\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_dictionary_element\n");
    }

    // Test 10: Round-trip all types
    if (test_round_trip()) {
        passed++;
        stdout.puts("PASS: test_round_trip\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_round_trip\n");
    }

    // Test 11: Complex nested structure
    if (test_nested_structure()) {
        passed++;
        stdout.puts("PASS: test_nested_structure\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_nested_structure\n");
    }

    // Test 12: Empty array
    if (test_empty_array()) {
        passed++;
        stdout.puts("PASS: test_empty_array\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_empty_array\n");
    }

    // Test 13: Empty dictionary
    if (test_empty_dictionary()) {
        passed++;
        stdout.puts("PASS: test_empty_dictionary\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_empty_dictionary\n");
    }

    // Test 14: Large integers
    if (test_large_integers()) {
        passed++;
        stdout.puts("PASS: test_large_integers\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_large_integers\n");
    }

    // Test 15: Special string values
    if (test_special_strings()) {
        passed++;
        stdout.puts("PASS: test_special_strings\n");
    } else {
        failed++;
        stdout.puts("FAIL: test_special_strings\n");
    }

    stdout.printf("\nResults: %d passed, %d failed\n", passed, failed);
    return failed > 0 ? 1 : 0;
}

// Test 1: Null element
bool test_null_element() {
    try {
        var writer = new ElementWriter();
        writer.write_null();
        
        var data = writer.to_binary_data();
        var reader = new ElementReader(data);
        
        var element = reader.read_element();
        return element.is_null();
    } catch (StorageError e) {
        return false;
    }
}

// Test 2: Boolean elements
bool test_bool_element() {
    try {
        // Test true
        var writer1 = new ElementWriter();
        writer1.write_element(new Invercargill.NativeElement<bool?>(true));
        var reader1 = new ElementReader(writer1.to_binary_data());
        var elem1 = reader1.read_element();
        if (elem1.is_null()) return false;
        bool val1 = elem1.as<bool?>();
        if (val1 != true) return false;
        
        // Test false
        var writer2 = new ElementWriter();
        writer2.write_element(new Invercargill.NativeElement<bool?>(false));
        var reader2 = new ElementReader(writer2.to_binary_data());
        var elem2 = reader2.read_element();
        if (elem2.is_null()) return false;
        bool val2 = elem2.as<bool?>();
        if (val2 != false) return false;
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 3: Int64 elements
bool test_int64_element() {
    try {
        int64[] values = { 0, 1, -1, 42, -42, int64.MAX, int64.MIN };
        
        foreach (var val in values) {
            var writer = new ElementWriter();
            writer.write_element(new Invercargill.NativeElement<int64?>(val));
            
            var reader = new ElementReader(writer.to_binary_data());
            var elem = reader.read_element();
            if (elem.is_null()) return false;
            int64? read_val = elem.as<int64?>();
            if (read_val == null || (!) read_val != val) return false;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 4: UInt64 elements
bool test_uint64_element() {
    try {
        uint64[] values = { 0, 1, 42, uint64.MAX };
        
        foreach (var val in values) {
            var writer = new ElementWriter();
            writer.write_element(new Invercargill.NativeElement<uint64?>(val));
            
            var reader = new ElementReader(writer.to_binary_data());
            var elem = reader.read_element();
            if (elem.is_null()) return false;
            uint64? read_val = elem.as<uint64?>();
            if (read_val == null || (!) read_val != val) return false;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 5: Double elements
bool test_double_element() {
    try {
        double[] values = { 0.0, 1.0, -1.0, 3.14159, -3.14159, double.MAX, double.MIN };
        
        foreach (var val in values) {
            var writer = new ElementWriter();
            writer.write_element(new Invercargill.NativeElement<double?>(val));
            
            var reader = new ElementReader(writer.to_binary_data());
            var elem = reader.read_element();
            if (elem.is_null()) return false;
            double? read_val = elem.as<double?>();
            if (read_val == null) return false;
            // Use approximate comparison for doubles
            if (((!) read_val - val).abs() > 0.0001) return false;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 6: String elements
bool test_string_element() {
    try {
        string[] values = { "", "hello", "Hello, World!", "日本語", "line1\nline2" };
        
        foreach (var val in values) {
            var writer = new ElementWriter();
            writer.write_element(new Invercargill.NativeElement<string>(val));
            
            var reader = new ElementReader(writer.to_binary_data());
            var elem = reader.read_element();
            if (elem.is_null()) return false;
            string read_val = elem.as<string>();
            if (read_val != val) return false;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 7: Binary elements
bool test_binary_element() {
    try {
        // Create binary data
        var data = new uint8[] { 0x00, 0x01, 0x02, 0xFF, 0xFE, 0xFD };
        var binary = new Invercargill.DataStructures.ByteBuffer.from_byte_array(data);
        
        var writer = new ElementWriter();
        writer.write_element(new Invercargill.NativeElement<Invercargill.BinaryData>(binary));
        
        var reader = new ElementReader(writer.to_binary_data());
        var elem = reader.read_element();
        if (elem.is_null()) return false;
        
        var read_binary = elem.as<Invercargill.BinaryData>();
        var read_bytes = read_binary.to_bytes();
        
        if (read_bytes.length != data.length) return false;
        for (int i = 0; i < data.length; i++) {
            if (read_bytes.get_data()[i] != data[i]) return false;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 8: Array elements
bool test_array_element() {
    try {
        var array = new Invercargill.DataStructures.Vector<Invercargill.Element>();
        array.add(new Invercargill.NativeElement<int64?>(1));
        array.add(new Invercargill.NativeElement<int64?>(2));
        array.add(new Invercargill.NativeElement<int64?>(3));
        
        var writer = new ElementWriter();
        writer.write_element(new Invercargill.NativeElement<Invercargill.Enumerable<Invercargill.Element>>(array));
        
        var reader = new ElementReader(writer.to_binary_data());
        var elem = reader.read_element();
        if (elem.is_null()) return false;
        
        var read_array = elem.as<Invercargill.Enumerable<Invercargill.Element>>();
        var count = read_array.count();
        if (count != 3) return false;
        
        int64 expected = 1;
        foreach (var item in read_array) {
            if (item.is_null()) return false;
            int64? val = item.as<int64?>();
            if (val == null || (!) val != expected) return false;
            expected++;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 9: Dictionary/Properties elements
bool test_dictionary_element() {
    try {
        var props = new Invercargill.DataStructures.PropertyDictionary();
        props.set("name", new Invercargill.NativeElement<string>("John"));
        props.set("age", new Invercargill.NativeElement<int64?>(30));
        props.set("active", new Invercargill.NativeElement<bool?>(true));
        
        var writer = new ElementWriter();
        writer.write_element(new Invercargill.NativeElement<Invercargill.Properties>(props));
        
        var reader = new ElementReader(writer.to_binary_data());
        var elem = reader.read_element();
        if (elem.is_null()) return false;
        
        var read_props = elem.as<Invercargill.Properties>();
        if (read_props.count() != 3) return false;
        
        // Check name
        var name_elem = read_props.get("name");
        if (name_elem == null || ((!) name_elem).is_null()) return false;
        string name = ((!) name_elem).as<string>();
        if (name != "John") return false;
        
        // Check age
        var age_elem = read_props.get("age");
        if (age_elem == null || ((!) age_elem).is_null()) return false;
        int64? age = ((!) age_elem).as<int64?>();
        if (age == null || (!) age != 30) return false;
        
        // Check active
        var active_elem = read_props.get("active");
        if (active_elem == null || ((!) active_elem).is_null()) return false;
        bool active = ((!) active_elem).as<bool?>();
        if (active != true) return false;
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 10: Round-trip all types
bool test_round_trip() {
    try {
        // Write multiple elements
        var writer = new ElementWriter();
        
        writer.write_element(new Invercargill.NativeElement<bool?>(true));
        writer.write_element(new Invercargill.NativeElement<int64?>(42));
        writer.write_element(new Invercargill.NativeElement<string>("test"));
        
        var data = writer.to_binary_data();
        var reader = new ElementReader(data);
        
        // Read and verify
        var elem1 = reader.read_element();
        if (elem1.is_null()) return false;
        bool val1 = elem1.as<bool?>();
        if (val1 != true) return false;
        
        var elem2 = reader.read_element();
        if (elem2.is_null()) return false;
        int64? val2 = elem2.as<int64?>();
        if (val2 == null || (!) val2 != 42) return false;
        
        var elem3 = reader.read_element();
        if (elem3.is_null()) return false;
        string val3 = elem3.as<string>();
        if (val3 != "test") return false;
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 11: Complex nested structure
bool test_nested_structure() {
    try {
        // Create nested structure: array containing dictionaries
        var inner_dict = new Invercargill.DataStructures.PropertyDictionary();
        inner_dict.set("key", new Invercargill.NativeElement<string>("value"));
        
        var array = new Invercargill.DataStructures.Vector<Invercargill.Element>();
        array.add(new Invercargill.NativeElement<Invercargill.Properties>(inner_dict));
        
        var writer = new ElementWriter();
        writer.write_element(new Invercargill.NativeElement<Invercargill.Enumerable<Invercargill.Element>>(array));
        
        var reader = new ElementReader(writer.to_binary_data());
        var elem = reader.read_element();
        if (elem.is_null()) return false;
        
        var read_array = elem.as<Invercargill.Enumerable<Invercargill.Element>>();
        if (read_array.count() != 1) return false;
        
        foreach (var item in read_array) {
            if (item.is_null()) return false;
            var dict = item.as<Invercargill.Properties>();
            var key_elem = dict.get("key");
            if (key_elem == null || ((!) key_elem).is_null()) return false;
            string key = ((!) key_elem).as<string>();
            if (key != "value") return false;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 12: Empty array
bool test_empty_array() {
    try {
        var array = new Invercargill.DataStructures.Vector<Invercargill.Element>();
        
        var writer = new ElementWriter();
        writer.write_element(new Invercargill.NativeElement<Invercargill.Enumerable<Invercargill.Element>>(array));
        
        var reader = new ElementReader(writer.to_binary_data());
        var elem = reader.read_element();
        if (elem.is_null()) return false;
        
        var read_array = elem.as<Invercargill.Enumerable<Invercargill.Element>>();
        if (read_array.count() != 0) return false;
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 13: Empty dictionary
bool test_empty_dictionary() {
    try {
        var props = new Invercargill.DataStructures.PropertyDictionary();
        
        var writer = new ElementWriter();
        writer.write_element(new Invercargill.NativeElement<Invercargill.Properties>(props));
        
        var reader = new ElementReader(writer.to_binary_data());
        var elem = reader.read_element();
        if (elem.is_null()) return false;
        
        var read_props = elem.as<Invercargill.Properties>();
        if (read_props.count() != 0) return false;
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 14: Large integers
bool test_large_integers() {
    try {
        // Test boundary values
        int64 max = int64.MAX;
        int64 min = int64.MIN;
        
        var writer = new ElementWriter();
        writer.write_element(new Invercargill.NativeElement<int64?>(max));
        writer.write_element(new Invercargill.NativeElement<int64?>(min));
        
        var reader = new ElementReader(writer.to_binary_data());
        
        var elem1 = reader.read_element();
        if (elem1.is_null()) return false;
        int64? val1 = elem1.as<int64?>();
        if (val1 == null || (!) val1 != max) return false;
        
        var elem2 = reader.read_element();
        if (elem2.is_null()) return false;
        int64? val2 = elem2.as<int64?>();
        if (val2 == null || (!) val2 != min) return false;
        
        return true;
    } catch (Error e) {
        return false;
    }
}

// Test 15: Special string values
bool test_special_strings() {
    try {
        string[] special = {
            "",                          // Empty
            " ",                         // Space
            "\t\n\r",                    // Whitespace
            "null",                      // Literal "null"
            "\"quoted\"",               // Quotes
            "back\\slash",              // Backslash
            "日本語",                    // Unicode
            "🎉",                        // Emoji
            "a\0b",                      // Null byte in string
        };
        
        foreach (var str in special) {
            var writer = new ElementWriter();
            writer.write_element(new Invercargill.NativeElement<string>(str));
            
            var reader = new ElementReader(writer.to_binary_data());
            var elem = reader.read_element();
            if (elem.is_null()) return false;
            string read = elem.as<string>();
            if (read != str) return false;
        }
        
        return true;
    } catch (Error e) {
        return false;
    }
}