/**
This module implements a $(LINK2 http://dlang.org/template-mixin.html,
template mixin) containing a program to search a list of directories
for all .d files therein, then writes a D program to run all unit
tests in those files using unit_threaded. The program
implemented by this mixin only writes out a D file that itself must be
compiled and run.

To use this as a runnable program, simply mix in and compile:
-----
#!/usr/bin/rdmd
import unit_threaded;
mixin genUtMain;
-----

Generally however, this code will be used by the gen_ut_main
dub configuration via `dub run`.

By default, genUtMain will look for unit tests in CWD
and write a program out to a temporary file. To change
the file to write to, use the $(D -f) option. To change what
directories to look in, simply pass them in as the remaining
command-line arguments.

The resulting file is also a program that must be compiled and, when
run, will run the unit tests found. By default, it will run all
tests. To run one test or all tests in a particular package, pass them
in as command-line arguments.  The $(D -h) option will list all
command-line options.

Examples (assuming the generated file is called $(D ut.d)):
-----
rdmd -unittest ut.d # run all tests
rdmd -unittest ut.d tests.foo tests.bar # run all tests from these packages
rdmd ut.d -h # list command-line options
-----
*/

module unit_threaded.runtime;

import unit_threaded.from;


mixin template genUtMain() {

    int main(string[] args) {
        try {
            writeUtMainFile(args);
            return 0;
        } catch(Exception ex) {
            import std.stdio: stderr;
            stderr.writeln(ex.msg);
            return 1;
        }
    }
}


struct Options {
    bool verbose;
    string fileName;
    string[] dirs;
    bool help;
    bool showVersion;
    string[] includes;
    string[] files;

    bool earlyReturn() @safe pure nothrow const {
        return help || showVersion;
    }
}


Options getGenUtOptions(string[] args) {
    import std.getopt;
    import std.stdio: writeln;

    Options options;
    auto getOptRes = getopt(
        args,
        "verbose|v", "Verbose mode.", &options.verbose,
        "file|f", "The filename to write. Will use a temporary if not set.", &options.fileName,
        "I", "Import paths as would be passed to the compiler", &options.includes,
        "version", "Show version.", &options.showVersion,
        );

    if (getOptRes.helpWanted) {
        defaultGetoptPrinter("Usage: gen_ut_main [options] [testDir1] [testDir2]...", getOptRes.options);
        options.help = true;
        return options;
    }

    if (options.showVersion) {
        writeln("unit_threaded.runtime version v0.6.1");
        return options;
    }

    options.dirs = args.length <= 1 ? ["."] : args[1 .. $];

    if (options.verbose) {
        writeln(__FILE__, ": finding all test cases in ", options.dirs);
    }

    return options;
}


from!"std.file".DirEntry[] findModuleEntries(in Options options) {

    import std.algorithm: splitter, canFind, map, startsWith, filter;
    import std.array: array, empty;
    import std.file: DirEntry, isDir, dirEntries, SpanMode;
    import std.path: dirSeparator, buildNormalizedPath;
    import std.exception: enforce;

    // dub list of files, don't bother reading the filesystem since
    // dub has done it already
    if(!options.files.empty && options.dirs == ["."]) {
        return dubFilesToAbsPaths(options.fileName, options.files)
            .map!toDirEntry
            .array;
    }

    DirEntry[] modules;
    foreach (dir; options.dirs) {
        enforce(isDir(dir), dir ~ " is not a directory name");
        auto entries = dirEntries(dir, "*.d", SpanMode.depth);
        auto normalised = entries.map!(a => buildNormalizedPath(a.name));

        bool isHiddenDir(string p) { return p.startsWith("."); }
        bool anyHiddenDir(string p) { return p.splitter(dirSeparator).canFind!isHiddenDir; }

        modules ~= normalised.
            filter!(a => !anyHiddenDir(a)).
            map!toDirEntry.array;
    }

    return modules;
}

auto toDirEntry(string a) {
    import std.file: DirEntry;
    return DirEntry(removePackage(a));
}

