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(

        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 KaFe10FileSymbol(psi, analysisContext)
    }

    override fun getScriptSymbol(psi: KtScript): KaScriptSymbol {
        return KaFe10PsiScriptSymbol(psi, analysisContext)
    }

    override fun getParameterSymbol(psi: KtParameter): KaVariableLikeSymbol {
        return when {

                        processingClassOrObject is KtObjectDeclaration && inlineObjectDeclarations.contains(processingClassOrObject)
            }

            override fun shouldGenerateScript(script: KtScript): Boolean {
                return script.containingKtFile === file
            }

            override fun shouldGenerateCodeFragment(script: KtCodeFragment) = false
        }