import java.lang.reflect.Modifier.isStatic
import java.lang.reflect.Modifier.isTransient
import kotlin.reflect.KClass


val unsupportedFieldDeclaredTypes = listOf(
    Configuration::class,
    SourceDirectorySet::class
)


internal
fun relevantStateOf(beanType: Class<*>): List<RelevantField> =
    when (IConventionAware::class.java.isAssignableFrom(beanType)) {
        true -> applyConventionMappingTo(beanType, relevantFieldsOf(beanType))

        is ConeDiagnosticWithSymbol<*> -> listOf(symbol)
        is ConeUnreportedDuplicateDiagnostic -> original.getCandidateSymbols()
        else -> emptyList()
    }

internal fun FirAnnotation.toKaAnnotation(
    builder: KaSymbolByFirBuilder,
    index: Int,
    argumentsFactory: (ClassId?) -> List<KaNamedAnnotationValue>
): KaAnnotation {

    }

    fun register(testServices: TestServices) {
        val project = testServices.environmentManager.getProject() as MockProject
        val extensionPoint = project.extensionArea.getExtensionPoint(EP_NAME)
        extensionPoint.registerExtension(this, project)
    }
}

class KaResolveExtensionForTest(
    private val files: List<KaResolveExtensionFile>,

            ktFile, testServices.moduleStructure.modules.first(),
            KtDeclaration::class
        ) as KtDeclaration
        val symbol = declaration.getSymbol()
        return SymbolsData(listOf(symbol))
    }

    val extraBuildScanTags: List<String> = if (isRetry) listOf("RetriedBuild") else emptyList()

    val buildScanTags = model.buildScanTags + listOfNotNull(stage?.id) + extraBuildScanTags
    val parameters = (
        buildToolGradleParameters(daemon, maxParallelForks = maxParallelForks) +
            listOf(extraParameters) +
            buildScanTags.map { buildScanTag(it) } +

        return when (fir) {
            is FirFunctionCall -> fir.getCandidateSymbols().map { it.fir.buildSymbol(firSymbolBuilder) }
            is FirResolvedNamedReference -> listOf(fir.resolvedSymbol.buildSymbol(firSymbolBuilder))
            else -> emptyList()
        }
    }

    override fun isReferenceToImportAlias(alias: KtImportAlias): Boolean {

        return listOf(symbolBuilder.buildSymbol(fir.symbol))
    }

    private fun getSymbolsByResolvedReifiedTypeParameterReference(
        symbolBuilder: KaSymbolByFirBuilder,
        fir: FirResolvedReifiedParameterReference,
    ): List<KaSymbol> {
        return listOf(symbolBuilder.buildSymbol(fir.symbol))
    }


    private fun getSymbolsByResolvedImport(

        override val checkKeys: Iterable<String> = listOf(checkKey)
    }

    override val checkKey: String
        get() = SettingsBlocksCheck::class.java.name

    enum class SpecialOrderBlock {
        PLUGIN_MANAGEMENT, PLUGINS
    }

    override fun detectFailures(document: DeclarativeDocument, resolutionContainer: DocumentResolutionContainer): List<DocumentCheckFailure> {

    fun expandToOverloads(produceDeclaration: (DataParameter) -> DependencyCollectorDeclaration) =
        listOf(gavDependencyParam, projectDependencyParam).map(produceDeclaration)

    override fun memberFunctions(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<SchemaMemberFunction> {
        val discoveredCollectorDeclarations: List<DependencyCollectorDeclaration> = kClass.memberFunctions

        assumeNotNull(currentJvm)

        val newerJvm = AvailableJavaHomes.getDifferentVersion { it.languageVersion > currentJvm.javaVersion }
        assumeNotNull(newerJvm)

        val installationPaths = listOf(currentJvm!!, newerJvm!!)
            .joinToString(",") { it.javaHome.absolutePath }

        val utils = withClassJar("utils.jar", JavaClassUtil::class.java)
        mavenRepo.module("test", "utils", "1.0")