#!/usr/bin/env kotlin

@file:DependsOn("io.swagger.parser.v3:swagger-parser:2.1.39")

import io.swagger.v3.core.util.Yaml
import io.swagger.v3.oas.models.OpenAPI
import io.swagger.v3.oas.models.Paths
import io.swagger.v3.oas.models.media.Schema
import io.swagger.v3.parser.OpenAPIV3Parser
import io.swagger.v3.parser.core.models.ParseOptions
import io.swagger.v3.parser.core.models.SwaggerParseResult
import java.io.File

// ================= CONFIG =================

val inputFile = "./raw-fft-api.yaml"
val outputFile = "./stripped-fft-api.yaml"

// Only keep these paths (empty = keep all)
val pathsToKeep =
    setOf(
        "/api/inboundprocesses/{inboundProcessId}",
        "/api/inboundprocesses/{inboundProcessId}/purchaseorder",
    )

// ===========================================

println("Parsing OpenAPI file: $inputFile")

val options =
    ParseOptions().apply {
        isResolve = true
        isResolveFully = false
        isFlatten = true
    }

val result: SwaggerParseResult = OpenAPIV3Parser().readLocation(inputFile, null, options)

if (result.messages.isNotEmpty()) {
    println("Parser messages:")
    result.messages.forEach { println(" - $it") }
}

var openAPI: OpenAPI = result.openAPI ?: error("Failed to parse OpenAPI spec")

println("Applying OpenAPI Generator normalization...")

// ================= PATH FILTERING =================
if (pathsToKeep.isNotEmpty()) {
    println("Filtering paths...")

    val newPaths = Paths()

    openAPI.paths
        ?.filterKeys { it in pathsToKeep }
        ?.forEach { (path, item) ->
            newPaths.addPathItem(path, item)
        }

    openAPI.paths = newPaths
}

// ================= COLLECT USED SCHEMAS =================

val usedSchemas = mutableSetOf<String>()

fun collectSchema(schema: Schema<*>?) {
    if (schema == null) return

    // Handle $ref
    schema.`$ref`?.let {
        val name = it.substringAfterLast("/")
        if (usedSchemas.add(name)) {
            val refSchema = openAPI.components?.schemas?.get(name)
            collectSchema(refSchema)
        }
        return
    }

    // Properties
    schema.properties?.values?.forEach {
        collectSchema(it as Schema<*>)
    }

    // Array items
    schema.items?.let {
        collectSchema(it)
    }

    // Composed schemas
    schema.allOf?.forEach { collectSchema(it as Schema<*>) }
    schema.oneOf?.forEach { collectSchema(it as Schema<*>) }
    schema.anyOf?.forEach { collectSchema(it as Schema<*>) }

    when (val additional = schema.additionalProperties) {
        is Schema<*> -> collectSchema(additional)
    }

    // Not required but safe: map value schemas
    schema.not?.let { collectSchema(it) }

    schema.discriminator?.mapping?.values?.forEach { ref ->
        val name = ref.substringAfterLast("/")
        if (usedSchemas.add(name)) {
            collectSchema(openAPI.components?.schemas?.get(name))
        }
    }
}

// Traverse paths
openAPI.paths?.values?.forEach { pathItem ->
    pathItem.readOperations().forEach { op ->
        op.requestBody?.content?.values?.forEach {
            collectSchema(it.schema)
        }
        op.responses?.values?.forEach { response ->
            response.content?.values?.forEach {
                collectSchema(it.schema)
            }
        }
        op.parameters?.forEach { param ->
            collectSchema((param)?.schema)
        }
    }
}

println("Used schemas: ${usedSchemas.size}")

// ================= REMOVE UNUSED SCHEMAS =================

val schemas = openAPI.components?.schemas ?: emptyMap()

val pruned = schemas.filterKeys { it in usedSchemas }

openAPI.components.schemas = pruned.toMutableMap()

println("Pruned schemas from ${schemas.size} to ${pruned.size}")

// Remove redundant components due to allOf flattening and anyOf simplification
openAPI.components?.schemas?.values?.forEach { schema ->

    // Remove duplicate discriminator property
    schema.allOf?.forEach { part ->
        if (part is Schema<*>) {
            val props = part.properties
            if (props != null && props.containsKey("action")) {
                props.remove("action")
            }
        }
    }

    // Remove useless anyOf (only required constraints)
    val anyOf = schema.anyOf
    if (anyOf != null) {
        val onlyRequiredConstraints =
            anyOf.all { sub ->
                sub is Schema<*> &&
                    sub.required != null &&
                    sub.properties == null
            }

        if (onlyRequiredConstraints) {
            schema.anyOf = null
        }
    }
}

