/**
Copyright: Copyright (c) 2020, Joakim Brännström. All rights reserved.
License: MPL-2
Author: Joakim Brännström (joakim.brannstrom@gmx.com)

This Source Code Form is subject to the terms of the Mozilla Public License,
v.2.0. If a copy of the MPL was not distributed with this file, You can obtain
one at http://mozilla.org/MPL/2.0/.

Common functionality used both by source and schemata testing of a mutant.
*/
module dextool.plugin.mutate.backend.test_mutant.common;

import logger = std.experimental.logger;
import std.algorithm : map, filter;
import std.array : empty, array;
import std.datetime : Duration, dur;
import std.exception : collectException;
import std.path : buildPath;
import std.typecons : Flag, No;

import blob_model : Blob;
import my.named_type;
import my.set;
import proc : DrainElement;
import sumtype;

import dextool.plugin.mutate.backend.interface_;
import dextool.plugin.mutate.backend.test_mutant.test_case_analyze : GatherTestCase;
import dextool.plugin.mutate.backend.test_mutant.test_cmd_runner;
import dextool.plugin.mutate.config;
import dextool.plugin.mutate.type : TestCaseAnalyzeBuiltin, ShellCommand;
import dextool.type : AbsolutePath, Path;

public import dextool.plugin.mutate.backend.type : Mutation, TestCase,
    ExitStatus, MutantTimeProfile;

version (unittest) {
    import unit_threaded.assertions;
}

@safe:

/// The result of running the test suite on one mutant.
struct MutationTestResult {
    import dextool.plugin.mutate.backend.database : MutationStatusId;
    import dextool.plugin.mutate.backend.type : Mutation, TestCase, ExitStatus;

    MutationStatusId id;
    Mutation.Status status;
    MutantTimeProfile profile;
    TestCase[] testCases;
    ExitStatus exitStatus;

    /// commands that had an exit status other than zero.
    ShellCommand[] testCmds;
}

/** Analyze stdout/stderr output from a test suite for test cases that failed
 * (killed) a mutant, which test cases that exists and if any of them are
 * unstable.
 */
struct TestCaseAnalyzer {
    private {
        ShellCommand[] externalAnalysers;
        TestCaseAnalyzeBuiltin[] builtins;
        AutoCleanup cleanup;
    }

    static struct Success {
        TestCase[] failed;
        TestCase[] testCmd;
        TestCase[] found;
    }

    static struct Unstable {
        TestCase[] unstable;
        TestCase[] found;
    }

    static struct Failed {
    }

    alias Result = SumType!(Success, Unstable, Failed);

    this(TestCaseAnalyzeBuiltin[] builtins, ShellCommand[] externalAnalyzers, AutoCleanup cleanup) {
        this.externalAnalysers = externalAnalyzers;
        this.builtins = builtins;
        this.cleanup = cleanup;
    }

    Result analyze(ShellCommand testCmd, DrainElement[] data,
            Flag!"allFound" allFound = No.allFound) {
        import dextool.plugin.mutate.backend.test_mutant.test_case_analyze : GatherTestCase;

        GatherTestCase gather;

        // the post processer must succeeed for the data to be stored. It is
        // considered a major error that may corrupt existing data if it fails.
        bool success = true;

        if (!externalAnalysers.empty) {
            foreach (cmd; externalAnalysers) {
                success = success && externalProgram(cmd, data, gather, cleanup);
            }
        }
        if (!builtins.empty) {
            builtin(testCmd, data, builtins, gather);
        }

        if (!gather.unstable.empty) {
            return Result(Unstable(gather.unstable.toArray, allFound ? gather.found.toArray : null));
        }

        if (success) {
            return Result(Success(gather.failed.toArray,
                    gather.testCmd.toArray, allFound ? gather.found.toArray : null));
        }

        return Result(Failed.init);
    }

    /// Returns: true if there are no analyzers setup.
    bool empty() @safe pure nothrow const @nogc {
        return externalAnalysers.empty && builtins.empty;
    }
}

/** Analyze the output from the test suite with one of the builtin analyzers.
 */
