import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtScript
import org.jetbrains.kotlin.resolve.BindingContext

internal class KaFe10PsiScriptSymbol(
    private val script: KtScript,
    override val analysisContext: Fe10AnalysisContext
) : KaScriptSymbol(), KaFe10AnnotatedSymbol, KaFe10PsiSymbol<KtScript, ScriptDescriptor> {
    override val descriptor: ScriptDescriptor? by cached {

    private val topLevelDeclarations: Sequence<KtDeclaration>
        get() {
            return sequence {
                for (child in kotlinFile.declarations) {
                    if (child is KtScript) {
                        yieldAll(child.declarations)
                    } else {
                        yield(child)
                    }
                }
            }
        }

        )
    }

    @Test
    fun `plugin id can contain dot gradle dot kts substring within its id`() {

        assertThat(
            scriptPlugin("dev.gradle.ktscript.plugin.gradle.kts").id,
            equalTo("dev.gradle.ktscript.plugin")
        )
    }

    @Test
    fun `plugin id is prefixed by package name if present`() {

        assertThat(
            scriptPlugin(

        is KtPropertyAccessor -> getPropertyAccessorSymbol(psi)
        is KtClassInitializer -> getClassInitializerSymbol(psi)
        is KtDestructuringDeclarationEntry -> getDestructuringDeclarationEntrySymbol(psi)
        is KtScript -> getScriptSymbol(psi)
        is KtScriptInitializer -> getScriptSymbol(psi.containingDeclaration)
        is KtDestructuringDeclaration -> getDestructuringDeclarationSymbol(psi)

        return providers.flatMapTo(mutableListOf()) { it.findInternalFilesForFacade(facadeFqName) }
    }

    override fun findFilesForScript(scriptFqName: FqName): Collection<KtScript> {
        return providers.flatMapTo(mutableListOf()) { it.findFilesForScript(scriptFqName) }
    }

    override fun computePackageNames(): Set<String>? {

    override fun findInternalFilesForFacade(facadeFqName: FqName): List<KtFile> = emptyList()
    override fun findFilesForScript(scriptFqName: FqName): List<KtScript> = emptyList()

    override fun computePackageNames(): Set<String> = emptySet()
    override val hasSpecificClassifierPackageNamesComputation: Boolean get() = false

    internal val multiFileClassPartMap: MutableMap<FqName, MutableSet<KtFile>> = mutableMapOf()
    internal val scriptMap: MutableMap<FqName, MutableSet<KtScript>> = mutableMapOf()
    internal val classMap: MutableMap<FqName, MutableSet<KtClassOrObject>> = mutableMapOf()
    internal val typeAliasMap: MutableMap<FqName, MutableSet<KtTypeAlias>> = mutableMapOf()

     */
    public abstract fun findInternalFilesForFacade(facadeFqName: FqName): Collection<KtFile>

    public abstract fun findFilesForScript(scriptFqName: FqName): Collection<KtScript>

    /**
     * Calculates the set of package names which can be provided by this declaration provider.
     *

    }

    override fun getFileSymbol(psi: KtFile): KaFileSymbol {
        return firSymbolBuilder.buildFileSymbol(psi.getOrBuildFirFile(firResolveSession).symbol)
    }

    override fun getScriptSymbol(psi: KtScript): KaScriptSymbol {
        return firSymbolBuilder.buildScriptSymbol(psi.resolveToFirSymbolOfType<FirScriptSymbol>(firResolveSession))
    }

    override fun getFunctionLikeSymbol(psi: KtNamedFunction): KaFunctionLikeSymbol {

            is KtUserType ->
                false

            // Only top-level named declarations have KtFile/KtScript Parents, and are never considered used
            is KtFile ->
                false
            is KtScript ->
                false

            // Only class members have KtClassBody parents, and are never considered used
            is KtClassBody ->