import com.github.jonathanxd.dracon.pijul.SuccessStatusCode
import com.github.jonathanxd.dracon.pijul.pijul

        TODO("Not yet implemented")

        val status = pijul(this.project).fileStatus(this.project, virtualFile)
        return if (status.statusCode is SuccessStatusCode) {
            status.result ?: FileStatus.UNKNOWN
        } else {
            FileStatus.UNKNOWN
        }

package com.github.jonathanxd.dracon.pijul
object PijulDiffJson {
    fun parseJson() {
    }
}

package com.github.jonathanxd.dracon.pijul.diff
import com.google.gson.GsonBuilder
import com.google.gson.annotations.SerializedName
import com.intellij.openapi.vcs.FileStatus
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import kotlin.reflect.javaType
import kotlin.reflect.typeOf
object PijulDiffJson {
    val GSON = GsonBuilder().disableHtmlEscaping().create()
    // TODO: Use Kotlin Flow and Flow-based Json reading
    @OptIn(ExperimentalStdlibApi::class)
    fun parseJson(json: String): List<ChangeEntry> =
        GSON.fromJson<Map<String, List<ChangeData>>>(json, typeOf<Map<String, List<ChangeData>>>().javaType).entries.map {
            ChangeEntry(it.key, it.value)
        }
}
fun List<ChangeEntry>.toFileStatusMap(): Map<String, List<FileStatus>> =
    this.associateBy { it.path }.mapValues {
        it.value.data.map { it.toFileStatus() }
    }
fun ChangeData.toFileStatus(): FileStatus =
    when (this.operation) {
        "replacement", "edit" -> FileStatus.MODIFIED
        "file move" -> FileStatus.ADDED
        "file del" -> FileStatus.DELETED
        "file undel" -> FileStatus.ADDED
        "file add" -> FileStatus.ADDED
        // "solve name conflict" -> ?
        // "unsolve name conflict" -> ?
        // "solve order conflict" -> ?
        // "unsolve order conflict" -> ?
        // "resurrect zombies" -> ????????????????????
        else -> FileStatus.UNKNOWN
    }
data class ChangeEntry(val path: String, val data: List<ChangeData>)
data class ChangeData(@SerializedName("operation") val operation: String, @SerializedName("line") val line: Any?)

    }

        fun findPijulDirectory(root: VirtualFile): VirtualFile? =
            findPijulDirectory(Paths.get(VcsUtil.getFilePath(root).path))

    fun findPijulDirectory(root: VirtualFile): VirtualFile? {
        var dir: Path? = Paths.get(VcsUtil.getFilePath(root).path)

        fun findPijulDirectory(root: Path): VirtualFile? {
            var dir: Path? = root

        while (dir != null) {
            if (isPijulRepository(dir)) {
                return LocalFileSystem.getInstance().findFileByNioFile(dir)

            while (dir != null) {
                if (isPijulRepository(dir)) {
                    return LocalFileSystem.getInstance().findFileByNioFile(dir)
                }
                dir = dir.parent

            dir = dir.parent

            return null

        return null
    }

        fun isUnderPijul(root: VirtualFile): Boolean = findPijulDirectory(root) != null

    fun isUnderPijul(root: VirtualFile): Boolean = this.findPijulDirectory(root) != null

        fun isUnderPijul(root: Path): Boolean = findPijulDirectory(root) != null
    }

import com.github.jonathanxd.dracon.pijul.diff.PijulDiffJson
import com.github.jonathanxd.dracon.pijul.diff.toFileStatusMap

import com.intellij.openapi.components.Service

import com.intellij.openapi.vcs.ProjectLevelVcsManager

import kotlin.io.path.ExperimentalPathApi
import kotlin.io.path.relativeTo

    @OptIn(ExperimentalPathApi::class)

        val root = ProjectLevelVcsManager.getInstance(project).getVcsRootFor(file)
            ?: return PijulOperationResult("file_status", SuccessStatusCode, FileStatus.UNKNOWN)
        val rootPath = Paths.get(VcsUtil.getFilePath(root).path)
        val execution = this.execPijul(project, rootPath, listOf("diff", "--json"), delay = 10L)

        return this.doExecutionWithMapper("file_status", execution) {
            val changes = PijulDiffJson.parseJson(it)
            val changeMap = changes.toFileStatusMap()
            val fPath = Paths.get(VcsUtil.getFilePath(file.path).path).relativeTo(rootPath).toString()
            if (fPath.isEmpty()) {
                FileStatus.SUPPRESSED
            } else {
                changeMap[fPath]?.firstOrNull()
            }
        }

        }
    }
    fun <T> doExecutionWithMapper(name: String,
                                execution: PijulExecution,
                                regularStreamStringMapper: (String) -> T?): PijulOperationResult<T> {
        val status = runBlocking(Dispatchers.IO) {
            execution.status.first()

        return if (status == 0) {
            val std = runBlocking(Dispatchers.IO) {
                execution.regularStream.toList().joinToString("\n")
            }
            PijulOperationResult(name, SuccessStatusCode, regularStreamStringMapper(std))
        } else {
            val error = runBlocking(Dispatchers.IO) {
                execution.errorStream.toList().joinToString("\n")
            }
            PijulOperationResult(name, NonZeroExitStatusCode(status, error), Unit) as PijulOperationResult<T>
        }

                          args: List<String>): PijulExecution {

                          args: List<String>,
                          delay: Long = 1000L): PijulExecution {

                    delay(1000L)

                    delay(delay)

import com.github.jonathanxd.dracon.pijul.Pijul

            if (pijul(project).isUnderPijul(root)) {

            if (Pijul.isUnderPijul(root)) {