index.check.text=Checking revisions...
index.load.rev.for.text=Loading revision <tt>{0}</tt> for file <tt>{1}</tt>
index.check.rev.text=Checking revision <tt>{0}</tt>...

index.copy.text=Copying files...

        <projectCloseHandler implementation="com.github.jonathanxd.dracon.handler.DraconCloseHandler" />

import org.apache.commons.codec.digest.DigestUtils

import java.security.MessageDigest

import kotlin.io.path.exists

    val tempDir = FileUtilRt.createTempDirectory("dracon_diffs-all-", revisionHash + UUID.randomUUID().toString())

    val sha1 = DigestUtils.sha1Hex(revisionHash)
    val tempDir = FileUtilRt.createTempDirectory("dracon_diffs-all-", sha1)

    if (Files.exists(tmpTarget.resolve(".pijul"))) {
        val ls = pijul(project).trackedFiles(project, tmpTarget)
        if (ls.statusCode !is SuccessStatusCode) {
            throw IllegalStateException("Failed to load state of all files in revision $revisionHash during reset. $ls")
        }
        i.fraction += 0.0001
        val trackedFiles = ls.result!!
        trackedFiles.forEachWithProgress(i) { it, indic ->
            indic.text2 = DraconBundle.message("index.item.description.text", it.toString())
            if (Files.isRegularFile(it)) {
                pathToRevisionState[it] = Files.readAllBytes(it)
            }
        }
        return pathToRevisionState
    }

        throw IllegalStateException("Failed to load state of all files in revision $revisionHash during reset. $revisions")

        throw IllegalStateException("Failed to load state of all files in revision $revisionHash during reset. $ls")

        FileUtilRt.delete(tempDir)

        //FileUtilRt.delete(tempDir)

