import Testing
@testable import GObjectGeneratorCore

@Test("Analysis resolves class hierarchy")
func testClassHierarchy() {
    let repo = Repository(namespaces: [
        Namespace(name: "Gtk", version: "4.0", classes: [
            Class(name: "Widget", cType: "GtkWidget", parent: "GObject.Object"),
            Class(name: "Window", cType: "GtkWindow", parent: "Widget"),
            Class(name: "ApplicationWindow", cType: "GtkApplicationWindow", parent: "Window"),
        ])
    ])
    let analyzer = Analyzer(config: GenerationConfig(
        library: "Gtk", version: "4.0", girsDirectories: [], targetDirectory: "",
        externalLibraries: [], generate: ["Gtk.Window"], manual: [], ignore: [], objects: []
    ))
    let result = analyzer.analyze(repository: repo)
    #expect(result.classHierarchy["Gtk.Window"] == "Gtk.Widget")
    #expect(result.classHierarchy["Gtk.ApplicationWindow"] == "Gtk.Window")
}

@Test("Analysis filters types by generate list")
func testTypeFiltering() {
    let repo = Repository(namespaces: [
        Namespace(name: "Gtk", version: "4.0", classes: [
            Class(name: "Widget", cType: "GtkWidget", parent: "GObject.Object"),
            Class(name: "Window", cType: "GtkWindow", parent: "Widget"),
            Class(name: "Button", cType: "GtkButton", parent: "Widget"),
        ])
    ])
    let config = GenerationConfig(library: "Gtk", version: "4.0", girsDirectories: [],
        targetDirectory: "", externalLibraries: [],
        generate: ["Gtk.Widget", "Gtk.Button"], manual: [], ignore: ["Gtk.Window"], objects: [])
    let analyzer = Analyzer(config: config)
    let result = analyzer.analyze(repository: repo)
    #expect(result.generatedTypes.contains("Gtk.Widget"))
    #expect(result.generatedTypes.contains("Gtk.Button"))
    #expect(!result.generatedTypes.contains("Gtk.Window"))
    #expect(result.manualTypes.isEmpty)
}

@Test("Analyzer applies signal overrides")
func testSignalOverrides() {
    let config = GenerationConfig(
        library: "Gtk", version: "4.0",
        girsDirectories: [], targetDirectory: "", externalLibraries: [],
        generate: ["Gtk.Button"], manual: [], ignore: [],
        objects: [.signal("Gtk.Button", "clicked", overrides: SignalOverrides(ignore: true, inhibit: true))]
    )
    let analyzer = Analyzer(config: config)
    let result = analyzer.analyze(repository: Repository())
    let key = "Gtk.Button.clicked"
    #expect(result.signalOverrides[key]?.ignore == true)
    #expect(result.signalOverrides[key]?.inhibit == true)
}

@Test("Analyzer applies property overrides")
func testPropertyOverrides() {
    let config = GenerationConfig(
        library: "Gtk", version: "4.0",
        girsDirectories: [], targetDirectory: "", externalLibraries: [],
        generate: ["Gtk.Widget"], manual: [], ignore: [],
        objects: [.property("Gtk.Widget", "name", overrides: PropertyOverrides(generate: [.get, .set]))]
    )
    let analyzer = Analyzer(config: config)
    let result = analyzer.analyze(repository: Repository())
    let key = "Gtk.Widget.name"
    #expect(result.propertyOverrides[key]?.generate == [.get, .set])
}

@Test("Analyzer applies function pattern overrides")
func testFunctionPatternOverrides() {
    let rename = RenameRule(regex: "^gtk_", replacement: "")
    let config = GenerationConfig(
        library: "Gtk", version: "4.0",
        girsDirectories: [], targetDirectory: "", externalLibraries: [],
        generate: [], manual: [], ignore: [],
        objects: [.functionPattern("Gtk.Widget", pattern: "set_*", rename: rename)]
    )
    let analyzer = Analyzer(config: config)
    let result = analyzer.analyze(repository: Repository())
    #expect(result.functionPatterns.count == 1)
    if let fr = result.functionPatterns.first {
        #expect(fr.typeName == "Gtk.Widget")
        #expect(fr.pattern == "set_*")
        #expect(fr.rename.regex == "^gtk_")
        #expect(fr.rename.replacement == "")
    } else {
        Issue.record("Expected function pattern entry")
    }
}