// package.d files will show up as foo.bar.package
// remove .package from the end
string removePackage(string name) {
    import std.algorithm: endsWith;
    import std.array: replace;
    enum toRemove = "/package.d";
    return name.endsWith(toRemove)
        ? name.replace(toRemove, "")
        : name;
}


private string[] dubFilesToAbsPaths(in string fileName, in string[] files) {
    import std.algorithm: filter, map;
    import std.array: array;
    import std.path: buildNormalizedPath;

    // dub list of files, don't bother reading the filesystem since
    // dub has done it already
    return files
        .filter!(a => a != fileName)
        .map!(a => removePackage(a))
        .map!(a => buildNormalizedPath(a))
        .array;
}

@("issue 40")
unittest {
    import unit_threaded.should;
    import std.path;
    dubFilesToAbsPaths("", ["foo/bar/package.d"]).shouldEqual(
        [buildPath("foo", "bar")]);
}


string[] findModuleNames(in Options options) {
    import std.path : dirSeparator, stripExtension, absolutePath, relativePath;
    import std.algorithm: endsWith, startsWith, filter, map;
    import std.array: replace, array;
    import std.path: baseName, absolutePath;

    // if a user passes -Isrc and a file is called src/foo/bar.d,
    // the module name should be foo.bar, not src.foo.bar,
    // so this function subtracts import path options
    string relativeToImportDirs(string path) {
        foreach(string importPath; options.includes) {
            importPath = relativePath(importPath);
            if(!importPath.endsWith(dirSeparator)) importPath ~= dirSeparator;
            if(path.startsWith(importPath)) {
                return path.replace(importPath, "");
            }
        }

        return path;
    }

    return findModuleEntries(options).
        filter!(a => a.baseName != "reggaefile.d").
        filter!(a => a.absolutePath != options.fileName.absolutePath).
        map!(a => relativeToImportDirs(a.name)).
        map!(a => replace(a.stripExtension, dirSeparator, ".")).
        array;
}

string writeUtMainFile(string[] args) {
    auto options = getGenUtOptions(args);
    return writeUtMainFile(options);
}

string writeUtMainFile(Options options) {
    if (options.earlyReturn) {
        return options.fileName;
    }

    return writeUtMainFile(options, findModuleNames(options));
}

private string writeUtMainFile(Options options, in string[] modules) {
    import std.path: buildPath, dName = dirName;
    import std.stdio: writeln, File;
    import std.file: tempDir, getcwd, mkdirRecurse, exists;
    import std.algorithm: map;
    import std.array: join;

    if (!options.fileName) {
        options.fileName = buildPath(tempDir, getcwd[1..$], "ut.d");
    }

    if(!haveToUpdate(options, modules)) {
        if(options.verbose) writeln("Not writing to ", options.fileName, ": no changes detected");
        return options.fileName;
    } else {
        if(options.verbose) writeln("Writing to unit test main file ", options.fileName);
    }

    const dirName = options.fileName.dName;
    dirName.exists || mkdirRecurse(dirName);


    auto wfile = File(options.fileName, "w");
    wfile.write(modulesDbList(modules));
    wfile.writeln(q{
//Automatically generated by unit_threaded.gen_ut_main, do not edit by hand.
import unit_threaded;
});

    wfile.writeln("int main(string[] args)");
    wfile.writeln("{");

    immutable indent = "                          ";
    wfile.writeln("    return args.runTests!(\n" ~
                  modules.map!(a => indent ~ `"` ~ a ~ `"`).join(",\n") ~
                  "\n" ~ indent ~ ");");
    wfile.writeln("}");
    wfile.close();

    return options.fileName;
}


private bool haveToUpdate(in Options options, in string[] modules) {
    import std.file: exists;
    import std.stdio: File;
    import std.array: join;
    import std..string: strip;

    if (!options.fileName.exists) {
        return true;
    }

    auto file = File(options.fileName);
    return file.readln.strip != modulesDbList(modules);
}


//used to not update the file if the file list hasn't changed
private string modulesDbList(in string[] modules) @safe pure nothrow {
    import std.array: join;
    return "//" ~ modules.join(",");
}