import java.io.OutputStream
import java.util.zip.ZipFile

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.apache.xmlgraphics:batik-transcoder:1.17")
        classpath("org.apache.xmlgraphics:batik-codec:1.17")
    }
}

plugins {
    alias(libs.plugins.fabric.loom)
    `maven-publish`
}

base {
    archivesName = properties["archives_base_name"] as String
    version = libs.versions.mod.version.get()
    group = properties["maven_group"] as String
}

repositories {
    maven {
        name = "meteor-maven"
        url = uri("https://maven.meteordev.org/releases")
    }
    mavenCentral()
}

dependencies {

    minecraft(libs.minecraft)
    implementation(libs.fabric.loader)
    implementation(libs.fabric.api)

    implementation("net.java.dev.jna:jna:5.13.0")
    implementation("net.java.dev.jna:jna-platform:5.13.0")
    implementation("io.netty:netty-handler-proxy:4.1.118.Final")
    implementation("io.netty:netty-codec-socks:4.1.118.Final")
    include("io.netty:netty-handler-proxy:4.1.118.Final")
    include("io.netty:netty-codec-socks:4.1.118.Final")
    implementation("de.florianreuth:waybackauthlib:1.1.0")
    include("de.florianreuth:waybackauthlib:1.1.0")
    implementation("com.github.weisj:jsvg:2.1.0")
    include("com.github.weisj:jsvg:2.1.0")

    // Bundle a newer MixinExtras (jar-in-jar) so Fabric Loader loads it over the old 0.5.0 it ships
    // with. Required because ViaFabricPlus (and our own WrapOperation/ModifyExpressionValue mixins)
    // need MixinExtras >= 0.5.3; without this, joining a server crashes during mixin application.
    implementation("io.github.llamalad7:mixinextras-fabric:0.5.4")
    include("io.github.llamalad7:mixinextras-fabric:0.5.4")

}

val generatedAutismResourcesDir = layout.buildDirectory.dir("generated/resources/autism/main")

data class SourceFile(val path: String, val text: String)
data class FieldSpec(val name: String, val type: String, val kind: String, val editable: Boolean)
data class PacketSpec(
    val className: String,
    val protocol: String,
    val direction: String,
    val codecStyle: String,
    val packetType: String,
    val source: String,
    val complete: Boolean,
    val fields: List<FieldSpec>
)

sourceSets {
    main {
        resources.srcDir(generatedAutismResourcesDir)
    }
}

val generateVanillaUiAssets by tasks.registering {
    // Semantic feature icons used by the vanilla-friendly UI. Structural
    // actions such as close and reorder are rendered as text symbols.
    val iconSourceDir = file("assets/icons")
    val outputDir = generatedAutismResourcesDir.map { it.dir("assets/autismclient") }

    inputs.dir(iconSourceDir)
    outputs.dir(outputDir)

    doLast {
        val targetRoot = outputDir.get().asFile
        targetRoot.parentFile.resolve("yu" + "ng" + "light").deleteRecursively()
        targetRoot.deleteRecursively()
        val iconTargetDir = targetRoot.resolve("textures/gui/vanillaui/icons")

        iconTargetDir.mkdirs()

        val pngTranscoderClass = Class.forName("org.apache.batik.transcoder.image.PNGTranscoder")
        val transcoderInputClass = Class.forName("org.apache.batik.transcoder.TranscoderInput")
        val transcoderOutputClass = Class.forName("org.apache.batik.transcoder.TranscoderOutput")
        val transcodingHintsKeyClass = Class.forName("org.apache.batik.transcoder.TranscodingHints\$Key")

        val transcoder = pngTranscoderClass.getDeclaredConstructor().newInstance()
        val widthField = pngTranscoderClass.getField("KEY_WIDTH")
        val heightField = pngTranscoderClass.getField("KEY_HEIGHT")
        val addHint = pngTranscoderClass.getMethod("addTranscodingHint", transcodingHintsKeyClass, Any::class.java)
        addHint.invoke(transcoder, widthField.get(null), 256f)
        addHint.invoke(transcoder, heightField.get(null), 256f)

        val inputCtor = transcoderInputClass.getConstructor(String::class.java)
        val outputCtor = transcoderOutputClass.getConstructor(OutputStream::class.java)
        val transcode = pngTranscoderClass.getMethod("transcode", transcoderInputClass, transcoderOutputClass)

        iconSourceDir.listFiles { file -> file.isFile && file.extension.equals("svg", ignoreCase = true) }
            ?.sortedBy { it.name.lowercase() }
            ?.forEach { svg ->
                val outputFile = iconTargetDir.resolve(svg.nameWithoutExtension.lowercase() + ".png")
                outputFile.outputStream().use { out ->
                    val input = inputCtor.newInstance(svg.toURI().toString())
                    val output = outputCtor.newInstance(out)
                    transcode.invoke(transcoder, input, output)
                }
            }
    }
}