void builtin(ShellCommand cmd, DrainElement[] output,
        const(TestCaseAnalyzeBuiltin)[] tc_analyze_builtin, ref GatherTestCase app) @safe nothrow {
    import dextool.plugin.mutate.backend.test_mutant.ctest_post_analyze;
    import dextool.plugin.mutate.backend.test_mutant.gtest_post_analyze;
    import dextool.plugin.mutate.backend.test_mutant.makefile_post_analyze;

    GtestParser gtest;
    CtestParser ctest;
    MakefileParser makefile;

    void analyzeLine(const(char)[] line) {
        // this is a magic number that felt good. Why would there be a line in a test case log that is longer than this?
        immutable magic_nr = 2048;
        if (line.length > magic_nr) {
            // The byLine split may fail and thus result in one huge line.
            // The result of this is that regex's that use backtracking become really slow.
            // By skipping these lines dextool at list doesn't hang.
            logger.warningf("Line in test case log is too long to analyze (%s > %s). Skipping...",
                    line.length, magic_nr);
            return;
        }

        foreach (const p; tc_analyze_builtin) {
            final switch (p) {
            case TestCaseAnalyzeBuiltin.gtest:
                gtest.process(line, app);
                break;
            case TestCaseAnalyzeBuiltin.ctest:
                ctest.process(line, app);
                break;
            case TestCaseAnalyzeBuiltin.makefile:
                makefile.process(line, app);
                break;
            case TestCaseAnalyzeBuiltin.test_cmd:
                break;
            }
        }
    }

    foreach (l; LineRange(output)) {
        try {
            analyzeLine(l);
        } catch (Exception e) {
            logger.warning("A error encountered when trying to analyze the output from the test suite. Ignoring the offending line.")
                .collectException;
            logger.warning(e.msg).collectException;
        }
    }

    foreach (const p; tc_analyze_builtin) {
        final switch (p) {
        case TestCaseAnalyzeBuiltin.gtest:
            gtest.finalize(app);
            break;
        case TestCaseAnalyzeBuiltin.ctest:
            break;
        case TestCaseAnalyzeBuiltin.makefile:
            break;
        case TestCaseAnalyzeBuiltin.test_cmd:
            app.reportTestCmd(TestCase(cmd.toShortString));
            break;
        }
    }
}

struct LineRange {
    DrainElement[] elems;
    const(char)[] buf;
    const(char)[] line;

    const(char)[] front() @safe pure nothrow {
        assert(!empty, "Can't get front of an empty range");
        return line;
    }

    void popFront() @safe nothrow {
        assert(!empty, "Can't pop front of an empty range");
        import std.algorithm : countUntil;

        static auto nextLine(ref const(char)[] buf) @safe nothrow {
            const(char)[] line;

            try {
                const idx = buf.countUntil('\n');
                if (idx != -1) {
                    line = buf[0 .. idx];
                    if (idx < buf.length) {
                        buf = buf[idx + 1 .. $];
                    } else {
                        buf = null;
                    }
                }
            } catch (Exception e) {
                logger.warning(e.msg).collectException;
                logger.warning("Unable to parse the buffered data for a newline. Ignoring the rest.")
                    .collectException;
                buf = null;
            }

            return line;
        }

        line = null;
        while (!elems.empty && line.empty) {
            try {
                auto tmp = elems[0].byUTF8.array;
                buf ~= tmp;
            } catch (Exception e) {
                logger.warning(e.msg).collectException;
                logger.warning(
                        "A error encountered when trying to parse the output as UTF-8. Ignoring the offending data.")
                    .collectException;
            }
            elems = elems[1 .. $];
            line = nextLine(buf);
        }

        const s = buf.length;
        // there are data in the buffer that may contain lines
        if (elems.empty && !buf.empty && line.empty) {
            line = nextLine(buf);
        }

        // the last data in the buffer. This is a special case if an
        // application write data but do not end the last block of data with a
        // newline.
        // `s == buf.length` handles the case wherein there is an empty line.
        if (elems.empty && !buf.empty && line.empty && (s == buf.length)) {
            line = buf;
            buf = null;
        }
    }

    bool empty() @safe pure nothrow const @nogc {
        return elems.empty && buf.empty && line.empty;
    }
}

@("shall end the parsing of DrainElements even if the last is missing a newline")
unittest {
    import std.algorithm : copy;
    import std.array : appender;

    auto app = appender!(DrainElement[])();
    ["foo", "bar\n", "smurf"].map!(a => DrainElement(DrainElement.Type.stdout,
            cast(const(ubyte)[]) a)).copy(app);

    auto r = LineRange(app.data);

    r.empty.shouldBeFalse;
    r.popFront;
    r.front.shouldEqual("foobar");

    r.empty.shouldBeFalse;
    r.popFront;
    r.front.shouldEqual("smurf");

    r.empty.shouldBeFalse;
    r.popFront;
    r.empty.shouldBeTrue;
}

