/**
 * This module implements functionality helpful for writing integration tests
 * as opposed to the unit variety where unit-tests are defined as not
 * having global side-effects. In constrast, this module implements
 * assertions that check for global side-effects such as writing to the
 * file system.
 */

module unit_threaded.integration;

version(Windows) {
    extern(C) int mkdir(char*);
    extern(C) char* mktemp(char* template_);

    char* mkdtemp(char* t) {
        version(unitUnthreaded)
            return mkdtempImpl(t);
        else {
            synchronized {
                return mkdtempImpl(t);
            }
        }
    }

    char* mkdtempImpl(char* t) {
        char* result = mktemp(t);

        if(result is null) return null;
        if (mkdir(result)) return null;

        return result;
    }

} else {
    extern(C) char* mkdtemp(char* template_);
}


shared static this() {
    import std.file: exists, rmdirRecurse;

    if(Sandbox.sandboxesPath.exists)
        rmdirRecurse(Sandbox.sandboxesPath);
}


@safe:

/**
 Responsible for creating a temporary directory to serve as a sandbox where
 files can be created, written to or deleted.
 */
struct Sandbox {
    import std.path;

    enum defaultSandboxesPath = buildPath("tmp", "unit-threaded");
    static string sandboxesPath = defaultSandboxesPath;
    string testPath;

    /// Instantiate a Sandbox object
    static Sandbox opCall() {
        Sandbox ret;
        ret.testPath = newTestDir;
        return ret;
    }


    static void setPath(string path) {
        import std.file: exists, mkdirRecurse;
        sandboxesPath = path;
        if(!sandboxesPath.exists) () @trusted { mkdirRecurse(sandboxesPath); }();
    }


    static void resetPath() {
        sandboxesPath = defaultSandboxesPath;
    }

    /// Write a file to the sandbox
    void writeFile(in string fileName, in string output = "") const {
        import std.stdio: File;
        import std.path: buildPath, dirName;
        import std.file: mkdirRecurse;

        () @trusted { mkdirRecurse(buildPath(testPath, fileName.dirName)); }();
        File(buildPath(testPath, fileName), "w").writeln(output);
    }

    /// Write a file to the sanbox
    void writeFile(in string fileName, in string[] lines) const {
        import std.array;
        writeFile(fileName, lines.join("\n"));
    }


    /// Assert that a file exists in the sandbox
    void shouldExist(string fileName, in string file = __FILE__, in size_t line = __LINE__) const {
        import std.file: exists;
        import std.path: buildPath;
        import unit_threaded.should: fail;

        fileName = buildPath(testPath, fileName);
        if(!fileName.exists)
            fail("Expected " ~ fileName ~ " to exist but it didn't", file, line);
    }

    /// Assert that a file does not exist in the sandbox
    void shouldNotExist(string fileName, in string file = __FILE__, in size_t line = __LINE__) const {
        import std.file: exists;
        import std.path: buildPath;
        import unit_threaded.should: fail;

        fileName = buildPath(testPath, fileName);
        if(fileName.exists)
            fail("Expected " ~ fileName ~ " to not exist but it did", file, line);
    }

    /// read a file in the test sandbox and verify its contents
    void shouldEqualContent(in string fileName, in string content,
                            in string file = __FILE__, in size_t line = __LINE__)
        const
    {
        import std.file: readText;
        import std.string: chomp, splitLines;
        import unit_threaded.should: shouldEqual;

        readText(buildPath(testPath, fileName)).shouldEqual(content, file, line);
    }

    /// read a file in the test sandbox and verify its contents
    void shouldEqualLines(in string fileName, in string[] lines,
                          string file = __FILE__, size_t line = __LINE__)
        const
    {
        import std.file: readText;
        import std.string: chomp, splitLines;
        import unit_threaded.should: shouldEqual;

        readText(buildPath(testPath, fileName)).chomp.splitLines
            .shouldEqual(lines, file, line);
    }

    // `fileName` should contain `needle`
    void fileShouldContain(in string fileName,
                           in string needle,
                           in string file = __FILE__,
                           in size_t line = __LINE__)
    {
        import std.file: readText;
        import unit_threaded.should: shouldBeIn;
        needle.shouldBeIn(readText(inSandboxPath(fileName)), file, line);
    }

    string sandboxPath() @safe @nogc pure nothrow const {
        return testPath;
    }

    string inSandboxPath(in string fileName) @safe pure nothrow const {
        import std.path: buildPath;
        return buildPath(sandboxPath, fileName);
    }

    /**
       Executing `args` should succeed
     */
    void shouldSucceed(string file = __FILE__, size_t line = __LINE__)
                      (in string[] args...)
        @safe const
    {
        import unit_threaded.should: UnitTestException;
        import std.conv: text;
        import std.array: join;

        const res = executeInSandbox(args);
        if(res.status != 0)
           throw new UnitTestException(text("Could not execute `", args.join(" "), "`:\n", res.output),
                                       file, line);
    }

    alias shouldExecuteOk = shouldSucceed;

    /**
       Executing `args` should fail
     */
    void shouldFail(string file = __FILE__, size_t line = __LINE__)
                   (in string[] args...)
        @safe const
    {
        import unit_threaded.should: UnitTestException;
        import std.conv: text;
        import std.array: join;

        const res = executeInSandbox(args);
        if(res.status == 0)
            throw new UnitTestException(
                text("`", args.join(" "), "` should have failed but didn't:\n", res.output),
                file,
                line);
    }


private:

    auto executeInSandbox(in string[] args) @safe const {
        import std.process: execute, Config;
        import std.algorithm: startsWith;
        import std.array: replace;

        const string[string] env = null;
        const config = Config.none;
        const maxOutput = size_t.max;
        const workDir = testPath;

        const executable = args[0].startsWith("./")
            ? inSandboxPath(args[0].replace("./", ""))
            : args[0];

        return execute(executable ~ args[1..$], env, config, maxOutput, workDir);
    }

    static string newTestDir() {
        import std.file: exists, mkdirRecurse;

        if(!sandboxesPath.exists) {
            () @trusted { mkdirRecurse(sandboxesPath); }();
        }

        return makeTempDir();
    }

    static string makeTempDir() {
        import std.algorithm: copy;
        import std.exception: enforce;
        import std.conv: to;
        import std.string: fromStringz;
        import core.stdc.string: strerror;
        import core.stdc.errno: errno;

        char[2048] template_;
        copy(buildPath(sandboxesPath, "XXXXXX") ~ '\0', template_[]);

        auto path = () @trusted { return mkdtemp(&template_[0]).to!string; }();

        enforce(path != "",
                "\n" ~
                "Failed to create temporary directory name using template '" ~
                () @trusted { return fromStringz(&template_[0]); }() ~ "': " ~
                () @trusted { return strerror(errno).to!string; }());

        return path.absolutePath;
    }
}