fun loadStateInRevisionForAllFilesForFile(revisionHash: String,
                                   project: Project,
                                   root: Path,
                                          file: Path): ByteArray {
    val sha1 = DigestUtils.sha1Hex(revisionHash)
    val tempDir = FileUtilRt.createTempDirectory("dracon_diffs-all-", sha1)
    val tmpTarget = tempDir.toPath()
    if (Files.exists(tmpTarget.resolve(".pijul"))) {
        val relativeToRoot = file.relativeTo(root)
        val relativeToTmpTarget = tmpTarget.resolve(relativeToRoot)
        if (Files.exists(relativeToTmpTarget)) {
            return Files.readAllBytes(relativeToTmpTarget)
        }
    }
    copyFolder(root, tmpTarget, StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING)
    val revisions = pijul(project).latestRevisionNumber(project, tmpTarget).result
    val reset = pijul(project).reset(project, tmpTarget)
    if (reset.statusCode !is SuccessStatusCode) {
        throw IllegalStateException("Failed to load state of all files in revision $revisionHash during reset. $revisions")
    }
    if (revisions == null || revisions.hash != revisionHash) {
        val rollbackOp = pijul(project).rollbackTo(revisionHash, project, tmpTarget)
        if (rollbackOp.statusCode !is SuccessStatusCode) {
            throw IllegalStateException("Failed to load state of all files in revision $revisionHash during unrecord. $rollbackOp")
        }
    }
    try {
        val relativeToRoot = file.relativeTo(root)
        val relativeToTmpTarget = tmpTarget.resolve(relativeToRoot)
        return if (Files.exists(relativeToTmpTarget)) {
            Files.readAllBytes(relativeToTmpTarget)
        } else {
            ByteArray(0)
        }
    } finally {
        //FileUtilRt.delete(tempDir)
    }
}
@OptIn(ExperimentalPathApi::class)

    val tempDir = FileUtilRt.createTempDirectory("dracon_diffs-all-","${allRevisions.size}-" + UUID.randomUUID().toString())

    val sha1 = DigestUtils.sha1Hex(allRevisions.toString())
    val tempDir = FileUtilRt.createTempDirectory("dracon_diffs-all-", sha1)

        if (indexOfFirstRevision + allRevisions.size >= pijulRevisions.size) {

        if (indexOfFirstRevision + allRevisions.size > pijulRevisions.size) {

        throw IllegalStateException("Failed to load state of all files in revisions '$allRevisions' during reset. $reset")

        IllegalStateException("Failed to load state of all files in revisions '$allRevisions' during reset. $reset").printStackTrace()
        return revisionToPathToState

        FileUtilRt.delete(tempDir)

        //FileUtilRt.delete(tempDir)
    }
}
@OptIn(ExperimentalPathApi::class)
fun loadFileStateInRevision(
    revision: String,
    project: Project,
    root: Path,
    cachePath: Path,
    file: Path,
    i: ProgressIndicator,
    cacheAllRevisions: Boolean = true
): FileStateInCache {
    val dir = resolveDirForRevision(cachePath, revision, createIfNotExists = false)
    val fileRelativeToRoot = file.relativeTo(root)
    if (!Files.exists(dir)) {
        val allRevisions = pijul(project).allRevisions(project, root).result!!.map { it.hash }
        val revisions = if (allRevisions[0] == revision) {
            listOf(revision)
        } else {
            allRevisions.subList(0, allRevisions.indexOf(revision) + 1)
        }
        val cacheMap = createCacheForRevisionFromTo(
            revisions,
            project,
            root,
            cachePath,
            i,
            cacheAllRevisions
        )
        if (!cacheMap.containsKey(revision)) {
            throw IllegalStateException("Failed to load state of all files in revision $revision")
        }
    }
    val fileInCache = dir.resolve(fileRelativeToRoot)
    return if (Files.exists(fileInCache) && Files.isRegularFile(fileInCache)) {
        FileStateInCache(file, fileInCache, false, Files.readAllBytes(fileInCache))
    } else {
        FileStateInCache(file, fileInCache, true, ByteArray(0))
    }
}
data class FileStateInCache(
    val originalPath: Path,
    val pathInCache: Path,
    val deleted: Boolean,
    val content: ByteArray
) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false
        other as FileStateInCache
        if (originalPath != other.originalPath) return false
        if (pathInCache != other.pathInCache) return false
        if (deleted != other.deleted) return false
        if (!content.contentEquals(other.content)) return false
        return true
    }
    override fun hashCode(): Int {
        var result = originalPath.hashCode()
        result = 31 * result + pathInCache.hashCode()
        result = 31 * result + deleted.hashCode()
        result = 31 * result + content.contentHashCode()
        return result
    }
}
fun resolveDirForRevision(cachePath: Path, revision: String, createIfNotExists: Boolean = true): Path {
    val path = cachePath.resolve(revision)
    if (createIfNotExists)
        Files.createDirectories(path)
    return path
}
@OptIn(ExperimentalPathApi::class)
fun createCacheForRevisionFromTo(allRevisions: List<String>,
                                 project: Project,
                                 root: Path,
                                 cachePath: Path,
                                 i: ProgressIndicator,
                                 cacheAllRevisions: Boolean = true): Map<String, Path> {
    if (allRevisions.isEmpty()) {
        throw IllegalArgumentException("Provided 'allRevisions' argument must not be empty.")
    }
    val revisionsToCache = allRevisions.toMutableList()
    i.text2 = DraconBundle.message("index.check.text")
    val revisionToPath = mutableMapOf<String, Path>()
    var lastFoundCachedRevisionPath: Path? = null
    var lastFoundCachedRevision: String? = null
    for (rev in allRevisions) {
        i.text2 = DraconBundle.message("index.check.rev.text", rev)
        val path = resolveDirForRevision(cachePath, rev, createIfNotExists = false)
        if (path.exists()) {
            revisionsToCache.remove(rev)
            lastFoundCachedRevisionPath = path
            lastFoundCachedRevision = rev
            revisionToPath["rev"] = path
        }
    }
    i.text2 = DraconBundle.message("index.item.description.finish.text")
    if (revisionsToCache.isEmpty()) {
        return revisionToPath
    }
    if (!cacheAllRevisions) {
        val last = revisionsToCache.last()
        revisionsToCache.clear()
        revisionsToCache.add(last)
    }
    val temporaryWorkingDirectory = cachePath.resolve(".tmp-work-dir-" + UUID.randomUUID().toString())
    Files.createDirectories(temporaryWorkingDirectory)
    if (lastFoundCachedRevision != null && lastFoundCachedRevisionPath != null) {
        // Copies last found revision into temporaryWorkingDirectory
        // This prevents from rolling back from revisions that are already cached.
        copyFolder(lastFoundCachedRevisionPath, temporaryWorkingDirectory)
    } else {
        // Copy current .pijul working dir into temporaryWorkingDirectory
        copyFolder(root, temporaryWorkingDirectory)
    }
    val revisions = pijul(project).allRevisions(project, temporaryWorkingDirectory)
    if (revisions.statusCode !is SuccessStatusCode) {
        throw IllegalStateException("Failed to load state of all files in revisions '$revisionsToCache' during all revisions hash retrieval. $revisions")
    }
    val pijulRevisions = revisions.result!!.map { it.hash }
    val indexOfFirstRevision = pijulRevisions.indexOf(revisionsToCache[0])
    if (indexOfFirstRevision == -1) {
        throw IllegalArgumentException("Could not find revision ${revisionsToCache[0]} in Pijul repository!")
    } else {
        if (indexOfFirstRevision + revisionsToCache.size > pijulRevisions.size) {
            throw IllegalArgumentException("There are more revisions to unrecord than the amount of recorded changes in Pijul Repository.")
        } else {
            val revisionSubList = pijulRevisions.subList(indexOfFirstRevision, indexOfFirstRevision + revisionsToCache.size)
            if (revisionsToCache != revisionSubList) {
                throw IllegalArgumentException("Revisions to load must sequentially match a sub sequence of revisions in Pijul repository. " +
                        "Changes found in pijul: $revisionSubList. Changes to unrecord: $revisionsToCache")
            }
        }
    }
    i.text2 = DraconBundle.message("index.reset.text")
    val reset = pijul(project).reset(project, temporaryWorkingDirectory)
    if (reset.statusCode !is SuccessStatusCode) {
        IllegalStateException("Failed to load state of all files in revisions '$revisionsToCache' during reset. $reset").printStackTrace()
        return revisionToPath
    }
    i.fraction += 0.0001
    revisionsToCache.withIndex().toList().forEachWithProgress(i) { (index, rev), indicator ->
        indicator.text2 = DraconBundle.message("index.revision.description.text", rev)
        val resolvedPathForRevision = resolveDirForRevision(cachePath, rev, createIfNotExists = false)
        if (Files.exists(resolvedPathForRevision)) {
            deleteFilesInsideDirectory(temporaryWorkingDirectory)
            copyFolder(resolvedPathForRevision, temporaryWorkingDirectory)
        } else {
            val rollback = pijul(project).rollbackTo(rev, project, temporaryWorkingDirectory)
            if (rollback.statusCode !is SuccessStatusCode) {
                throw IllegalStateException("Failed to load state of all files in revision '$rev' during rollback. $rollback")
            }
            /*if (index == 0) {
            } else {
                val unrecord = pijul(project).unrecord(project, temporaryWorkingDirectory, revisionsToCache[index - 1])
                if (unrecord.statusCode !is SuccessStatusCode) {
                    throw IllegalStateException("Failed to load state of all files in revision '$rev' during unrecord. $unrecord")
                }
            }*/
            indicator.text2 = DraconBundle.message("index.copy.text")
            copyFolder(temporaryWorkingDirectory, resolvedPathForRevision)
        }
        revisionToPath[rev] = resolvedPathForRevision
    }
    i.text2 = DraconBundle.message("index.item.description.finish.text")
    try {
        return revisionToPath
    } finally {
        FileUtilRt.delete(temporaryWorkingDirectory.toFile())

    val copyOptions = arrayOf(*options, StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING)

            Files.copy(file, target.resolve(source.relativize(file)), *options)

            Files.copy(file, target.resolve(source.relativize(file)), *copyOptions)
            return FileVisitResult.CONTINUE
        }
    })
}
fun deleteFilesInsideDirectory(path: Path) {
    Files.walkFileTree(path, object : SimpleFileVisitor<Path>() {
        override fun preVisitDirectory(dir: Path, attrs: BasicFileAttributes): FileVisitResult {
            return if (dir != path) FileVisitResult.CONTINUE
            else FileVisitResult.SKIP_SUBTREE
        }
        override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
            Files.delete(file)

    private val content = this.project.service<FileRevisionCache>().loadAsync(this)

    private val content by lazy {
        this.project.service<FileRevisionCache>().loadAsync(this)
    }

                        pijul(project).changes(project, ctx.root, it, -1, {

                        pijul(project).changes(project, ctx.root, it, 1, {

import kotlin.io.path.isDirectory

                }.forEach { path, hunks ->

                }.filter { pathToView.isDirectory() || it.key == pathToView }.forEach { path, hunks ->

package com.github.jonathanxd.dracon.log
import com.intellij.vcs.log.Hash
class PijulHash(val hash: String) : Hash {
    override fun asString(): String = this.hash
    override fun toShortString(): String = this.hash.substring(0, 10)
}

package com.github.jonathanxd.dracon.log
import com.intellij.vcs.log.Hash
class PijulHash(val hash: String) : Hash {
    override fun asString(): String = this.hash
    override fun toShortString(): String = this.hash.substring(0, 10)
}

package com.github.jonathanxd.dracon.handler
import com.github.jonathanxd.dracon.cache.FileRevisionCache
import com.intellij.openapi.components.serviceIfCreated
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.ProjectCloseHandler
class DraconCloseHandler: ProjectCloseHandler {
    override fun canClose(project: Project): Boolean {
        val fileRevisionCache = project.serviceIfCreated<FileRevisionCache>()
        fileRevisionCache?.invalidate()
        return true
    }
}

    private val content = this.project.service<FileRevisionCache>().loadAsync(this)

    private val content by lazy {
        this.project.service<FileRevisionCache>().loadAsync(this)
    }

    fun isToCacheAllRevisions(): Boolean =
        this.state.cacheAllRevisions

    @get:OptionTag("CACHE_ALL_REVISIONS")
    var cacheAllRevisions by property(defaultValue = true)

        val execution = this.createPainlessExecPijulOperation(project, rootPath, listOf("diff", "--json"))

        val execution = this.createPainlessExecPijulOperation(project, rootPath, listOf("diff", "--json"), logOutput = false)

        val execution = this.createPainlessExecPijulOperation(project, root, listOf("diff", "--json"))

        val execution = this.createPainlessExecPijulOperation(project, root, listOf("diff", "--json"), logOutput = false)

        val execution = this.createPainlessExecPijulOperation(project, root, listOf("diff", "--json"))

        val execution = this.createPainlessExecPijulOperation(project, root, listOf("diff", "--json"), logOutput = false)

        }?.map { entry ->

        }?.asSequence()?.map { entry ->

        args: List<String>

        args: List<String>,
        logOutput: Boolean = true,

        input.split("\n").forEach {
            draconConsoleWriter(project).logCommand("pijul", args, it)

        if (logOutput) {
            if (input.trim().isNotEmpty()) {
                input.split("\n").forEach {
                    draconConsoleWriter(project).logCommand("pijul", args, it)
                }
            }

        error.split("\n").forEach {
            draconConsoleWriter(project).logCommandError("pijul", args, it)

        if (error.trim().isNotEmpty()) {
            error.split("\n").forEach {
                draconConsoleWriter(project).logCommandError("pijul", args, it)
            }

import com.github.jonathanxd.dracon.config.PijulSettings

import com.github.jonathanxd.iutils.`object`.Lazy
import com.intellij.execution.Executor

import com.intellij.openapi.progress.EmptyProgressIndicator
import com.intellij.openapi.progress.ProgressIndicator
import com.intellij.openapi.progress.forEachWithProgress
import com.intellij.openapi.progress.withPushPop

import com.intellij.openapi.progress.*

import com.intellij.openapi.project.getProjectDataPath
import com.intellij.openapi.util.ThrowableComputable

import java.nio.file.Files

class FileRevisionCache(val project: Project) : CacheService<FileRevisionRef, ByteArray> {
    override val cache = DataCache<FileRevisionRef, ByteArray>(this.project, "file_revision")

class FileRevisionCache(val project: Project)  {
    //override val cache = DataCache<String, Map<String, ByteArray>>(this.project, "path_revision")
    fun cachePath(): Path =
        this.project.getProjectDataPath("com.github.jonathanxd.dracon").resolve("revision-cache")

        val fileRev = FileRevisionRef(file.filePathAsString(), rev.hash)

        val cache = this.cachePath()

        return this.cache.queryOrLoadAsyncExpanded(fileRev) {
            val revisions = loadStateInEveryRevisionForAllFiles(
                listOf(rev.hash),
                project,
                root,
                EmptyProgressIndicator()
            )

        Files.createDirectories(cache)
        val completableFuture = CompletableFuture<ByteArray>()

            val revisionsForHash = revisions[rev.hash]!!
            val stringKeys = revisionsForHash.mapKeys { (k, _) -> k.filePathAsString() }
            stringKeys[it.filePath]!! to stringKeys.map { (k, v) -> FileRevisionRef(k, rev.hash) to v }

        ProgressManager.getInstance().run(object : Task.Backgroundable(
            project,
            DraconBundle.message("index.load.rev.for.text", rev.hash.substring(0, 10), file.fileName.toString()),
            true
        ) {
            override fun run(indicator: ProgressIndicator) {
                indicator.isIndeterminate = false
                try {
                    val revision = loadFileStateInRevision(
                        rev.hash,
                        project,
                        root,
                        cache,
                        file,
                        indicator,
                        project.service<PijulSettings>().isToCacheAllRevisions()
                    )
                    completableFuture.complete(revision.content)
                } catch (t: Throwable) {
                    t.printStackTrace()
                    completableFuture.completeExceptionally(t)
                }
            }
        })
        return completableFuture.handle { t, u ->
            u?.printStackTrace()
            t ?: ByteArray(0)

    fun loadAndPrecacheRevisions(amount: Int, i: ProgressIndicator) {

    fun invalidate() {
        deleteFilesInsideDirectory(this.cachePath())
    }
    /*fun loadAndPrecacheRevisions(amount: Int, i: ProgressIndicator) {

                    stateMap.entries.forEachWithProgress(indic) { (path, bytes), indicator2 ->
                        indicator2.text2 =
                            DraconBundle.message("index.revision.file.description.text", path.toString(), rev)
                        val revRef = FileRevisionRef(path.filePathAsString(), rev)
                        this.cache.updateCache(revRef) {
                            bytes
                        }

                    this.cache.updateCache(rev) {
                        stateMap.mapKeys { (k, _) -> k.filePathAsString() }

    }
}
data class FileRevisionRef(
    val filePath: String,
    val revision: String
) : Serializable

    }*/
}

    private val updateExecutor = Executors.newWorkStealingPool(16)

    private val updateExecutor = Executors.newSingleThreadExecutor()

                fileRevisionCache.loadAndPrecacheRevisions(PRE_INDEX_REVISION_AMOUNT, indicator)

                //fileRevisionCache.loadAndPrecacheRevisions(PRE_INDEX_REVISION_AMOUNT, indicator)

platformVersion = LATEST-EAP-SNAPSHOT

platformVersion = 211.6693.111

                File("./README.md").readText().lines().run {

                projectDir.resolve("README.md").readText().lines().run {