// ================= WRITE OUTPUT =================

val yaml: String = Yaml.pretty(openAPI)
File(outputFile).writeText(yaml)

println("Cleaned OpenAPI written to $outputFile")
println("Done.")

import org.openapitools.generator.gradle.plugin.tasks.GenerateTask

plugins {
    // Apply the org.jetbrains.kotlin.jvm Plugin to add support for Kotlin.
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.openapi)

    // Apply the application plugin to add support for building a CLI application in Java.
    application
}

repositories {
    // Use Maven Central for resolving dependencies.
    mavenCentral()
}

dependencies {
    // This dependency is used by the application.
    implementation(libs.dotenv)
    implementation(libs.jackson)
    implementation(libs.jackson.jsr310)
    implementation(libs.jakarta.annotation)
}

// Apply a specific Java toolchain to ease working on different environments.
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(25)
    }
}

application {
    // Define the main class for the application.
    mainClass = "dev.simonscholz.AppKt"
}

configureOpenApiClient(
    taskName = "generateFftApiClient",
    spec = "$rootDir/stripped-fft-api.yaml",
    basePackage = "dev.simonscholz.api.client.fft",
)

fun configureOpenApiClient(
    taskName: String,
    spec: String,
    basePackage: String,
) {
    tasks.register(taskName, GenerateTask::class.java) {
        generatorName.set("java")

        inputSpec.set(spec)
        outputDir.set("${layout.buildDirectory.get()}/generated")

        packageName.set(basePackage)
        apiPackage.set("$basePackage.api")
        modelPackage.set("$basePackage.model")
        modelNameSuffix.set("DTO")
        invokerPackage.set("$basePackage.invoker")

        // Use Java 11 HttpClient
        library.set("native")

        generateModelTests.set(false)
        generateApiTests.set(false)

        configOptions.set(
            mapOf(
                "library" to "native",
                "enumPropertyNaming" to "MACRO_CASE",
                "dateLibrary" to "java8",
                "openApiNullable" to "false",
                "useJakartaEe" to "true",
                "serializationLibrary" to "jackson",
                "hideGenerationTimestamp" to "true",
            ),
        )

        globalProperties.set(
            mapOf(
                "models" to "", // generate DTOs
                "apis" to "", // generate API interfaces
                "supportingFiles" to "",
            ),
        )

        generateModelTests.set(false)
        generateApiTests.set(false)
        generateModelDocumentation.set(false)
        generateApiDocumentation.set(false)
    }
}

sourceSets {
    main {
        java {
            srcDir("${layout.buildDirectory.get()}/generated/src/main/java")
        }
    }
}

package dev.simonscholz

import dev.simonscholz.api.client.fft.api.InboundInventoryApi
import dev.simonscholz.api.client.fft.invoker.ApiClient
import dev.simonscholz.api.client.fft.model.InboundProcessPurchaseOrderForUpsertDTO
import io.github.cdimascio.dotenv.dotenv

fun main() {
    val dotenv = dotenv()

    val baseUri = dotenv["baseUri"]
    val bearerToken = dotenv["bearerToken"]
    val inboundProcessId = "019d728c-7bf4-74ed-998a-54ca02999463"
    val newQty = 15

    val authorizationHeader =
        mapOf(
            "Authorization" to "Bearer $bearerToken",
        )

    val apiClient = ApiClient()
    apiClient.updateBaseUri(baseUri)
    val api = InboundInventoryApi(apiClient)
    val inboundProcess = api.getInboundProcess(inboundProcessId, authorizationHeader)

    val purchaseOrder =
        requireNotNull(inboundProcess.purchaseOrder) {
            "Purchase order must not be null for inbound process with id $inboundProcessId"
        }

    val requestedItems =
        purchaseOrder.requestedItems.map {
            println("Current quantity for item ${it.tenantArticleId} is ${it.quantity.value} and will be updated to $newQty")
            val modifiedQty =
                it.quantity.apply {
                    value = newQty
                }
            it.quantity(modifiedQty)
        }

    val updateDTO =
        InboundProcessPurchaseOrderForUpsertDTO()
            .version(inboundProcess.version)
            .requestedItems(
                requestedItems,
            ).orderDate(purchaseOrder.orderDate)
            .requestedDate(purchaseOrder.requestedDate)

    val response =
        api.upsertInboundProcessPurchaseOrder(
            inboundProcessId,
            updateDTO,
            authorizationHeader,
        )

    println("Response from FFT:")
    println(response)
}