/** Software package builder.
 *
 * Run as: dmd -debug -g -I.. -i xy.d -version=main && ./xy dmd druntime phobos dub DCD DustMite
 *
 * TODO: Support `xy REPO_URL`. Try for instance git@github.com:rui314/mold.git
 * or https://github.com/rui314/mold.git. Supports matching repo with registered
 * repos where repo name is stripped ending slash before matching.
 *
 * TODO: resolution-pyramid sample chronologically joined commits over dmd, druntime, phobos
 * TODO: Experiment with indentation of stdout and stderr lines
 * TODO: Show memory usage using https://code.dlang.org/packages/resusage
 * TODO: Add install using installPrefix
 * TODO: Skip building if fingerprint hasn’t changed unless --force -f is used. Put HEAD git-fingerprint directly under installPrefix
 * TODO: Delete installPrefix prior to installation
 * TODO: Add argparse --build=debug|release
 * TODO: Pick compiler dmd if --build=debug
 * TODO: Pick compiler ldmd2 if --build=release
 * TODO: --test
 */
module nxt.xy;

import std.path : absolutePath, expandTilde, buildPath;
import std.stdio : writeln;
import std.file : chdir, exists, mkdir, FileException;
import std.process : Config, spawnProcess, wait, Pid;
import std.algorithm : canFind, joiner;
import std.conv : to;
import std.exception : enforce;
import std.getopt : getopt;

import nxt.fs;
import nxt.cmd;

@safe:

/// Spec Name.
struct Name { string value; alias value this; }

/// D `version` symbol.
alias DlangVersionName = string;

struct RemoteSpec
{
    URL url;
    string remoteName;
    string[] repoBranches;
}

version(main)
    int main(string[] args)
    {
        return buildN(args);
    }

/** Build the packages `packages`.
 */
int buildN(scope const string[] packages)
{
    const bool echo = true; // TODO: getopt flag being negation of make-like flag -s, --silent, --quiet
    const BuildOption[] bos;
    auto builds = makeSpecs(echo);
    foreach (const name; packages)
        if (Spec* buildPtr = Name(name) in builds)
            (*buildPtr).go(bos, echo);
	return 0;                   // TODO: propagate exit code
}

const DlangVersionName[] versionNames = ["cli"];
const string[] dflagsLDCRelease = ["-m64", "-O3", "-release", "-boundscheck=off", "-enable-inlining", "-flto=full"];

enum BuildOption
{
	debugMode,            /// Compile in debug mode (enables contracts, -debug)
	releaseMode,          /// Compile in release mode (disables assertions and bounds checks, -release)
	ltoMode,              /// Compile using LTO
	pgoMode,              /// Compile using PGO
	coverage,             /// Enable code coverage analysis (-cov)
	debugInfo,            /// Enable symbolic debug information (-g)
	debugInfoC,           /// Enable symbolic debug information in C compatible form (-gc)
	alwaysStackFrame,     /// Always generate a stack frame (-gs)
	stackStomping,        /// Perform stack stomping (-gx)
	inline,               /// Perform function inlining (-inline)
	noBoundsCheck,        /// Disable all bounds checking (-noboundscheck)
	optimize,             /// Enable optimizations (-O)
	profile,              /// Emit profiling code (-profile)
	unittests,            /// Compile unit tests (-unittest)
	verbose,              /// Verbose compiler output (-v)
	ignoreUnknownPragmas, /// Ignores unknown pragmas during compilation (-ignore)
	syntaxOnly,           /// Don't generate object files (-o-)
	warnings,             /// Enable warnings (-wi)
	warningsAsErrors,     /// Treat warnings as errors (-w)
	ignoreDeprecations,   /// Do not warn about using deprecated features (-d)
	deprecationWarnings,  /// Warn about using deprecated features (-dw)
	deprecationErrors,    /// Stop compilation upon usage of deprecated features (-de)
	property,             /// DEPRECATED: Enforce property syntax (-property)
	profileGC,            /// Profile runtime allocations
	pic,                  /// Generate position independent code
	betterC,              /// Compile in betterC mode (-betterC)
	lowmem,               /// Compile in lowmem mode (-lowmem)
}

