/** Wrappers around commands such `git`, `patch`, etc.
 *
 * Original version https://gist.github.com/PetarKirov/b4c8b64e7fc9bb7391901bcb541ddf3a
 *
 * See_Also: https://github.com/CyberShadow/ae/blob/master/sys/git.d
 * See_Also: https://forum.dlang.org/post/ziqgqpkdjolplyfztulp@forum.dlang.org
 *
 * TODO: integrate @CyberShadow’s ae.sys.git at ae/sys/git.d
 */
module nxt.cmd;

import std.exception : enforce;
import std.format : format;
import std.file : exists, isDir, isFile;
import std.path : absolutePath, buildNormalizedPath, dirName, relativePath;
import std.stdio : write, writeln, writefln, File, stdin;
import nxt.fs;

@safe:

/** Spawn logging configuration.
 */
struct Log
{
    enum Fmt
    {
        tree,                   ///< Tree-like. Default.
        trad,                   ///< Traditional.
    }

    bool opCast(T : bool)() const scope @safe pure nothrow @nogc
    {
        return fmt != Fmt.none;
    }

private:
    Fmt fmt;
    bool echoDesc = true;       ///< Echo description.
    bool echoSpawn = false;      ///< Echo spawn arguments.
    bool echoWait = false;       ///< Echo wait.
    bool echoOut = false; ///< Echo standard output upon completion of execution.
    bool echoErr = false; ///< Echo standard error upon completion of execution.
    bool colored = true;
}

ExitCode exitMessage(ExitCode code)
{
    return typeof(return)(code);
}

struct ExitCode
{
    @property void toString(scope void delegate(scope const(char)[]) @safe sink, in bool colored = true) const scope
    {
        import nxt.ansi_escape : putWithSGRs, SGR;
        if (colored)
            putWithSGRs(sink, value == 0 ? "SUCCESS" : "FAILURE", SGR.whiteForegroundColor);
    }
    int value;
    alias value this;
}

/** Process spawn state.
 */
@safe struct Spawn
{
    import std.process : Pid;
    Pid pid;
    File _out;
    File _err;
    Log log;

    this(Pid pid, File _out, File _err, Log log)
    {
        this.pid = pid;
        this._out = _out;
        this._err = _err;
        this.log = log;
    }

    @disable this(this);        // avoid copying `File`s for now

    ExitCode wait()
    {
        if (log.echoWait)
            writeIng("Waiting");

        import std.process : wait;
        auto code = typeof(return)(pid.wait());

        writeln(" (", code, ")");

        void echo(File src, File dst, in string name)
        {
            writeln("  - ", name, ":");
            src.flush();
            import std.algorithm.mutation: copy;
            () @trusted { src.byLine().copy(dst.lockingBinaryWriter); } (); // TODO: writeIndented
        }

        import std.stdio : stdout, stderr;
        if (code != 0 ||        // always show stdout upon failure
            log.echoOut)
        {
            () @trusted { echo(_out, stdout, "OUT"); } ();
        }
        if (code != 0 ||        // always show stderr upon failure
            log.echoErr)
        {
            () @trusted { echo(_err, stderr, "ERR"); } ();
        }

        return code;
    }
}

Spawn spawn(scope ref Log log, scope const(char[])[] args, File stdin_ = stdin)
{
    if (log.echoSpawn)
        writeIng("Spawning ", args);
    import std.stdio : stdout, stderr;
    auto out_ = log.echoOut ? () @trusted { return stdout; } () : File("/dev/null", "wb");
    auto err_ = log.echoErr ? () @trusted { return stderr; } () : File("/dev/null", "wb");
    import std.process : spawnProcess;
    return typeof(return)(spawnProcess(args, stdin_, out_, err_), out_, err_, log);
}

/** Patch file handling.
 */
struct Patch
{
    Path file;
    uint level;
    Log log;

    this(Path file, in uint level, in bool echoOutErr)
    {
        this.file = file;
        this.level = level;
        this.log = Log(Log.Fmt.init, echoOutErr);
    }

    Spawn applyIn(in DirPath dir)
    {
        import std.conv : to;
        import std.stdio : File;
        if (log.echoDesc)
            final switch (log.fmt)
            {
            case Log.Fmt.tree: writeIng(dir, ": Applying patch ", file.absolutePath); break;
            case Log.Fmt.trad: writeIng("Applying patch ", file.absolutePath, " at ", dir); break;
            }
        return spawn(log,
                     ["patch", // TODO: can we use execute shell instead?
                          "-d", dir[].to!string,
                          "-p"~level.to!string],
                         File(file[].absolutePath.to!string));
    }
}

