package ioutil

import (
	"io"
	"os"
)

// AppendFile - appends the file "src" to the file "dst"
func AppendFile(dst string, src string, osync bool) error {
	flags := os.O_WRONLY | os.O_APPEND | os.O_CREATE
	if osync {
		flags |= os.O_SYNC
	}
	appendFile, err := os.OpenFile(dst, flags, 0o666)
	if err != nil {
		return err
	}
	defer appendFile.Close()

	srcFile, err := os.Open(src)
	if err != nil {

        return buildString {
            appendLine("$expression.mapKeys { ($keyName, _) ->")
            appendLine(keyTransformation.withIndent(context.increaseIndent()))
            appendLine("}.mapValues { (_, $valueName) -> ".withIndent(context))
            appendLine(valueTransformation.withIndent(context.increaseIndent()))
            append("}".withIndent(context))
        }

    if (endWithNewLine) printer.appendLine(renderedValue) else printer.append(renderedValue)
}

internal data class Context(val session: KaSession, val printer: PrettyPrinter, val symbolRenderer: DebugSymbolRenderer)

private fun PrettyPrinter.appendHeader(clazz: KClass<*>, body: PrettyPrinter.() -> Unit) {
    append(clazz.simpleName)
    appendLine(":")
    withIndent { body() }
}

            buildString {
                appendLine("${KtTypeReference::class.simpleName}: ${ktTypeReference.text}")
                appendLine("annotations: [")
                for (annotation in annotations) {
                    appendLine(DebugSymbolRenderer().renderAnnotationApplication(analysisSession, annotation).indented(indent = 2))
                }
                appendLine("]")
            }
        }

                                appendLine("asPsiType(allowErrorTypes=$allowErrorTypes, mode=$typeMappingMode, isAnnotationMethod=$isAnnotationMethod):")
                                withIndent {
                                    appendLine("PsiType: ${AnalysisApiPsiTypeProviderTestUtils.render(psiType)}")
                                }
                                appendLine()
                            }

        withIndent {
            appendLine()
            renderProperty(KaCallableSymbol::callableId, printer, renderSymbolsFully = false, symbol)
            if (symbol is KaNamedSymbol) {
                appendLine()
                renderProperty(KaNamedSymbol::name, printer, renderSymbolsFully = false, symbol)
            }
            appendLine()

            }
        }
        val actual = buildString {
            appendLine("expression: ${expressionAtCaret.text}")
            appendLine("expected type: $type")
            appendLine("functionClassKind: $functionClassKind")
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

            val symbol = expressionAtCaret.getTypeParameterSymbol()
            val ktType = buildTypeParameterType(symbol)
            buildString {
                appendLine("${KtTypeParameter::class.simpleName}: ${expressionAtCaret.text}")
                appendLine("${KaType::class.simpleName}: ${ktType.render(position = Variance.INVARIANT)}")
            }
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)

        val readWriteAccess = expressionAtCaret.readWriteAccess(true)

        val actual = buildString {
            appendLine("expression: ${expressionAtCaret.text}")
            appendLine("access type: $readWriteAccess")
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

                buildString {
                    appendLine("ALL:")
                    allOverriddenSymbols.forEach { appendLine("  $it") }
                    appendLine("DIRECT:")
                    directlyOverriddenSymbols.forEach { appendLine("  $it") }
                }
            }
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)