import Testing
@testable import GObjectGeneratorCore

@Test("generatePackageScaffolding produces Package.swift")
func testPackageScaffolding() {
    let config = GenerationConfig(library: "Gtk", version: "4.0", girsDirectories: [],
        targetDirectory: "", externalLibraries: [],
        generate: ["Gtk.Widget"], manual: [], ignore: [], objects: [])
    let repo = Repository(
        namespaces: [
            Namespace(name: "Gtk", version: "4.0", cSharedLibrary: "libgtk-4.so.1", cIdentifierPrefix: "Gtk")
        ],
        cHeaderPath: "gtk/gtk.h",
        includedLibraryLinks: ["gdk-4", "gsk-4"]
    )
    let scaffolding = CodeGenerator.generatePackageScaffolding(config: config, repository: repo)

    #expect(scaffolding.keys.contains("Package.swift"))
    #expect(scaffolding["Package.swift"]?.contains("name: \"Gtk\"") == true)
    #expect(scaffolding["Package.swift"]?.contains("pkgConfig: \"gtk-4\"") == true)
}

@Test("generatePackageScaffolding produces module map")
func testModuleMapScaffolding() {
    let config = GenerationConfig(library: "Gtk", version: "4.0", girsDirectories: [],
        targetDirectory: "", externalLibraries: [],
        generate: ["Gtk.Widget"], manual: [], ignore: [], objects: [])
    let repo = Repository(
        namespaces: [
            Namespace(name: "Gtk", version: "4.0", cSharedLibrary: "libgtk-4.so.1", cIdentifierPrefix: "Gtk")
        ],
        cHeaderPath: "gtk/gtk.h",
        includedLibraryLinks: ["gdk-4", "gsk-4"]
    )
    let scaffolding = CodeGenerator.generatePackageScaffolding(config: config, repository: repo)

    let moduleMapName = "Sources/CGtk/module.modulemap"
    #expect(scaffolding.keys.contains(moduleMapName))
    #expect(scaffolding[moduleMapName]?.contains("module CGtk [system]") == true)
    #expect(scaffolding[moduleMapName]?.contains("link \"gdk-4\"") == true)
}

@Test("generatePackageScaffolding produces umbrella header")
func testUmbrellaHeader() {
    let config = GenerationConfig(library: "Gtk", version: "4.0", girsDirectories: [],
        targetDirectory: "", externalLibraries: [],
        generate: ["Gtk.Widget"], manual: [], ignore: [], objects: [])
    let repo = Repository(
        namespaces: [
            Namespace(name: "Gtk", version: "4.0", cSharedLibrary: "libgtk-4.so.1", cIdentifierPrefix: "Gtk")
        ],
        cHeaderPath: "gtk/gtk.h",
        includedLibraryLinks: ["gdk-4", "gsk-4"]
    )
    let scaffolding = CodeGenerator.generatePackageScaffolding(config: config, repository: repo)

    let headerName = "Sources/CGtk/CGtk.h"
    #expect(scaffolding.keys.contains(headerName))
    #expect(scaffolding[headerName]?.contains("#include <gtk/gtk.h>") == true)
}

@Test("generatePackageScaffolding works for GLib")
func testPackageScaffoldingGLib() {
    let config = GenerationConfig(library: "GLib", version: "2.0", girsDirectories: [],
        targetDirectory: "", externalLibraries: [],
        generate: ["GLib.String"], manual: [], ignore: [], objects: [])
    let repo = Repository(
        namespaces: [
            Namespace(name: "GLib", version: "2.0", cSharedLibrary: "libglib-2.0.so.0", cIdentifierPrefix: "G")
        ],
        cHeaderPath: "glib.h"
    )
    let scaffolding = CodeGenerator.generatePackageScaffolding(config: config, repository: repo)

    #expect(scaffolding["Package.swift"]?.contains("name: \"GLib\"") == true)
    #expect(scaffolding["Package.swift"]?.contains("pkgConfig: \"glib-2.0\"") == true)
    #expect(scaffolding["Sources/CGLib/module.modulemap"]?.contains("link \"glib-2.0\"") == true)
    #expect(scaffolding["Sources/CGLib/CGLib.h"]?.contains("#include <glib.h>") == true)
}

@Test("generatePackageScaffolding works for Adw")
func testPackageScaffoldingAdw() {
    let config = GenerationConfig(library: "Adw", version: "1", girsDirectories: [],
        targetDirectory: "", externalLibraries: [],
        generate: ["Adw.Window"], manual: [], ignore: [], objects: [])
    let repo = Repository(
        namespaces: [
            Namespace(name: "Adw", version: "1", cSharedLibrary: "libadwaita-1.so.0", cIdentifierPrefix: "Adw")
        ],
        cHeaderPath: "adwaita.h",
        includedLibraryLinks: ["gio-2", "gtk-4"]
    )
    let scaffolding = CodeGenerator.generatePackageScaffolding(config: config, repository: repo)

    #expect(scaffolding["Package.swift"]?.contains("pkgConfig: \"adwaita-1\"") == true)
    #expect(scaffolding["Sources/CAdw/module.modulemap"]?.contains("link \"adwaita-1\"") == true)
    #expect(scaffolding["Sources/CAdw/CAdw.h"]?.contains("#include <adwaita.h>") == true)
}

// MARK: - User target preservation

@Test("generateMonorepoScaffolding includes user targets marker block")
func testMonorepoPackageHasUserTargetMarkers() {
    // Build minimal MultiPackageAnalysis with one module
    let repo = Repository(
        namespaces: [Namespace(name: "Gtk", version: "4.0",
            cSharedLibrary: "libgtk-4.so.1", cIdentifierPrefix: "Gtk")]
    )
    let analysis = MultiPackageAnalysis(
        repositories: ["Gtk": repo],
        directDependencies: ["Gtk": []],
        transitiveDependencies: ["Gtk": []],
        implicitImports: ["Gtk": []],
        packageConfigs: [:]
    )
    let scaffolding = CodeGenerator.generateMonorepoScaffolding(analysis: analysis)
    let pkg = scaffolding["Package.swift"] ?? ""
    #expect(pkg.contains("// BEGIN_USER_TARGETS"))
    #expect(pkg.contains("// END_USER_TARGETS"))
}

@Test("preserveUserTargets splices user block from existing into generated")
func testPreserveUserTargets() {
    let existing = """
    targets: [
        .systemLibrary(name: "CGLib"),
        // BEGIN_USER_TARGETS
        .testTarget(name: "MyTests", dependencies: ["GLib"]),
        // END_USER_TARGETS
    ]
    """

    let generated = """
    targets: [
        .systemLibrary(name: "CGLib"),
        // BEGIN_USER_TARGETS

        // END_USER_TARGETS
    ]
    """
    let result = CodeGenerator.preserveUserTargets(generated: generated, existing: existing)
    #expect(result.contains("MyTests"))
    #expect(result != generated, "Result should differ from generated since existing has content")
    #expect(result.contains("// BEGIN_USER_TARGETS"))
    #expect(result.contains("// END_USER_TARGETS"))
    #expect(result.contains(".testTarget(name:"))
}

@Test("preserveUserTargets returns generated unchanged when existing has no markers")
func testPreserveUserTargetsFirstGeneration() {
    let generated = """
    targets: [
        .systemLibrary(name: "CGLib"),
        // BEGIN_USER_TARGETS

        // END_USER_TARGETS
    ]
    """

    let result = CodeGenerator.preserveUserTargets(generated: generated, existing: "")
    #expect(result == generated)
}