/** Run an external program that analyze the output from the test suite for
 * test cases that failed.
 *
 * Params:
 * cmd = user analyze command to execute on the output
 * output = output from the test command to be passed on to the analyze command
 * report = the result is stored in the report
 *
 * Returns: True if it successfully analyzed the output
 */
bool externalProgram(ShellCommand cmd, DrainElement[] output,
        ref GatherTestCase report, AutoCleanup cleanup) @safe nothrow {
    import std.datetime : dur;
    import std.algorithm : copy;
    import std.ascii : newline;
    import std.string : strip, startsWith;
    import proc;

    immutable passed = "passed:";
    immutable failed = "failed:";
    immutable unstable = "unstable:";

    auto tmpdir = createTmpDir();
    if (tmpdir.empty) {
        return false;
    }

    ShellCommand writeOutput(ShellCommand cmd) @safe {
        import std.stdio : File;

        const stdoutPath = buildPath(tmpdir, "stdout.log");
        const stderrPath = buildPath(tmpdir, "stderr.log");
        auto stdout = File(stdoutPath, "w");
        auto stderr = File(stderrPath, "w");

        foreach (a; output) {
            final switch (a.type) {
            case DrainElement.Type.stdout:
                stdout.rawWrite(a.data);
                break;
            case DrainElement.Type.stderr:
                stderr.rawWrite(a.data);
                break;
            }
        }

        cmd.value ~= [stdoutPath, stderrPath];
        return cmd;
    }

    try {
        cleanup.add(tmpdir.Path.AbsolutePath);
        cmd = writeOutput(cmd);
        auto p = pipeProcess(cmd.value).sandbox.rcKill;
        foreach (l; p.process.drainByLineCopy().map!(a => a.strip)
                .filter!(a => !a.empty)) {
            if (l.startsWith(passed))
                report.reportFound(TestCase(l[passed.length .. $].strip.idup));
            else if (l.startsWith(failed))
                report.reportFailed(TestCase(l[failed.length .. $].strip.idup));
            else if (l.startsWith(unstable))
                report.reportUnstable(TestCase(l[unstable.length .. $].strip.idup));
        }

        if (p.wait == 0) {
            return true;
        }

        logger.warningf("Failed to analyze the test case output with command '%-(%s %)'", cmd);
    } catch (Exception e) {
        logger.warning(e.msg).collectException;
    }

    return false;
}

/// Returns: path to a tmp directory or null on failure.
string createTmpDir() @safe nothrow {
    import std.random : uniform;
    import std.format : format;
    import std.file : mkdir;

    string test_tmp_output;

    // try 5 times or bailout
    foreach (const _; 0 .. 5) {
        try {
            auto tmp = format!"dextool_tmp_id_%s"(uniform!ulong);
            mkdir(tmp);
            test_tmp_output = AbsolutePath(Path(tmp));
            break;
        } catch (Exception e) {
            logger.warning(e.msg).collectException;
        }
    }

    if (test_tmp_output.length == 0) {
        logger.warning("Unable to create a temporary directory to store stdout/stderr in")
            .collectException;
    }

    return test_tmp_output;
}

/** Paths stored will be removed automatically either when manually called or
 * goes out of scope.
 */
class AutoCleanup {
    private string[] remove_dirs;

    void add(AbsolutePath p) @safe nothrow {
        remove_dirs ~= cast(string) p;
    }

    // trusted: the paths are forced to be valid paths.
    void cleanup() @trusted nothrow {
        import std.file : rmdirRecurse, exists;

        foreach (ref p; remove_dirs.filter!(a => !a.empty)) {
            try {
                if (exists(p))
                    rmdirRecurse(p);
                if (!exists(p))
                    p = null;
            } catch (Exception e) {
                logger.info(e.msg).collectException;
            }
        }

        remove_dirs = remove_dirs.filter!(a => !a.empty).array;
    }
}

alias CompileResult = SumType!(Mutation.Status, bool);
alias PrintCompileOnFailure = NamedType!(bool, Tag!"CompileActionOnFailure",
        bool.init, TagStringable, ImplicitConvertable);

