import Testing
@testable import GObjectGeneratorCore

@Test("Config builder creates valid configuration")
func testConfigBuilder() {
    let config = GenerationConfig(
        library: "GLib",
        version: "2.0",
        girsDirectories: ["/usr/share/gir-1.0"],
        targetDirectory: "Sources/GLib/Generated",
        externalLibraries: [],
        generate: ["GLib.String", "GLib.List"],
        manual: ["GLib.MainLoop"],
        ignore: ["GLib.Test"],
        objects: []
    )
    #expect(config.library == "GLib")
    #expect(config.generate.count == 2)
}

@Test("Object overrides merge correctly")
func testObjectOverrides() {
    let override = ObjectOverrides(status: .generate, finalType: true, concurrency: .mainActor,
                                    version: "2.0", cfgCondition: nil, generateBuilder: false)
    #expect(override.status == .generate)
    #expect(override.finalType == true)
    #expect(override.concurrency == .mainActor)
    #expect(override.version == "2.0")
    #expect(override.cfgCondition == nil)
    #expect(override.generateBuilder == false)
}

@Test("Function overrides can ignore a function")
func testFunctionOverrides() {
    let override = FunctionOverrides(ignore: true)
    #expect(override.ignore == true)
}

@Test("Config with object and function overrides stores values correctly")
func testConfigWithObjectOverrides() throws {
    let widgetOverrides = ObjectOverrides(
        status: .generate, finalType: false, concurrency: .mainActor,
        version: "4.0", cfgCondition: nil, generateBuilder: false
    )
    let showOverride = FunctionOverrides(ignore: true)
    let config = GenerationConfig(
        library: "Gtk",
        version: "4.0",
        girsDirectories: ["vendor/gir-files"],
        targetDirectory: "Sources/GTK/Generated",
        externalLibraries: ["Gdk-4.0", "Gsk-4.0"],
        generate: ["Gtk.Widget", "Gtk.Window"],
        manual: ["Gtk.Buildable"],
        ignore: [],
        objects: [
            .object("Gtk.Widget", overrides: widgetOverrides),
            .function("Gtk.Widget", "show", overrides: showOverride),
            .functionPattern("Gtk.Window", pattern: "set_*", rename: RenameRule(regex: "^set_(.*)", replacement: "$1")),
            .signal("Gtk.Button", "clicked", overrides: SignalOverrides(ignore: true)),
            .property("Gtk.Label", "label", overrides: PropertyOverrides(generate: [.get, .set])),
        ]
    )
    #expect(config.objects.count == 5)
    if case .object(let name, let ov) = config.objects[0] {
        #expect(name == "Gtk.Widget")
        #expect(ov.finalType == false)
    } else { #expect(Bool(false), "Expected .object case") }
    if case .functionPattern(let type, let pattern, let rename) = config.objects[2] {
        #expect(type == "Gtk.Window")
        #expect(pattern == "set_*")
        #expect(rename.regex == "^set_(.*)")
    } else { #expect(Bool(false), "Expected .functionPattern case") }
    if case .signal(let type, let name, let ov) = config.objects[3] {
        #expect(type == "Gtk.Button")
        #expect(name == "clicked")
        #expect(ov.ignore == true)
    } else { #expect(Bool(false), "Expected .signal case") }
    if case .property(let type, let name, let ov) = config.objects[4] {
        #expect(type == "Gtk.Label")
        #expect(name == "label")
        #expect(ov.generate == [.get, .set])
    } else { #expect(Bool(false), "Expected .property case") }
}