/**
Copyright: Copyright (c) 2020, Joakim Brännström. All rights reserved.
License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0)
Author: Joakim Brännström (joakim.brannstrom@gmx.com)
*/
module my.filter;

import std.algorithm : filter;
import std.array : array, empty;
import logger = std.experimental.logger;

import my.optional;
import my.path;

@safe:

/** Filter strings by first cutting out regions (include) and then selectively
 * remove (exclude) from region.
 *
 * It assumes that if `include` is empty everything should match.
 *
 * I often use this in my programs to allow a user to specify what files to
 * process and have some control over what to exclude.
 *
 * `--re-include` and `--re-exclude` is a suggestion for parameters to use with
 * `getopt`.
 */
struct ReFilter {
    import std.regex : Regex, regex, matchFirst;

    Regex!char[] includeRe;
    Regex!char[] excludeRe;

    /**
     * The regular expressions are set to ignoring the case.
     *
     * Params:
     *  include = regular expression.
     *  exclude = regular expression.
     */
    this(string[] include, string[] exclude) {
        foreach (r; include)
            includeRe ~= regex(r, "i");
        foreach (r; exclude)
            excludeRe ~= regex(r, "i");
    }

    /**
     * Returns: true if `s` matches `ìncludeRe` and NOT matches any of `excludeRe`.
     */
    bool match(string s, void delegate(string s, string type) @safe logFailed = null) {
        const inclPassed = () {
            if (includeRe.empty)
                return true;
            foreach (ref re; includeRe) {
                if (!matchFirst(s, re).empty)
                    return true;
            }
            return false;
        }();
        if (!inclPassed) {
            if (logFailed !is null)
                logFailed(s, "include");
            return false;
        }

        foreach (ref re; excludeRe) {
            if (!matchFirst(s, re).empty) {
                if (logFailed !is null)
                    logFailed(s, "exclude");
                return false;
            }
        }

        return true;
    }
}

/// Example:
unittest {
    auto r = ReFilter(["foo.*"], [".*bar.*", ".*batman"]);
    assert(["foo", "foobar", "foo smurf batman", "batman", "fo",
            "foo mother"].filter!(a => r.match(a)).array == [
            "foo", "foo mother"
            ]);
}

@("shall match everything by default")
unittest {
    ReFilter r;
    assert(["foo", "foobar"].filter!(a => r.match(a)).array == ["foo", "foobar"]);
}

@("shall exclude the specified items")
unittest {
    auto r = ReFilter(null, [".*bar.*", ".*batman"]);
    assert(["foo", "foobar", "foo smurf batman", "batman", "fo",
            "foo mother"].filter!(a => r.match(a)).array == [
            "foo", "fo", "foo mother"
            ]);
}

/** Filter strings by first cutting out a region (include) and then selectively
 * remove (exclude) from that region.
 *
 * I often use this in my programs to allow a user to specify what files to
 * process and the have some control over what to exclude.
 */
struct GlobFilter {
    string[] include;
    string[] exclude;

    /**
     * The regular expressions are set to ignoring the case.
     *
     * Params:
     *  include = glob string patter
     *  exclude = glob string patterh
     */
    this(string[] include, string[] exclude) {
        this.include = include;
        this.exclude = exclude;
    }

    /**
     * Params:
     *  logFailed = called when `s` fails matching.
     *
     * Returns: true if `s` matches `ìncludeRe` and NOT matches any of `excludeRe`.
     */
    bool match(string s, void delegate(string s, string[] filters) @safe logFailed = null) {
        import std.algorithm : canFind;
        import std.path : globMatch;

        if (!include.empty && !canFind!((a, b) => globMatch(b, a))(include, s)) {
            if (logFailed !is null)
                logFailed(s, include);
            return false;
        }

        if (canFind!((a, b) => globMatch(b, a))(exclude, s)) {
            if (logFailed !is null)
                logFailed(s, exclude);
            return false;
        }

        return true;
    }
}

/// Example:
unittest {
    import std.algorithm : filter;
    import std.array : array;

    auto r = GlobFilter(["foo*"], ["*bar*", "*batman"]);

    assert(["foo", "foobar", "foo smurf batman", "batman", "fo",
            "foo mother"].filter!(a => r.match(a)).array == [
            "foo", "foo mother"
            ]);
}

@("shall not crash")
unittest {
    auto r = GlobFilter(["*"], ["bar/*"]);

    assert(["foo", "bar", "bar/foo", "bar batman",].filter!(a => r.match(a))
            .array == ["foo", "bar", "bar batman"]);
}

GlobFilter merge(GlobFilter a, GlobFilter b) {
    return GlobFilter(a.include ~ b.include, a.exclude ~ b.exclude);
}

@("shall merge two filters")
unittest {
    auto a = GlobFilter(["foo*"], ["*bar*", "*batman"]);
    auto b = GlobFilter(["fun*"], ["*fun*"]);
    auto c = merge(a, b);
    assert(c.include == ["foo*", "fun*"]);
    assert(c.exclude == ["*bar*", "*batman", "*fun*"]);
}

struct GlobFilterClosestMatch {
    GlobFilter filter;
    AbsolutePath base;

    bool match(string s, void delegate(string s, string[] filters) @safe logFailed = null) {
        import std.path : relativePath;

        return filter.match(s.relativePath(base.toString), logFailed);
    }
}

/** The closest matching filter.
 *
 * Use for example as:
 * ```
 * closest(filters, p).orElse(GlobFilterClosestMatch(defaultFilter, AbsolutePath("."))).match(p);
 * ```
 */
Optional!GlobFilterClosestMatch closest(GlobFilter[AbsolutePath] filters, AbsolutePath p) {
    import std.path : rootName;

    if (filters.empty)
        return typeof(return)(None.init);

    const root = p.toString.rootName;
    while (p != root) {
        p = p.dirName;
        if (auto v = p in filters)
            return some(GlobFilterClosestMatch(*v, p));
    }

    return typeof(return)(None.init);
}