Spec[Name] makeSpecs(bool echo)
{
    typeof(return) specs;
    {
        const name = "vox";
        Spec spec =
        { homePage : URL("https://github.com/MrSmith33/"~name~"/"),
          name : Name(name),
          repo : URL("https://github.com/MrSmith33/"~name~".git"),
          compiler : ExePath("ldc2"),
          versionNames : ["cli"],
          sourceFilePaths : [Path("main.d")],
          outFilePath : Path(name~".out"),
        };
        specs[spec.name] = spec;
    }
    {
        const name = "dmd";
        Spec spec =
        { homePage : URL("http://dlang.org/"),
          name : Name(name),
          repo : URL("https://github.com/dlang/"~name~".git"),
          // nordlow/selective-unittest-2
          // nordlow/check-self-assign
          // nordlow/check-unused
          extraRemoteSpecs : [RemoteSpec(URL("https://github.com/nordlow/dmd.git"), "nordlow",
                                         ["relax-alias-assign",
                                          "traits-isarray-take2",
                                          "diagnose-padding",
                                          "aliasseq-bench",
                                          "add-traits-hasAliasing",
                                          "unique-qualifier"]),
                              // RemoteSpec(URL("https://github.com/UplinkCoder/dmd.git"), "skoch", ["newCTFE_upstream"]),
          ],
          // patches : [Patch(Path("new-ctfe.patch"), 1, echo)],
          buildFlagsDefault : ["PIC=1"],
          buildFlagsByBO : [BuildOption.debugMode : ["ENABLE_DEBUG=1"],
                            BuildOption.releaseMode : ["ENABLE_RELASE=1"]],
        };
        specs[spec.name] = spec;
    }
    {
        const name = "druntime";
        Spec spec =
        { homePage : URL("http://dlang.org/"),
          name : Name(name),
          repo : URL("https://github.com/dlang/"~name~".git"),
        };
        specs[spec.name] = spec;
    }
    {
        const name = "phobos";
        Spec spec =
        { homePage : URL("http://dlang.org/"),
          name : Name(name),
          repo : URL("https://github.com/dlang/"~name~".git"),
          extraRemoteSpecs : [RemoteSpec(URL("https://github.com/nordlow/phobos.git"), "nordlow", ["faster-formatValue"])],
        };
        specs[spec.name] = spec;
    }
    {
        const name = "dub";
        Spec spec =
        { homePage : URL("http://dlang.org/"),
          name : Name(name),
          repo : URL("https://github.com/dlang/"~name~".git"),
        };
        specs[spec.name] = spec;
    }
    {
        const name = "DustMite";
        Spec spec =
        { homePage : URL("https://github.com/CyberShadow/"~name~"/wiki"),
          name : Name(name),
          compiler : ExePath("ldmd2"),
          sources : ["dustmite.d", "polyhash.d", "splitter.d"],
          repo : URL("https://github.com/CyberShadow/"~name~".git"),
        };
        specs[spec.name] = spec;
    }
    {
        const name = "DCD";
        Spec spec =
        { name : Name(name),
          repo : URL("https://github.com/dlang-community/"~name~".git"),
          buildFlagsDefault : ["ldc"],
          buildFlagsByBO : [BuildOption.debugMode : ["debug"],
                            BuildOption.releaseMode : ["ldc"]],
        };
        specs[spec.name] = spec;
    }
    {
        const name = "mold";
        Spec spec =
        { name : Name(name),
          repo : URL("https://github.com/rui314/"~name~".git"),
        };
        specs[spec.name] = spec;
    }
    return specs;
}

/** Launch/Execution specification.
 */
@safe struct Spec
{
    URL homePage;
    Name name;

    // Git sources
    URL repo;
    string remote = "origin";
    string branch;
    RemoteSpec[] extraRemoteSpecs;
    Patch[] patches;

    ExePath compiler;
    string[] sources;
    string[] buildFlagsDefault;
    string[][BuildOption] buildFlagsByBO;
    DlangVersionName[] versionNames;
    Path[] sourceFilePaths;
    Path outFilePath;
    uint jobCount;
    bool recurseSubModulesFlag = true;

    void go(scope ref const BuildOption[] bos, in bool echo) scope
    {
        const dlDirName = DirName(".cache/archives");
        const dlDir = DirPath(("~/" ~ dlDirName ~ "/").expandTilde.buildPath(name));
        writeln();
        fetch(bos, dlDir, echo);
        build(bos, dlDir, echo);
    }