struct Repository
{
    const URL url;
    const DirPath lrd;            ///< Local root directory.
    Log log;

    this(in URL url, in DirPath lrd, in bool echoOutErr)
    {
        this.url = url;
        this.lrd = lrd;
        this.log = Log(Log.Fmt.init, echoOutErr);
    }

    @disable this(this);

    Spawn cloneOrPull(in bool recursive, in string branch = [])
    {
        if (lrd.buildNormalizedPath(".git").exists)
            return pull(recursive);
        else
            return clone(recursive, branch);
    }

    Spawn cloneOrRefresh(in bool recursive, in string remote, in string branch = [])
    {
        if (lrd.buildNormalizedPath(".git").exists)
            return refresh(recursive, remote, branch);
        else
            return clone(recursive, branch);
    }

    Spawn clone(in bool recursive, in string branch = [])
    {
        final switch (log.fmt)
        {
        case Log.Fmt.tree: writeIng(url, ": Cloning to ", lrd); break;
        case Log.Fmt.trad: writeIng("Cloning ", url, " to ", lrd); break;
        }
        return spawn(log,
                     ["git", "clone"]
                     ~ [url, lrd]
                     ~ (branch.length ? ["-b", branch] : [])
                     ~ (recursive ? ["--recurse-submodules"] : []));
    }

    Spawn pull(in bool recursive)
    {
        if (log.echoDesc)
            writeIng("Pulling ", url, " to ", lrd);
        return spawn(log,
                     ["git", "-C", lrd, "pull"]
                     ~ (recursive ? ["--recurse-submodules"] : []));
    }

    Spawn refresh(in bool recursive, in string remote, in string branch = [])
    {
        if (log.echoDesc)
            writeIng("Refreshing ", url, " to ", lrd);
        fetch([remote]);
        if (branch)
            return resetHardTo(remote~"/"~branch, recursive);
        else
            return resetHard(recursive);
    }

    Spawn checkout(in string branchName)
    {
        if (log.echoDesc)
            writeIng("Checking out branch ", branchName, " at ", lrd);
        return spawn(log, ["git", "-C", lrd, "checkout" , branchName]);
    }

    Spawn remoteRemove(in string name)
    {
        if (log.echoDesc)
            writeIng("Removing remote ", name, " at ", lrd);
        return spawn(log, ["git", "-C", lrd, "remote", "remove", name]);
    }
    alias removeRemote = remoteRemove;

    Spawn remoteAdd(in URL url, in string name)
    {
        if (log.echoDesc)
            writeIng("Adding remote ", url, " at ", lrd, (name ? " as " ~ name : "") ~ " ...");
        return spawn(log, ["git", "-C", lrd, "remote", "add", name, url]);
    }
    alias addRemote = remoteAdd;

    Spawn fetch(in string[] names)
    {
        if (log.echoDesc)
            writeIng("Fetching remotes ", names, " at ", lrd);
        if (names)
            return spawn(log, ["git", "-C", lrd, "fetch", "--multiple"] ~ names);
        else
            return spawn(log, ["git", "-C", lrd, "fetch"]);
    }

    Spawn fetchAll()
    {
        if (log.echoDesc)
            writeIng("Fetching all remotes at ", lrd);
        return spawn(log, ["git", "-C", lrd, "fetch", "--all"]);
    }

    Spawn clean()
    {
        if (log.echoDesc)
            writeIng("Cleaning ", lrd);
        return spawn(log, ["git", "-C", lrd, "clean", "-ffdx"]);
    }

    Spawn resetHard(in bool recursive)
    {
        if (log.echoDesc)
            writeIng("Resetting hard ", lrd);
        return spawn(log, ["git", "-C", lrd, "reset", "--hard"]
                     ~ (recursive ? ["--recurse-submodules"] : []));
    }

    Spawn resetHardTo(in string treeish, in bool recursive)
    {
        if (log.echoDesc)
            writeIng("Resetting hard ", lrd);
        return spawn(log, ["git", "-C", lrd, "reset", "--hard", treeish]
                     ~ (recursive ? ["--recurse-submodules"] : []));
    }

    Spawn merge(in string[] commits, in string[] args = [])
    {
        if (log.echoDesc)
            writeIng("Merging commits ", commits, " with flags ", args, " at ", lrd);
        return spawn(log, ["git", "-C", lrd, "merge"]
                     ~ args ~ commits);
    }
}

void writeIng(S...)(S args)
{
    import std.stdio : stdout;
    write(args, " ...");
    () @trusted { stdout.flush(); } ();
}