package plugin

/*
#cgo linux LDFLAGS: -ldl
#include <dlfcn.h>
#include <limits.h>
#include <stdlib.h>
#include <stdint.h>

#include <stdio.h>

static uintptr_t pluginOpen(const char* path, char** err) {
	void* h = dlopen(path, RTLD_NOW|RTLD_GLOBAL);
	if (h == NULL) {
		*err = (char*)dlerror();
	}
	return (uintptr_t)h;
}

    @Test
    fun `PluginTree#of`() {

        val flatPlugin = PluginTree.PluginSpec("flat-plugin", "FlatPlugin")
        val nestedPluginA = PluginTree.PluginSpec("nested.plugin-a", "NestedPluginA")
        val nestedPluginB = PluginTree.PluginSpec("nested.other.plugin-b", "NestedPluginB")
        val nestedPluginC = PluginTree.PluginSpec("nested.other.plugin-c", "NestedPluginC")
        assertThat(
            PluginTree.of(

internal
sealed class PluginTree {

    data class PluginGroup(val path: List<String>, val plugins: Map<String, PluginTree>) : PluginTree()

    data class PluginSpec(val id: String, val implementationClass: String) : PluginTree()

    companion object {

        fun of(plugins: Sequence<PluginSpec>): Map<String, PluginTree> {
            val root = linkedMapOf<String, PluginTree>()
            plugins.sortedBy { it.id }.forEach { plugin ->

                linkedMapOf(
                    "my-plugin" to PluginTree.PluginSpec(
                        "my-plugin", "my.Plugin"
                    ),
                    "my" to PluginTree.PluginGroup(
                        listOf("my"),
                        linkedMapOf(
                            "plugin-a" to PluginTree.PluginSpec("my.plugin-a", "my.PluginA")
                        )
                    )

    void hasPlugin(String alias, @DelegatesTo(strategy = Closure.DELEGATE_FIRST, value = PluginSpec) Closure<Void> spec) {
        assert model.hasPlugin(alias)
        def plugin = model.getPlugin(alias)
        assert plugin != null : "Expected a plugin with alias '$alias' but it wasn't found"
        def pluginSpec = new PluginSpec(plugin)
        spec.delegate = pluginSpec
        spec.resolveStrategy = Closure.DELEGATE_FIRST
        spec()
    }

                )
            }
        }

        val pluginSpec by debug {
            pluginIdSpec + kotlinDslSpec
        }

        val firstLines by debug {
            zeroOrMore(pluginSpec * statementSeparator())
        }

        val lastLine by debug {
            optional(pluginSpec * wsOrNewLine())
        }

        token(LBRACE) * wsOrNewLine() *

                        }
                    }
                }
            """
            file("src/test/groovy/PluginSpec.groovy") << """
                import spock.lang.Specification

                class PluginSpec extends Specification {
                    def "dummy test"() {
                        expect:
                        true
                    }
                }

private
fun pluginSpecsFrom(pluginDescriptorsClassPath: ClassPath): Sequence<PluginTree.PluginSpec> =
    pluginDescriptorsClassPath
        .asFiles
        .asSequence()
        .filter { it.isFile && it.extension.equals("jar", true) }
        .flatMap { pluginEntriesFrom(it).asSequence() }
        .map { PluginTree.PluginSpec(it.pluginId, it.implementationClass) }


private

            String versionCatalogRef = buildContentGenerationContext.getVersionCatalogDependencyRegistry().registerPlugin(pluginId, version);
            plugin = new PluginSpec(versionCatalogRef, comment);
        } else {
            plugin = new PluginSpec(pluginId, version, comment);
        }
        block.plugins.add(plugin);
        return this;
    }

    /**