CompileResult compile(ShellCommand cmd, Duration timeout, PrintCompileOnFailure printOnFailure) @trusted nothrow {
    import proc;
    import std.datetime : Clock;
    import std.stdio : write, writeln;

    if (cmd.value.empty)
        return CompileResult(false);

    const auto started = Clock.currTime;
    // every minute print something to indicate that the process is still
    // alive. Otherwise e.g. Jenkins may determine that it is dead.
    auto nextTick = Clock.currTime + 1.dur!"minutes";
    void tick() {
        const now = Clock.currTime;
        if (now > nextTick) {
            nextTick = now + 1.dur!"minutes";
            writeln("compiling... ", now - started);
        }
    }

    int runCompilation(bool print) {
        auto p = () {
            if (cmd.value.length == 1) {
                return pipeShell(cmd.value[0]).sandbox.timeout(timeout).rcKill;
            }
            return pipeProcess(cmd.value).sandbox.timeout(timeout).rcKill;
        }();

        foreach (a; p.process.drain) {
            if (!a.empty && print) {
                write(a.byUTF8);
            } else if (!print) {
                tick();
            }
        }

        return p.wait;
    }

    try {
        auto exitStatus = runCompilation(false);
        if (exitStatus != 0 && printOnFailure)
            exitStatus = runCompilation(true);

        if (exitStatus != 0)
            return CompileResult(Mutation.Status.killedByCompiler);
    } catch (Exception e) {
        logger.warning("Unknown error when executing the build command").collectException;
        logger.warning(cmd.value).collectException;
        logger.warning(e.msg).collectException;
        return CompileResult(Mutation.Status.unknown);
    }

    return CompileResult(true);
}

struct TestResult {
    Mutation.Status status;
    ExitStatus exitStatus;
    DrainElement[][ShellCommand] output;
}

/** Run the test suite to verify a mutation.
 *
 * Returns: the result of testing the mutant.
 */
TestResult runTester(Args...)(ref TestRunner runner, auto ref Args args) nothrow {
    import proc;

    TestResult rval;
    try {
        auto res = runner.run(args);
        rval.output = res.output;
        rval.exitStatus = res.exitStatus;

        final switch (res.status) with (
            dextool.plugin.mutate.backend.test_mutant.test_cmd_runner.TestResult.Status) {
        case passed:
            rval.status = Mutation.Status.alive;
            break;
        case failed:
            rval.status = Mutation.Status.killed;
            break;
        case timeout:
            rval.status = Mutation.Status.timeout;
            break;
        case memOverload:
            rval.status = Mutation.Status.memOverload;
            break;
        case error:
            rval.status = Mutation.Status.unknown;
            break;
        }
    } catch (Exception e) {
        // unable to for example execute the test suite
        logger.warning(e.msg).collectException;
        rval.status = Mutation.Status.unknown;
    }

    return rval;
}

void restoreFiles(AbsolutePath[] files, FilesysIO fio) {
    foreach (a; files) {
        fio.makeOutput(a).write(fio.makeInput(a));
    }
}

/// The conditions for when to stop mutation testing.
/// Intended to be re-used by both the main FSM and the sub-FSMs.
struct TestStopCheck {
    import std.format : format;
    import std.datetime.systime : Clock, SysTime;
    import my.optional;
    import dextool.plugin.mutate.config : ConfigMutationTest;

    enum HaltReason {
        none,
        maxRuntime,
        aliveTested,
        overloaded,
    }

    private {
        typeof(ConfigMutationTest.loadBehavior) loadBehavior;
        typeof(ConfigMutationTest.loadThreshold) baseLoadThreshold;
        typeof(ConfigMutationTest.loadThreshold) loadThreshold;

        Optional!int maxAlive;

        /// Max time to run the mutation testing for.
        SysTime stopAt;
        Duration maxRuntime;

        long aliveMutants_;
    }

    this(ConfigMutationTest conf) {
        loadBehavior = conf.loadBehavior;
        loadThreshold = conf.loadThreshold;
        baseLoadThreshold = conf.loadThreshold;
        if (!conf.maxAlive.isNull)
            maxAlive = some(conf.maxAlive.get);
        stopAt = Clock.currTime + conf.maxRuntime;
        maxRuntime = conf.maxRuntime;
    }

    void incrAliveMutants(int number = 1) @safe pure nothrow @nogc {
        aliveMutants_ += number;
    }

    long aliveMutants() @safe pure nothrow const @nogc {
        return aliveMutants_;
    }