val generateAutismInspectorMappings by tasks.registering {
    val mappingFiles = fileTree(".gradle/loom-cache/source_mappings") {
        include("**/*.tiny")
    }
    val outputFile = generatedAutismResourcesDir.map { it.file("autism-inspector-mappings.tsv") }

    inputs.files(mappingFiles)
    outputs.file(outputFile)

    doLast {
        run {
            val target = outputFile.get().asFile
            target.parentFile.mkdirs()
            target.writeText(
                "# Official Mojang mappings are used for Minecraft 26.1.2; no Yarn aliases are generated.\n",
                Charsets.UTF_8
            )
            return@doLast
        }

        val tinyFile = mappingFiles.files
            .filter { it.isFile }
            .maxByOrNull { it.lastModified() }
            ?: error("Missing Loom source mappings under ${project.file(".gradle/loom-cache/source_mappings").absolutePath}")

        val lines = tinyFile.readLines(Charsets.UTF_8)
        val header = lines.firstOrNull { it.startsWith("tiny\t") }
            ?: error("Invalid tiny mapping file: ${tinyFile.absolutePath}")
        val namespaces = header.split('\t').drop(3)
        val namedIndex = namespaces.indexOf("named")
        val intermediaryIndex = namespaces.indexOf("intermediary")
        require(namedIndex >= 0 && intermediaryIndex >= 0) {
            "Tiny mapping header must expose named and intermediary namespaces: $header"
        }

        fun readNamespace(parts: List<String>, baseOffset: Int, namespaceIndex: Int): String {
            val index = baseOffset + namespaceIndex
            return if (index in parts.indices) parts[index].trim() else ""
        }

        val namedToIntermediary = linkedMapOf<String, String>()
        val classAliases = linkedMapOf<String, String>()

        for (raw in lines) {
            val trimmed = raw.trimStart('\t')
            if (!trimmed.startsWith("c\t")) continue
            val parts = trimmed.split('\t')
            val namedName = readNamespace(parts, 1, namedIndex)
            val intermediaryName = readNamespace(parts, 1, intermediaryIndex)
            if (namedName.isBlank() || intermediaryName.isBlank()) continue
            namedToIntermediary[namedName] = intermediaryName
            classAliases[intermediaryName.replace('/', '.')] = namedName.substringAfterLast('/').replace('$', '.')
        }

        fun remapDescriptorToIntermediary(descriptor: String): String {
            if (descriptor.isBlank()) return descriptor
            val classRef = Regex("L([^;]+);")
            return classRef.replace(descriptor) { match ->
                val namedInternalName = match.groupValues[1]
                val intermediaryInternalName = namedToIntermediary[namedInternalName] ?: namedInternalName
                "L$intermediaryInternalName;"
            }
        }

        fun storeAlias(
            target: MutableMap<String, String>,
            ambiguous: MutableSet<String>,
            key: String,
            alias: String
        ) {
            if (key.isBlank() || alias.isBlank() || ambiguous.contains(key)) return
            val existing = target[key]
            if (existing == null) {
                target[key] = alias
                return
            }
            if (existing != alias) {
                target.remove(key)
                ambiguous.add(key)
            }
        }

        val fieldAliases = linkedMapOf<String, String>()
        val methodAliases = linkedMapOf<String, String>()
        val ambiguousFieldKeys = linkedSetOf<String>()
        val ambiguousMethodKeys = linkedSetOf<String>()

        var currentOwner = ""
        for (raw in lines) {
            val trimmed = raw.trimStart('\t')
            if (trimmed.isBlank()) continue
            val parts = trimmed.split('\t')
            when (parts.firstOrNull()) {
                "c" -> {
                    currentOwner = readNamespace(parts, 1, intermediaryIndex).replace('/', '.')
                }

                "f" -> {
                    if (currentOwner.isBlank()) continue
                    val descriptor = if (parts.size > 1) remapDescriptorToIntermediary(parts[1]) else ""
                    val namedName = readNamespace(parts, 2, namedIndex)
                    val intermediaryName = readNamespace(parts, 2, intermediaryIndex)
                    if (namedName.isBlank() || intermediaryName.isBlank()) continue
                    storeAlias(fieldAliases, ambiguousFieldKeys, "$currentOwner#$intermediaryName#$descriptor", namedName)
                }

                "m" -> {
                    if (currentOwner.isBlank()) continue
                    val descriptor = if (parts.size > 1) remapDescriptorToIntermediary(parts[1]) else ""
                    val namedName = readNamespace(parts, 2, namedIndex)
                    val intermediaryName = readNamespace(parts, 2, intermediaryIndex)
                    if (namedName.isBlank() || intermediaryName.isBlank()) continue
                    if (namedName == "<init>" || namedName == "<clinit>") continue
                    storeAlias(methodAliases, ambiguousMethodKeys, "$currentOwner#$intermediaryName#$descriptor", namedName)
                }
            }
        }

        val authAliasFragments = listOf(
            "session", "accesstoken", "refreshtoken", "authtoken",
            "clientsession", "playersession", "publicsession"
        )
        fun isAuthAlias(alias: String): Boolean {
            val normalized = alias.lowercase().replace(Regex("[^a-z0-9]"), "")
            return authAliasFragments.any { normalized.contains(it) }
        }

        val filteredClassAliases = classAliases.filter { (_, alias) -> !isAuthAlias(alias) }
        val blockedOwners = classAliases.keys.filter { owner ->
            val alias = classAliases[owner] ?: return@filter false
            isAuthAlias(alias)
        }.toSet()

        val target = outputFile.get().asFile
        target.parentFile.mkdirs()
        target.printWriter(Charsets.UTF_8).use { out ->
            out.println("# Yarn deobfuscation mappings")
            filteredClassAliases.toSortedMap().forEach { (owner, alias) ->
                out.println("C\t$owner\t$alias")
            }
            fieldAliases.toSortedMap().forEach { (key, alias) ->
                val parts = key.split('#', limit = 3)
                if (parts.size == 3 && !blockedOwners.contains(parts[0]) && !isAuthAlias(alias)) {
                    out.println("F\t${parts[0]}\t${parts[1]}\t${parts[2]}\t$alias")
                }
            }
            methodAliases.toSortedMap().forEach { (key, alias) ->
                val parts = key.split('#', limit = 3)
                if (parts.size == 3 && !blockedOwners.contains(parts[0]) && !isAuthAlias(alias)) {
                    out.println("M\t${parts[0]}\t${parts[1]}\t${parts[2]}\t$alias")
                }
            }
        }
    }
}

