Resolve imports in background thread in PlainTextPasteImportResolver

#KT-34956 Fixed

idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt

@@ -16,6 +16,8 @@
 
 package org.jetbrains.kotlin.idea.conversion.copy
 
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.progress.ProgressManager
 import com.intellij.psi.*
 import com.intellij.psi.search.PsiShortNamesCache
 import com.intellij.psi.util.PsiTreeUtil
@@ -30,6 +32,7 @@ import org.jetbrains.kotlin.idea.core.isVisible
 import org.jetbrains.kotlin.idea.imports.canBeReferencedViaImport
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
 import org.jetbrains.kotlin.psi.KtFile
@@ -69,6 +72,10 @@ class PlainTextPasteImportResolver(private val dataForConversion: DataForConvers
     }
 
     fun addImportsFromTargetFile() {
+        if (importList in dataForConversion.elementsAndTexts.toList()) return
+
+        val task = {
+            val addImportList = mutableListOf<PsiImportStatementBase>()
 
             fun tryConvertKotlinImport(importDirective: KtImportDirective) {
                 val importPath = importDirective.importPath
@@ -92,16 +99,29 @@ class PlainTextPasteImportResolver(private val dataForConversion: DataForConvers
                     if (importPath.isAllUnder) {
                         when {
                             isClassReceiver ->
-                            addImport(psiElementFactory.createImportStaticStatement(receiver as PsiClass, "*"))
+                                addImportList.add(
+                                    psiElementFactory.createImportStaticStatement(
+                                        receiver as PsiClass,
+                                        "*"
+                                    )
+                                )
                             isPackageReceiver ->
-                            addImport(psiElementFactory.createImportStatementOnDemand((receiver as PsiPackage).qualifiedName))
+                                addImportList.add(
+                                    psiElementFactory.createImportStatementOnDemand(
+                                        (receiver as PsiPackage).qualifiedName
+                                    )
+                                )
                         }
                     } else {
                         when {
                             isClassSelector ->
-                            addImport(psiElementFactory.createImportStatement(selector as PsiClass))
+                                addImportList.add(
+                                    psiElementFactory.createImportStatement(
+                                        selector as PsiClass
+                                    )
+                                )
                             isClassReceiver ->
-                            addImport(
+                                addImportList.add(
                                     psiElementFactory.createImportStaticStatement(
                                         receiver as PsiClass,
                                         importPath.importedName!!.asString()
@@ -111,11 +131,23 @@ class PlainTextPasteImportResolver(private val dataForConversion: DataForConvers
                     }
                 }
             }
-        if (importList !in dataForConversion.elementsAndTexts.toList()) {
+
-            runWriteAction {
+            runReadAction {
-                targetFile.importDirectives.forEach(::tryConvertKotlinImport)
+                val importDirectives = targetFile.importDirectives
+                importDirectives.forEachIndexed { index, value ->
+                    ProgressManager.getInstance().progressIndicator?.fraction = 1.0 * index / importDirectives.size
+                    tryConvertKotlinImport(value)
                 }
             }
+
+            ApplicationManager.getApplication().invokeAndWait {
+                runWriteAction { addImportList.forEach { addImport(it) } }
+            }
+        }
+
+        ProgressManager.getInstance().runProcessWithProgressSynchronously(
+            task, "Adding imports ...", true, project
+        )
     }
 
     fun tryResolveReferences() {