#include "cache.h"
#include "tmp-objdir.h"
#include "dir.h"
#include "sigchain.h"
#include "string-list.h"
#include "strbuf.h"
#include "argv-array.h"

struct tmp_objdir {
        struct strbuf path;
        struct argv_array env;
};

/*
 * Allow only one tmp_objdir at a time in a running process, which simplifies
 * our signal/atexit cleanup routines.  It's doubtful callers will ever need
 * more than one, and we can expand later if so.  You can have many such
 * tmp_objdirs simultaneously in many processes, of course.
 */
static struct tmp_objdir *the_tmp_objdir;

static void tmp_objdir_free(struct tmp_objdir *t)
{
        strbuf_release(&t->path);
        argv_array_clear(&t->env);
        free(t);
}

static int tmp_objdir_destroy_1(struct tmp_objdir *t, int on_signal)
{
        int err;

        if (!t)
                return 0;

        if (t == the_tmp_objdir)
                the_tmp_objdir = NULL;

        /*
         * This may use malloc via strbuf_grow(), but we should
         * have pre-grown t->path sufficiently so that this
         * doesn't happen in practice.
         */
        err = remove_dir_recursively(&t->path, 0);

        /*
         * When we are cleaning up due to a signal, we won't bother
         * freeing memory; it may cause a deadlock if the signal
         * arrived while libc's allocator lock is held.
         */
        if (!on_signal)
                tmp_objdir_free(t);
        return err;
}

int tmp_objdir_destroy(struct tmp_objdir *t)
{
        return tmp_objdir_destroy_1(t, 0);
}

static void remove_tmp_objdir(void)
{
        tmp_objdir_destroy(the_tmp_objdir);
}

static void remove_tmp_objdir_on_signal(int signo)
{
        tmp_objdir_destroy_1(the_tmp_objdir, 1);
        sigchain_pop(signo);
        raise(signo);
}

/*
 * These env_* functions are for setting up the child environment; the
 * "replace" variant overrides the value of any existing variable with that
 * "key". The "append" variant puts our new value at the end of a list,
 * separated by PATH_SEP (which is what separate values in
 * GIT_ALTERNATE_OBJECT_DIRECTORIES).
 */
static void env_append(struct argv_array *env, const char *key, const char *val)
{
        const char *old = getenv(key);

        if (!old)
                argv_array_pushf(env, "%s=%s", key, val);
        else
                argv_array_pushf(env, "%s=%s%c%s", key, old, PATH_SEP, val);
}

static void env_replace(struct argv_array *env, const char *key, const char *val)
{
        argv_array_pushf(env, "%s=%s", key, val);
}

static int setup_tmp_objdir(const char *root)
{
        char *path;
        int ret = 0;

        path = xstrfmt("%s/pack", root);
        ret = mkdir(path, 0777);
        free(path);

        return ret;
}

struct tmp_objdir *tmp_objdir_create(void)
{
        static int installed_handlers;
        struct tmp_objdir *t;

        if (the_tmp_objdir)
                die("BUG: only one tmp_objdir can be used at a time");

        t = xmalloc(sizeof(*t));
        strbuf_init(&t->path, 0);
        argv_array_init(&t->env);

        strbuf_addf(&t->path, "%s/incoming-XXXXXX", get_object_directory());

        /*
         * Grow the strbuf beyond any filename we expect to be placed in it.
         * If tmp_objdir_destroy() is called by a signal handler, then
         * we should be able to use the strbuf to remove files without
         * having to call malloc.
         */
        strbuf_grow(&t->path, 1024);

        if (!mkdtemp(t->path.buf)) {
                /* free, not destroy, as we never touched the filesystem */
                tmp_objdir_free(t);
                return NULL;
        }

        the_tmp_objdir = t;
        if (!installed_handlers) {
                atexit(remove_tmp_objdir);
                sigchain_push_common(remove_tmp_objdir_on_signal);
                installed_handlers++;
        }

        if (setup_tmp_objdir(t->path.buf)) {
                tmp_objdir_destroy(t);
                return NULL;
        }

        env_append(&t->env, ALTERNATE_DB_ENVIRONMENT,
                   absolute_path(get_object_directory()));
        env_replace(&t->env, DB_ENVIRONMENT, absolute_path(t->path.buf));

        return t;
}

/*
 * Make sure we copy packfiles and their associated metafiles in the correct
 * order. All of these ends_with checks are slightly expensive to do in
 * the midst of a sorting routine, but in practice it shouldn't matter.
 * We will have a relatively small number of packfiles to order, and loose
 * objects exit early in the first line.
 */
static int pack_copy_priority(const char *name)
{
        if (!starts_with(name, "pack"))
                return 0;
        if (ends_with(name, ".keep"))
                return 1;
        if (ends_with(name, ".pack"))
                return 2;
        if (ends_with(name, ".idx"))
                return 3;
        return 4;
}

static int pack_copy_cmp(const char *a, const char *b)
{
        return pack_copy_priority(a) - pack_copy_priority(b);
}

static int read_dir_paths(struct string_list *out, const char *path)
{
        DIR *dh;
        struct dirent *de;

        dh = opendir(path);
        if (!dh)
                return -1;

        while ((de = readdir(dh)))
                if (!is_dot_or_dotdot(de->d_name))
                        string_list_append(out, de->d_name);

        closedir(dh);
        return 0;
}

static int migrate_paths(struct strbuf *src, struct strbuf *dst);

static int migrate_one(struct strbuf *src, struct strbuf *dst)
{
        struct stat st;

        if (stat(src->buf, &st) < 0)
                return -1;
        if (S_ISDIR(st.st_mode)) {
                if (!mkdir(dst->buf, 0777)) {
                        if (adjust_shared_perm(dst->buf))
                                return -1;
                } else if (errno != EEXIST)
                        return -1;
                return migrate_paths(src, dst);
        }
        return finalize_object_file(src->buf, dst->buf);
}

static int migrate_paths(struct strbuf *src, struct strbuf *dst)
{
        size_t src_len = src->len, dst_len = dst->len;
        struct string_list paths = STRING_LIST_INIT_DUP;
        int i;
        int ret = 0;

        if (read_dir_paths(&paths, src->buf) < 0)
                return -1;
        paths.cmp = pack_copy_cmp;
        string_list_sort(&paths);

        for (i = 0; i < paths.nr; i++) {
                const char *name = paths.items[i].string;

                strbuf_addf(src, "/%s", name);
                strbuf_addf(dst, "/%s", name);

                ret |= migrate_one(src, dst);

                strbuf_setlen(src, src_len);
                strbuf_setlen(dst, dst_len);
        }

        string_list_clear(&paths, 0);
        return ret;
}

int tmp_objdir_migrate(struct tmp_objdir *t)
{
        struct strbuf src = STRBUF_INIT, dst = STRBUF_INIT;
        int ret;

        if (!t)
                return 0;

        strbuf_addbuf(&src, &t->path);
        strbuf_addstr(&dst, get_object_directory());

        ret = migrate_paths(&src, &dst);

        strbuf_release(&src);
        strbuf_release(&dst);

        tmp_objdir_destroy(t);
        return ret;
}

const char **tmp_objdir_env(const struct tmp_objdir *t)
{
        if (!t)
                return NULL;
        return t->env.argv;
}

void tmp_objdir_add_as_alternate(const struct tmp_objdir *t)
{
        add_to_alternates_memory(t->path.buf);
}