val generateAutismPacketSchemas by tasks.registering {
    val minecraftVersion = libs.versions.minecraft.get()
    val outputFile = generatedAutismResourcesDir.map { it.file("autism-packet-schemas.tsv") }

    outputs.file(outputFile)

    doLast {
        fun normalizeWhitespace(value: String): String = value.replace(Regex("\\s+"), " ").trim()

        fun splitTopLevelComma(value: String): List<String> {
            val out = mutableListOf<String>()
            var depth = 0
            var start = 0
            for (i in value.indices) {
                when (value[i]) {
                    '<', '(', '[', '{' -> depth++
                    '>', ')', ']', '}' -> if (depth > 0) depth--
                    ',' -> if (depth == 0) {
                        out += value.substring(start, i).trim()
                        start = i + 1
                    }
                }
            }
            val tail = value.substring(start).trim()
            if (tail.isNotBlank()) out += tail
            return out
        }

        fun protocolFromPath(path: String): String {
            val normalized = path.replace('\\', '/')
            val marker = "/network/protocol/"
            val idx = normalized.indexOf(marker)
            val tail = if (idx >= 0) normalized.substring(idx + marker.length) else normalized.substringAfter("net/minecraft/network/protocol/", "")
            return tail.substringBefore('/').ifBlank { "unknown" }
        }

        fun directionFromName(simpleName: String): String = when {
            simpleName.startsWith("Clientbound") -> "S2C"
            simpleName.startsWith("Serverbound") -> "C2S"
            else -> "ANY"
        }

        fun kindForType(type: String): String {
            val lower = type.lowercase()
            return when {
                lower == "byte" || lower == "short" || lower == "int" || lower == "long" || lower == "float" || lower == "double" -> "number"
                lower == "boolean" -> "boolean"
                lower == "string" -> "string"
                lower.contains("itemstack") || lower.contains("hashedstack") -> "item"
                lower.contains("component") -> "component"
                lower.contains("identifier") || lower.contains("resourcekey") -> "identifier"
                lower.contains("holder<") || lower == "holder" -> "holder"
                lower.contains("blockpos") || lower.contains("chunkpos") -> "position"
                lower.contains("vec3") || lower.contains("positionmoverotation") -> "vector"
                lower.contains("uuid") -> "uuid"
                lower.startsWith("optional<") || lower.contains(".optional<") -> "optional"
                lower.startsWith("list<") || lower.startsWith("set<") || lower.contains("list<") || lower.contains("set<") -> "list"
                lower.startsWith("map<") || lower.contains("map<") || lower.contains("int2objectmap") -> "map"
                lower.contains("bitset") -> "bitset"
                lower.contains("enumset") || lower.contains("relative") || lower.contains("containerinput") -> "enum"
                else -> "object"
            }
        }

        fun editableFor(kind: String): Boolean = kind in setOf("number", "boolean", "string", "identifier", "enum", "uuid")

        fun parseComponent(raw: String): FieldSpec? {
            val cleaned = normalizeWhitespace(raw)
                .replace(Regex("^@[\\w.]+(?:\\([^)]*\\))?\\s+"), "")
            val idx = cleaned.lastIndexOf(' ')
            if (idx <= 0 || idx >= cleaned.length - 1) return null
            val type = cleaned.substring(0, idx).trim()
            val name = cleaned.substring(idx + 1).trim().removeSuffix("...")
            if (!name.matches(Regex("[A-Za-z_$][A-Za-z0-9_$]*"))) return null
            val kind = kindForType(type)
            return FieldSpec(name, type, kind, editableFor(kind))
        }

        fun parseFields(text: String): Pair<String, List<FieldSpec>> {
            val record = Regex("""public\s+record\s+\w+\s*\((.*?)\)\s*implements""", setOf(RegexOption.DOT_MATCHES_ALL))
                .find(text)
            if (record != null) {
                val fields = splitTopLevelComma(record.groupValues[1]).mapNotNull(::parseComponent)
                return "record" to fields
            }

            val fields = Regex("""(?m)^\s*(?:private|protected)\s+final\s+([^;=]+?)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*;""")
                .findAll(text)
                .mapNotNull { match ->
                    val type = normalizeWhitespace(match.groupValues[1])
                    val name = match.groupValues[2]
                    val kind = kindForType(type)
                    FieldSpec(name, type, kind, editableFor(kind))
                }
                .toList()
            return if (fields.isNotEmpty()) "fields" to fields else "fallback" to emptyList()
        }

        fun loadSources(): List<SourceFile> {
            val sourcesJar = file("${System.getProperty("user.home")}/.gradle/caches/fabric-loom/minecraftMaven/net/minecraft/minecraft-merged-deobf/$minecraftVersion/minecraft-merged-deobf-$minecraftVersion-sources.jar")
            if (sourcesJar.isFile) {
                ZipFile(sourcesJar).use { zip ->
                    return zip.entries().asSequence()
                        .filter { !it.isDirectory }
                        .filter { it.name.startsWith("net/minecraft/network/protocol/") && it.name.endsWith("Packet.java") }
                        .map { entry ->
                            SourceFile(entry.name, zip.getInputStream(entry).bufferedReader(Charsets.UTF_8).use { it.readText() })
                        }
                        .toList()
                }
            }

            val localRoot = file("mc-src$minecraftVersion/libs/net.minecraft.minecraft-merged-deobf/net/minecraft/network/protocol")
            if (localRoot.isDirectory) {
                return localRoot.walkTopDown()
                    .filter { it.isFile && it.name.endsWith("Packet.java") }
                    .map { file ->
                        SourceFile(file.relativeTo(localRoot.parentFile.parentFile.parentFile.parentFile).invariantSeparatorsPath, file.readText(Charsets.UTF_8))
                    }
                    .toList()
            }

            error("Missing Minecraft deobf sources jar and local mc-src fallback for $minecraftVersion")
        }

        fun packetTypeOf(text: String): String {
            return Regex("""return\s+([A-Za-z0-9_]+PacketTypes\.[A-Z0-9_]+)\s*;""")
                .find(text)
                ?.groupValues
                ?.get(1)
                ?: ""
        }

        fun codecStyleOf(text: String): String = when {
            text.contains("StreamCodec.unit") -> "UNIT"
            text.contains("StreamCodec.composite") -> "COMPOSITE"
            text.contains("Packet.codec") -> "PACKET_CODEC"
            else -> "CUSTOM"
        }

        fun escape(value: String): String = value
            .replace('\t', ' ')
            .replace('\n', ' ')
            .replace('|', '/')
            .replace('~', '-')

        val specs = loadSources().mapNotNull { source ->
            val pkg = Regex("""package\s+([A-Za-z0-9_.]+)\s*;""").find(source.text)?.groupValues?.get(1) ?: return@mapNotNull null
            val simpleName = Regex("""public\s+(?:abstract\s+)?(?:record|class)\s+([A-Za-z0-9_]+Packet)\b""")
                .find(source.text)
                ?.groupValues
                ?.get(1)
                ?: return@mapNotNull null
            val codecStyle = codecStyleOf(source.text)
            val parsed = parseFields(source.text)
            val sourceKind = if (codecStyle == "UNIT") "unit" else parsed.first
            val complete = codecStyle == "UNIT" || parsed.second.isNotEmpty()
            PacketSpec(
                "$pkg.$simpleName",
                protocolFromPath(source.path),
                directionFromName(simpleName),
                codecStyle,
                packetTypeOf(source.text),
                sourceKind,
                complete,
                if (codecStyle == "UNIT") emptyList() else parsed.second
            )
        }.sortedBy { it.className }

        val target = outputFile.get().asFile
        target.parentFile.mkdirs()
        target.printWriter(Charsets.UTF_8).use { out ->
            out.println("# Generated from Minecraft $minecraftVersion packet sources. Fields preserve source/record order where available.")
            out.println("# class\tprotocol\tdirection\tcodec\tpacketType\tsource\tcomplete\tfields(name~type~kind~editable|...)")
            for (spec in specs) {
                val fields = spec.fields.joinToString("|") { field ->
                    listOf(field.name, field.type, field.kind, field.editable.toString()).joinToString("~", transform = ::escape)
                }
                val columns = listOf(
                    spec.className,
                    spec.protocol,
                    spec.direction,
                    spec.codecStyle,
                    spec.packetType,
                    spec.source,
                    spec.complete.toString()
                ).joinToString("\t", transform = ::escape)
                out.println("$columns\t$fields")
            }
        }
    }
}