    void fetch(scope ref const BuildOption[] bos, in DirPath dlDir, in bool echo) scope
    {
        import core.thread : Thread;
        import core.time : dur;
        auto repo = Repository(repo, dlDir, echo);
        // TODO: use waitAllInSequence();
        enforce(!repo.cloneOrRefresh(recurseSubModulesFlag, remote, branch).wait());
        enforce(!repo.clean().wait());
        string[] remoteNames;
        foreach (const spec; extraRemoteSpecs)
        {
            remoteNames ~= spec.remoteName;
            const statusIgnored = repo.remoteRemove(spec.remoteName).wait(); // ok if already removed
            enforce(!repo.remoteAdd(spec.url, spec.remoteName).wait());
        }
        enforce(!repo.fetch(remoteNames).wait());
        foreach (const spec; extraRemoteSpecs)
            foreach (const branch; spec.repoBranches)
                enforce(!repo.merge([spec.remoteName~"/"~branch], ["--no-edit", "-Xignore-all-space"]).wait());
        foreach (ref patch; patches)
            enforce(!patch.applyIn(dlDir).wait());
    }

    string[] bosFlags(scope ref const BuildOption[] bos) const scope pure nothrow
    {
        typeof(return) result;
        foreach (bo; bos)
            result ~= buildFlagsByBO[bo];
        return result;
    }

    string[] allBuildFlags(scope ref const BuildOption[] bos) const scope pure nothrow
    {
        return buildFlagsDefault ~ bosFlags(bos) ~ jobFlags() ~ sources;
    }

    void build(scope ref const BuildOption[] bos, in DirPath workDir, in bool echo) const scope
    {
        string[] args;
        Config config = Config.none;
        size_t maxOutput = size_t.max;

        chdir(workDir);         // TODO: replace with absolute paths in exists or dir.exists

        // TODO: when serveral of this exists ask user
        if (exists("Makefile"))
            args = ["make", "-f", "Makefile"] ~ allBuildFlags(bos);
        else if (exists("makefile"))
            args = ["make", "-f", "makefile"] ~ allBuildFlags(bos);
        else if (exists("posix.mak"))
            args = ["make", "-f", "posix.mak"] ~ allBuildFlags(bos);
        else if (exists("dub.sdl") ||
                 exists("dub.json"))
            args = ["dub", "build"];
        else
        {
            args = [compiler];
            if (bos.canFind(BuildOption.releaseMode) &&
                (compiler[].canFind("ldc2") ||
                 compiler[].canFind("ldmd2")))
                args ~= dflagsLDCRelease; // TODO: make declarative
            foreach (const ver; versionNames)
                args ~= ("-d-version=" ~ ver);
            args ~= sources;
        }
        /* ${DC} -release -boundscheck=off dustmite.d splitter.d polyhash.d */
        /*       mkdir -p ${DMD_EXEC_PREFIX} */
        /* mv dustmite ${DMD_EXEC_PREFIX} */

        enforce(args.length, "Could not deduce build command");

        // TOOD: wrap in Spawn
        writeln("Building as `", args.joiner(" "), "` ...");
        string[string] env_;
        /* TODO: add a wrapper spawnProcess1 called by Patch.applyIn,
         * Repository.spawn and here that sets stdout, stderr based on bool
         * echo. */
        scope Pid pid = spawnProcess(args, env_, config, workDir);
        const status = pid.wait();
        if (status != 0)
            writeln("Compilation failed:\n");
        if (status != 0)
            writeln("Compilation successful:\n");
    }

    string[] jobFlags() const scope pure nothrow
    {
        return jobCount ? ["-j"~jobCount.to!string] : [];
    }
}

/// Relaxed variant of `mkdir`.
void mkdirRelaxed(in const(char)[] pathname)
{
    try
        mkdir(pathname);
    catch (FileException e) {}  // TODO: avoid need for throwing
}

int[] waitAllInSequence(scope Pid[] pids...)
{
    typeof(return) statuses;
    foreach (pid; pids)
        statuses ~= pid.wait();
    return statuses;
}

int[] waitAllInParallel(scope Pid[] pids...)
{
    assert(0, "TODO: implement");
}