    /// A halt conditions has occured. Mutation testing should stop.
    HaltReason isHalt() @safe nothrow {
        if (isMaxRuntime)
            return HaltReason.maxRuntime;

        if (isAliveTested)
            return HaltReason.aliveTested;

        if (loadBehavior == ConfigMutationTest.LoadBehavior.halt && load15 > baseLoadThreshold.get)
            return HaltReason.overloaded;

        return HaltReason.none;
    }

    /// The system is overloaded and the user has configured the tool to slowdown.
    bool isOverloaded() @safe nothrow const @nogc {
        if (loadBehavior == ConfigMutationTest.LoadBehavior.slowdown && load15 > loadThreshold.get)
            return true;

        return false;
    }

    bool isAliveTested() @safe pure nothrow @nogc {
        return maxAlive.hasValue && aliveMutants_ >= maxAlive.orElse(0);
    }

    bool isMaxRuntime() @safe nothrow const {
        return Clock.currTime > stopAt;
    }

    private double[3] load() nothrow const @nogc @trusted {
        import my.libc : getloadavg;

        double[3] load;
        const nr = getloadavg(&load[0], 3);
        if (nr <= 0 || nr > load.length) {
            return [0.0, 0.0, 0.0];
        }
        return load;
    };

    private double load1() @safe nothrow const @nogc {
        return load[0];
    }

    private double load15() @safe nothrow const @nogc {
        return load[2];
    }

    /// Pause the current thread by sleeping.
    void pause(Duration sleepFor = 30.dur!"seconds") @trusted nothrow {
        import core.thread : Thread;
        import std.algorithm : max;

        logger.infof("Sleeping %s", sleepFor).collectException;
        Thread.sleep(sleepFor);

        // make it more sensitive if the system is still overloaded.
        if (load1 > loadThreshold.get)
            loadThreshold.get = max(1, baseLoadThreshold.get - 1);
        else
            loadThreshold = baseLoadThreshold;
    }

    /// Start a background thread that will forcefully terminate the application.
    void startBgShutdown(Duration waitFor = 10.dur!"minutes") @trusted nothrow {
        import std.concurrency : spawnLinked, receiveTimeout, LinkTerminated, OwnerTerminated;

        static void tick(Duration waitFor) @trusted nothrow {
            import core.stdc.stdlib : exit;

            const stopAt = Clock.currTime + waitFor;
            bool parentAlive = true;

            while (parentAlive && Clock.currTime < stopAt) {
                try {
                    receiveTimeout(10.dur!"seconds", (int) {});
                } catch (LinkTerminated) {
                    parentAlive = false;
                } catch (OwnerTerminated) {
                    // owner terminated thus assuming the program is progressing to a clean shutdown.
                    return;
                } catch (Exception e) {
                }
            }

            logger.info("Force shutdown").collectException;
            // note: the below assumption may not be correct because if the
            // shutdown triggers before files on disc have been restored then
            // well. It isn't a severe problem as long as the user always setup
            // the source code from scratch/cleanly when starting.
            //
            // it is not really a failure just, a workaround if other parts
            // lockup such as a thread pool. it happens sometimes.
            exit(0);
        }

        spawnLinked(&tick, waitFor).collectException;
    }

    string overloadToString() @safe const {
        return format!"Detected overload (%s > %s)"(load15, loadThreshold.get);
    }

    string maxRuntimeToString() @safe const {
        return format!"Max runtime of %s reached at %s"(maxRuntime, Clock.currTime);
    }
}

struct HashFile {
    import my.hash : Checksum64;

    Checksum64 cs;
    Path file;
}

auto hashFiles(RangeT)(RangeT files) nothrow {
    import my.hash : makeCrc64Iso, checksum;
    import my.file : existsAnd, isFile;

    return files.filter!(a => existsAnd!isFile(Path(a)))
        .map!((a) {
            auto p = AbsolutePath(a);
            auto cs = checksum!makeCrc64Iso(p);
            return HashFile(cs, Path(a));
        });
}

/// A runtime database of the current status of the test binaries and their checksum.
struct TestBinaryDb {
    import my.hash : Checksum64;
    import my.set : Set;

    Set!Checksum64 original;
    Mutation.Status[Checksum64] mutated;

    // last added
    Mutation.Status[Checksum64] added;

    void add(Checksum64 cs, Mutation.Status status) @safe pure nothrow {
        added[cs] = status;
        mutated[cs] = status;
    }

    void clearAdded() @safe pure nothrow @nogc {
        added = null;
    }

    bool empty() @safe pure nothrow const @nogc {
        return original.empty && mutated.empty;
    }
}