/*
 * Copyright (C) the libgit2 contributors. All rights reserved.
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */
#include "git2/pathspec.h"
#include "git2/diff.h"
#include "pathspec.h"
#include "buf_text.h"
#include "attr_file.h"
#include "iterator.h"
#include "repository.h"
#include "index.h"
#include "bitvec.h"
#include "diff.h"
/* what is the common non-wildcard prefix for all items in the pathspec */
char *git_pathspec_prefix(const git_strarray *pathspec)
{
        git_buf prefix = GIT_BUF_INIT;
        const char *scan;
        if (!pathspec || !pathspec->count ||
                git_buf_text_common_prefix(&prefix, pathspec) < 0)
                return NULL;
        /* diff prefix will only be leading non-wildcards */
        for (scan = prefix.ptr; *scan; ++scan) {
                if (git__iswildcard(*scan) &&
                        (scan == prefix.ptr || (*(scan - 1) != '\\')))
                        break;
        }
        git_buf_truncate(&prefix, scan - prefix.ptr);
        if (prefix.size <= 0) {
                git_buf_free(&prefix);
                return NULL;
        }
        git_buf_text_unescape(&prefix);
        return git_buf_detach(&prefix);
}
/* is there anything in the spec that needs to be filtered on */
bool git_pathspec_is_empty(const git_strarray *pathspec)
{
        size_t i;
        if (pathspec == NULL)
                return true;
        for (i = 0; i < pathspec->count; ++i) {
                const char *str = pathspec->strings[i];
                if (str && str[0])
                        return false;
        }
        return true;
}
/* build a vector of fnmatch patterns to evaluate efficiently */
int git_pathspec__vinit(
        git_vector *vspec, const git_strarray *strspec, git_pool *strpool)
{
        size_t i;
        memset(vspec, 0, sizeof(*vspec));
        if (git_pathspec_is_empty(strspec))
                return 0;
        if (git_vector_init(vspec, strspec->count, NULL) < 0)
                return -1;
        for (i = 0; i < strspec->count; ++i) {
                int ret;
                const char *pattern = strspec->strings[i];
                git_attr_fnmatch *match = git__calloc(1, sizeof(git_attr_fnmatch));
                if (!match)
                        return -1;
                match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE |
                        GIT_ATTR_FNMATCH_ALLOWNEG | GIT_ATTR_FNMATCH_NOLEADINGDIR;
                ret = git_attr_fnmatch__parse(match, strpool, NULL, &pattern);
                if (ret == GIT_ENOTFOUND) {
                        git__free(match);
                        continue;
                } else if (ret < 0) {
                        git__free(match);
                        return ret;
                }
                if (git_vector_insert(vspec, match) < 0)
                        return -1;
        }
        return 0;
}
/* free data from the pathspec vector */
void git_pathspec__vfree(git_vector *vspec)
{
        git_vector_free_deep(vspec);
}
struct pathspec_match_context {
        int fnmatch_flags;
        int (*strcomp)(const char *, const char *);
        int (*strncomp)(const char *, const char *, size_t);
};
static void pathspec_match_context_init(
        struct pathspec_match_context *ctxt,
        bool disable_fnmatch,
        bool casefold)
{
        if (disable_fnmatch)
                ctxt->fnmatch_flags = -1;
        else if (casefold)
                ctxt->fnmatch_flags = FNM_CASEFOLD;
        else
                ctxt->fnmatch_flags = 0;
        if (casefold) {
                ctxt->strcomp  = git__strcasecmp;
                ctxt->strncomp = git__strncasecmp;
        } else {
                ctxt->strcomp  = git__strcmp;
                ctxt->strncomp = git__strncmp;
        }
}
static int pathspec_match_one(
        const git_attr_fnmatch *match,
        struct pathspec_match_context *ctxt,
        const char *path)
{
        int result = (match->flags & GIT_ATTR_FNMATCH_MATCH_ALL) ? 0 : FNM_NOMATCH;
        if (result == FNM_NOMATCH)
                result = ctxt->strcomp(match->pattern, path) ? FNM_NOMATCH : 0;
        if (ctxt->fnmatch_flags >= 0 && result == FNM_NOMATCH)
                result = p_fnmatch(match->pattern, path, ctxt->fnmatch_flags);
        /* if we didn't match, look for exact dirname prefix match */
        if (result == FNM_NOMATCH &&
                (match->flags & GIT_ATTR_FNMATCH_HASWILD) == 0 &&
                ctxt->strncomp(path, match->pattern, match->length) == 0 &&
                path[match->length] == '/')
                result = 0;
        /* if we didn't match and this is a negative match, check for exact
         * match of filename with leading '!'
         */
        if (result == FNM_NOMATCH &&
                (match->flags & GIT_ATTR_FNMATCH_NEGATIVE) != 0 &&
                *path == '!' &&
                ctxt->strncomp(path + 1, match->pattern, match->length) == 0 &&
                (!path[match->length + 1] || path[match->length + 1] == '/'))
                return 1;
        if (result == 0)
                return (match->flags & GIT_ATTR_FNMATCH_NEGATIVE) ? 0 : 1;
        return -1;
}
static int git_pathspec__match_at(
        size_t *matched_at,
        const git_vector *vspec,
        struct pathspec_match_context *ctxt,
        const char *path0,
        const char *path1)
{
        int result = GIT_ENOTFOUND;
        size_t i = 0;
        const git_attr_fnmatch *match;
        git_vector_foreach(vspec, i, match) {
                if (path0 && (result = pathspec_match_one(match, ctxt, path0)) >= 0)
                        break;
                if (path1 && (result = pathspec_match_one(match, ctxt, path1)) >= 0)
                        break;
        }
        *matched_at = i;
        return result;
}
/* match a path against the vectorized pathspec */
bool git_pathspec__match(
        const git_vector *vspec,
        const char *path,
        bool disable_fnmatch,
        bool casefold,
        const char **matched_pathspec,
        size_t *matched_at)
{
        int result;
        size_t pos;
        struct pathspec_match_context ctxt;
        if (matched_pathspec)
                *matched_pathspec = NULL;
        if (matched_at)
                *matched_at = GIT_PATHSPEC_NOMATCH;
        if (!vspec || !vspec->length)
                return true;
        pathspec_match_context_init(&ctxt, disable_fnmatch, casefold);
        result = git_pathspec__match_at(&pos, vspec, &ctxt, path, NULL);
        if (result >= 0) {
                if (matched_pathspec) {
                        const git_attr_fnmatch *match = git_vector_get(vspec, pos);
                        *matched_pathspec = match->pattern;
                }
                if (matched_at)
                        *matched_at = pos;
        }
        return (result > 0);
}
int git_pathspec__init(git_pathspec *ps, const git_strarray *paths)
{
        int error = 0;
        memset(ps, 0, sizeof(*ps));
        ps->prefix = git_pathspec_prefix(paths);
        git_pool_init(&ps->pool, 1);
        if ((error = git_pathspec__vinit(&ps->pathspec, paths, &ps->pool)) < 0)
                git_pathspec__clear(ps);
        return error;
}
void git_pathspec__clear(git_pathspec *ps)
{
        git__free(ps->prefix);
        git_pathspec__vfree(&ps->pathspec);
        git_pool_clear(&ps->pool);
        memset(ps, 0, sizeof(*ps));
}
int git_pathspec_new(git_pathspec **out, const git_strarray *pathspec)
{
        int error = 0;
        git_pathspec *ps = git__malloc(sizeof(git_pathspec));
        GITERR_CHECK_ALLOC(ps);
        if ((error = git_pathspec__init(ps, pathspec)) < 0) {
                git__free(ps);
                return error;
        }
        GIT_REFCOUNT_INC(ps);
        *out = ps;
        return 0;
}
static void pathspec_free(git_pathspec *ps)
{
        git_pathspec__clear(ps);
        git__free(ps);
}
void git_pathspec_free(git_pathspec *ps)
{
        if (!ps)
                return;
        GIT_REFCOUNT_DEC(ps, pathspec_free);
}
int git_pathspec_matches_path(
        const git_pathspec *ps, uint32_t flags, const char *path)
{
        bool no_fnmatch = (flags & GIT_PATHSPEC_NO_GLOB) != 0;
        bool casefold =  (flags & GIT_PATHSPEC_IGNORE_CASE) != 0;
        assert(ps && path);
        return (0 != git_pathspec__match(
                &ps->pathspec, path, no_fnmatch, casefold, NULL, NULL));
}
static void pathspec_match_free(git_pathspec_match_list *m)
{
        if (!m)
                return;
        git_pathspec_free(m->pathspec);
        m->pathspec = NULL;
        git_array_clear(m->matches);
        git_array_clear(m->failures);
        git_pool_clear(&m->pool);
        git__free(m);
}
static git_pathspec_match_list *pathspec_match_alloc(
        git_pathspec *ps, int datatype)
{
        git_pathspec_match_list *m = git__calloc(1, sizeof(git_pathspec_match_list));
        if (!m)
                return NULL;
        git_pool_init(&m->pool, 1);
        /* need to keep reference to pathspec and increment refcount because
         * failures array stores pointers to the pattern strings of the
         * pathspec that had no matches
         */
        GIT_REFCOUNT_INC(ps);
        m->pathspec = ps;
        m->datatype = datatype;
        return m;
}
GIT_INLINE(size_t) pathspec_mark_pattern(git_bitvec *used, size_t pos)
{
        if (!git_bitvec_get(used, pos)) {
                git_bitvec_set(used, pos, true);
                return 1;
        }
        return 0;
}
static size_t pathspec_mark_remaining(
        git_bitvec *used,
        git_vector *patterns,
        struct pathspec_match_context *ctxt,
        size_t start,
        const char *path0,
        const char *path1)
{
        size_t count = 0;
        if (path1 == path0)
                path1 = NULL;
        for (; start < patterns->length; ++start) {
                const git_attr_fnmatch *pat = git_vector_get(patterns, start);
                if (git_bitvec_get(used, start))
                        continue;
                if (path0 && pathspec_match_one(pat, ctxt, path0) > 0)
                        count += pathspec_mark_pattern(used, start);
                else if (path1 && pathspec_match_one(pat, ctxt, path1) > 0)
                        count += pathspec_mark_pattern(used, start);
        }
        return count;
}
static int pathspec_build_failure_array(
        git_pathspec_string_array_t *failures,
        git_vector *patterns,
        git_bitvec *used,
        git_pool *pool)
{
        size_t pos;
        char **failed;
        const git_attr_fnmatch *pat;
        for (pos = 0; pos < patterns->length; ++pos) {
                if (git_bitvec_get(used, pos))
                        continue;
                if ((failed = git_array_alloc(*failures)) == NULL)
                        return -1;
                pat = git_vector_get(patterns, pos);
                if ((*failed = git_pool_strdup(pool, pat->pattern)) == NULL)
                        return -1;
        }
        return 0;
}
static int pathspec_match_from_iterator(
        git_pathspec_match_list **out,
        git_iterator *iter,
        uint32_t flags,
        git_pathspec *ps)
{
        int error = 0;
        git_pathspec_match_list *m = NULL;
        const git_index_entry *entry = NULL;
        struct pathspec_match_context ctxt;
        git_vector *patterns = &ps->pathspec;
        bool find_failures = out && (flags & GIT_PATHSPEC_FIND_FAILURES) != 0;
        bool failures_only = !out || (flags & GIT_PATHSPEC_FAILURES_ONLY) != 0;
        size_t pos, used_ct = 0, found_files = 0;
        git_index *index = NULL;
        git_bitvec used_patterns;
        char **file;
        if (git_bitvec_init(&used_patterns, patterns->length) < 0)
                return -1;
        if (out) {
                *out = m = pathspec_match_alloc(ps, PATHSPEC_DATATYPE_STRINGS);
                GITERR_CHECK_ALLOC(m);
        }
        if ((error = git_iterator_reset_range(iter, ps->prefix, ps->prefix)) < 0)
                goto done;
        if (git_iterator_type(iter) == GIT_ITERATOR_TYPE_WORKDIR &&
                (error = git_repository_index__weakptr(
                        &index, git_iterator_owner(iter))) < 0)
                goto done;
        pathspec_match_context_init(
                &ctxt, (flags & GIT_PATHSPEC_NO_GLOB) != 0,
                git_iterator_ignore_case(iter));
        while (!(error = git_iterator_advance(&entry, iter))) {
                /* search for match with entry->path */
                int result = git_pathspec__match_at(
                        &pos, patterns, &ctxt, entry->path, NULL);
                /* no matches for this path */
                if (result < 0)
                        continue;
                /* if result was a negative pattern match, then don't list file */
                if (!result) {
                        used_ct += pathspec_mark_pattern(&used_patterns, pos);
                        continue;
                }
                /* check if path is ignored and untracked */
                if (index != NULL &&
                        git_iterator_current_is_ignored(iter) &&
                        git_index__find_pos(NULL, index, entry->path, 0, GIT_INDEX_STAGE_ANY) < 0)
                        continue;
                /* mark the matched pattern as used */
                used_ct += pathspec_mark_pattern(&used_patterns, pos);
                ++found_files;
                /* if find_failures is on, check if any later patterns also match */
                if (find_failures && used_ct < patterns->length)
                        used_ct += pathspec_mark_remaining(
                                &used_patterns, patterns, &ctxt, pos + 1, entry->path, NULL);
                /* if only looking at failures, exit early or just continue */
                if (failures_only || !out) {
                        if (used_ct == patterns->length)
                                break;
                        continue;
                }
                /* insert matched path into matches array */
                if ((file = (char **)git_array_alloc(m->matches)) == NULL ||
                        (*file = git_pool_strdup(&m->pool, entry->path)) == NULL) {
                        error = -1;
                        goto done;
                }
        }
        if (error < 0 && error != GIT_ITEROVER)
                goto done;
        error = 0;
        /* insert patterns that had no matches into failures array */
        if (find_failures && used_ct < patterns->length &&
                (error = pathspec_build_failure_array(
                        &m->failures, patterns, &used_patterns, &m->pool)) < 0)
                goto done;
        /* if every pattern failed to match, then we have failed */
        if ((flags & GIT_PATHSPEC_NO_MATCH_ERROR) != 0 && !found_files) {
                giterr_set(GITERR_INVALID, "No matching files were found");
                error = GIT_ENOTFOUND;
        }
done:
        git_bitvec_free(&used_patterns);
        if (error < 0) {
                pathspec_match_free(m);
                if (out) *out = NULL;
        }
        return error;
}
static git_iterator_flag_t pathspec_match_iter_flags(uint32_t flags)
{
        git_iterator_flag_t f = 0;
        if ((flags & GIT_PATHSPEC_IGNORE_CASE) != 0)
                f |= GIT_ITERATOR_IGNORE_CASE;
        else if ((flags & GIT_PATHSPEC_USE_CASE) != 0)
                f |= GIT_ITERATOR_DONT_IGNORE_CASE;
        return f;
}
int git_pathspec_match_workdir(
        git_pathspec_match_list **out,
        git_repository *repo,
        uint32_t flags,
        git_pathspec *ps)
{
        git_iterator *iter;
        git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT;
        int error = 0;
        assert(repo);
        iter_opts.flags = pathspec_match_iter_flags(flags);
        if (!(error = git_iterator_for_workdir(&iter, repo, NULL, NULL, &iter_opts))) {
                error = pathspec_match_from_iterator(out, iter, flags, ps);
                git_iterator_free(iter);
        }
        return error;
}
int git_pathspec_match_index(
        git_pathspec_match_list **out,
        git_index *index,
        uint32_t flags,
        git_pathspec *ps)
{
        git_iterator *iter;
        git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT;
        int error = 0;
        assert(index);
        iter_opts.flags = pathspec_match_iter_flags(flags);
        if (!(error = git_iterator_for_index(&iter, git_index_owner(index), index, &iter_opts))) {
                error = pathspec_match_from_iterator(out, iter, flags, ps);
                git_iterator_free(iter);
        }
        return error;
}
int git_pathspec_match_tree(
        git_pathspec_match_list **out,
        git_tree *tree,
        uint32_t flags,
        git_pathspec *ps)
{
        git_iterator *iter;
        git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT;
        int error = 0;
        assert(tree);
        iter_opts.flags = pathspec_match_iter_flags(flags);
        if (!(error = git_iterator_for_tree(&iter, tree, &iter_opts))) {
                error = pathspec_match_from_iterator(out, iter, flags, ps);
                git_iterator_free(iter);
        }
        return error;
}
int git_pathspec_match_diff(
        git_pathspec_match_list **out,
        git_diff *diff,
        uint32_t flags,
        git_pathspec *ps)
{
        int error = 0;
        git_pathspec_match_list *m = NULL;
        struct pathspec_match_context ctxt;
        git_vector *patterns = &ps->pathspec;
        bool find_failures = out && (flags & GIT_PATHSPEC_FIND_FAILURES) != 0;
        bool failures_only = !out || (flags & GIT_PATHSPEC_FAILURES_ONLY) != 0;
        size_t i, pos, used_ct = 0, found_deltas = 0;
        const git_diff_delta *delta, **match;
        git_bitvec used_patterns;
        assert(diff);
        if (git_bitvec_init(&used_patterns, patterns->length) < 0)
                return -1;
        if (out) {
                *out = m = pathspec_match_alloc(ps, PATHSPEC_DATATYPE_DIFF);
                GITERR_CHECK_ALLOC(m);
        }
        pathspec_match_context_init(
                &ctxt, (flags & GIT_PATHSPEC_NO_GLOB) != 0,
                git_diff_is_sorted_icase(diff));
        git_vector_foreach(&diff->deltas, i, delta) {
                /* search for match with delta */
                int result = git_pathspec__match_at(
                        &pos, patterns, &ctxt, delta->old_file.path, delta->new_file.path);
                /* no matches for this path */
                if (result < 0)
                        continue;
                /* mark the matched pattern as used */
                used_ct += pathspec_mark_pattern(&used_patterns, pos);
                /* if result was a negative pattern match, then don't list file */
                if (!result)
                        continue;
                ++found_deltas;
                /* if find_failures is on, check if any later patterns also match */
                if (find_failures && used_ct < patterns->length)
                        used_ct += pathspec_mark_remaining(
                                &used_patterns, patterns, &ctxt, pos + 1,
                                delta->old_file.path, delta->new_file.path);
                /* if only looking at failures, exit early or just continue */
                if (failures_only || !out) {
                        if (used_ct == patterns->length)
                                break;
                        continue;
                }
                /* insert matched delta into matches array */
                if (!(match = (const git_diff_delta **)git_array_alloc(m->matches))) {
                        error = -1;
                        goto done;
                } else {
                        *match = delta;
                }
        }
        /* insert patterns that had no matches into failures array */
        if (find_failures && used_ct < patterns->length &&
                (error = pathspec_build_failure_array(
                        &m->failures, patterns, &used_patterns, &m->pool)) < 0)
                goto done;
        /* if every pattern failed to match, then we have failed */
        if ((flags & GIT_PATHSPEC_NO_MATCH_ERROR) != 0 && !found_deltas) {
                giterr_set(GITERR_INVALID, "No matching deltas were found");
                error = GIT_ENOTFOUND;
        }
done:
        git_bitvec_free(&used_patterns);
        if (error < 0) {
                pathspec_match_free(m);
                if (out) *out = NULL;
        }
        return error;
}
void git_pathspec_match_list_free(git_pathspec_match_list *m)
{
        if (m)
                pathspec_match_free(m);
}
size_t git_pathspec_match_list_entrycount(
        const git_pathspec_match_list *m)
{
        return m ? git_array_size(m->matches) : 0;
}
const char *git_pathspec_match_list_entry(
        const git_pathspec_match_list *m, size_t pos)
{
        if (!m || m->datatype != PATHSPEC_DATATYPE_STRINGS ||
                !git_array_valid_index(m->matches, pos))
                return NULL;
        return *((const char **)git_array_get(m->matches, pos));
}
const git_diff_delta *git_pathspec_match_list_diff_entry(
        const git_pathspec_match_list *m, size_t pos)
{
        if (!m || m->datatype != PATHSPEC_DATATYPE_DIFF ||
                !git_array_valid_index(m->matches, pos))
                return NULL;
        return *((const git_diff_delta **)git_array_get(m->matches, pos));
}
size_t git_pathspec_match_list_failed_entrycount(
        const git_pathspec_match_list *m)
{
        return m ? git_array_size(m->failures) : 0;
}
const char * git_pathspec_match_list_failed_entry(
        const git_pathspec_match_list *m, size_t pos)
{
        char **entry = m ? git_array_get(m->failures, pos) : NULL;
        return entry ? *entry : NULL;
}