tasks {
    processResources {
        dependsOn(generateAutismInspectorMappings)
        dependsOn(generateAutismPacketSchemas)
        dependsOn(generateVanillaUiAssets)
        val propertyMap = mapOf(
            "version" to project.version,
            "mc_version" to libs.versions.minecraft.get()
        )

        inputs.properties(propertyMap)

        filteringCharset = "UTF-8"

        exclude("addon-template.mixins.json")
        exclude("assets/template/**")

        filesMatching("fabric.mod.json") {
            expand(propertyMap)
        }
    }

    jar {
        inputs.property("archivesName", project.base.archivesName.get())

        from("LICENSE") {
            rename { "${it}_${inputs.properties["archivesName"]}" }
        }

        // ModMenu API is a compile-only soft dependency: we ship local stubs of its two API
        // interfaces so we can compile the integration without a cross-version ModMenu artifact, but
        // we must NOT bundle them — at runtime the real ModMenu provides them (and if ModMenu is
        // absent, our integration entrypoint is simply never loaded).
        exclude("com/terraformersmc/**")
    }

    java {
        sourceCompatibility = JavaVersion.VERSION_25
        targetCompatibility = JavaVersion.VERSION_25
        toolchain {
            languageVersion.set(JavaLanguageVersion.of(25))
        }
    }

    withType<JavaCompile> {
        options.encoding = "UTF-8"
        options.release.set(25)
        options.compilerArgs.add("-Xlint:deprecation")
        options.compilerArgs.add("-Xlint:unchecked")
        options.compilerArgs.add("-Xlint:-restricted")
    }
}

// Publish the Loom-remapped jar to the local Maven repo so the standalone addon-template (and any
// third-party addon) can depend on it via `modImplementation("com.autismclient:autism:<version>")`.
// Run: ./gradlew publishToMavenLocal
publishing {
    publications {
        create<MavenPublication>("mavenJava") {
            groupId = "com.autismclient"
            artifactId = "autism"
            version = project.version.toString()
            from(components["java"])
        }
    }
    repositories {
        mavenLocal()
    }
}