package io.gitlab.jfronny.lom.ext

import org.gradle.api.Action
import org.gradle.api.DefaultTask
import org.gradle.api.PolymorphicDomainObjectContainer
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.plugins.JavaPluginExtension
import org.gradle.api.publish.PublishingExtension
import org.gradle.api.tasks.SourceSetContainer
import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.bundling.Jar
import org.gradle.kotlin.dsl.named
import org.gradle.kotlin.dsl.support.delegates.ProjectDelegate
import org.gradle.language.jvm.tasks.ProcessResources
import kotlin.reflect.KClass
import kotlin.reflect.KProperty

val Project.java: JavaPluginExtension get() = extensions.getByName("java") as JavaPluginExtension
fun Project.java(configure: Action<JavaPluginExtension>) = extensions.configure("java", configure)
val Project.publishing: PublishingExtension get() = extensions.getByName("publishing") as PublishingExtension
fun Project.publishing(configure: Action<PublishingExtension>) = extensions.configure("publishing", configure)

val Project.sourceSets: SourceSetContainer get() = extensions.getByName("sourceSets") as SourceSetContainer
fun Project.sourceSets(configure: Action<SourceSetContainer>) = extensions.configure("sourceSets", configure)

val TaskContainer.assemble: DefaultTask get() = named<DefaultTask>("assemble").get()
val TaskContainer.build: DefaultTask get() = named<DefaultTask>("build").get()
val TaskContainer.jar: Jar get() = named<Jar>("jar").get()
val TaskContainer.sourcesJar: Jar get() = named<Jar>("sourcesJar").get()
val TaskContainer.publish: Task get() = named("publish").get()
fun TaskContainer.processResources(configure: ProcessResources.() -> Unit) = named<ProcessResources>("processResources").configure(configure)

fun <T : Any, C : PolymorphicDomainObjectContainer<T>, U : T> C.registering(type: KClass<U>, action: U.() -> Unit): PDelegate<T, C, U> = PDelegate(this, type.java, action)

class PDelegate<T : Any, C : PolymorphicDomainObjectContainer<T>, U : T>(private val container: C, private val type: Class<U>, private val action: U.() -> Unit) {
    operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): SDelegate<U> = SDelegate(container.register(property.name, type, action).get())
}

class SDelegate<T>(private val delegate: T) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): T = delegate
}

fun Project.prop(name: String, default: String? = null): String {
    return if (default == null || hasProperty(name)) property(name).toString()
    else default
}