#include "cache.h"

static int cached_only = 0;
static int recursive = 0;
static int line_termination = '\n';

static int diff_cache(void *tree, unsigned long size, struct cache_entry **ac, int entries, const char *base);

static void update_tree_entry(void **bufp, unsigned long *sizep)
{
	void *buf = *bufp;
	unsigned long size = *sizep;
	int len = strlen(buf) + 1 + 20;

	if (size < len)
		die("corrupt tree file 1 (%s)", size);
	*bufp = buf + len;
	*sizep = size - len;
}

static const unsigned char *extract(void *tree, unsigned long size, const char **pathp, unsigned int *modep)
{
	int len = strlen(tree)+1;
	const unsigned char *sha1 = tree + len;
	const char *path = strchr(tree, ' ');

	if (!path || size < len + 20 || sscanf(tree, "%o", modep) != 1)
		die("corrupt tree file 2 (%d)", size);
	*pathp = path+1;
	return sha1;
}

static char *malloc_base(const char *base, const char *path, int pathlen)
{
	int baselen = strlen(base);
	char *newbase = malloc(baselen + pathlen + 2);
	memcpy(newbase, base, baselen);
	memcpy(newbase + baselen, path, pathlen);
	memcpy(newbase + baselen + pathlen, "/", 2);
	return newbase;
}

static void show_file(const char *prefix, const char *path, unsigned int mode, const unsigned char *sha1, const char *base);

/* A whole sub-tree went away or appeared */
static void show_tree(const char *prefix, void *tree, unsigned long size, const char *base)
{
	while (size) {
		const char *path;
		unsigned int mode;
		const unsigned char *sha1 = extract(tree, size, &path, &mode);
		
		show_file(prefix, path, mode, sha1, base);
		update_tree_entry(&tree, &size);
	}
}

/* A file entry went away or appeared */
static void show_file(const char *prefix, const char *path, unsigned int mode, const unsigned char *sha1, const char *base)
{
	if (recursive && S_ISDIR(mode)) {
		char type[20];
		unsigned long size;
		char *newbase = malloc_base(base, path, strlen(path));
		void *tree;

		tree = read_sha1_file(sha1, type, &size);
		if (!tree || strcmp(type, "tree"))
			die("corrupt tree sha %s", sha1_to_hex(sha1));

		show_tree(prefix, tree, size, newbase);
		
		free(tree);
		free(newbase);
		return;
	}

	printf("%s%o\t%s\t%s\t%s%s%c", prefix, mode,
	       S_ISDIR(mode) ? "tree" : "blob",
	       sha1_to_hex(sha1), base, path,
	       line_termination);
}

static int compare_tree_entry(const char *path1, unsigned int mode1, const unsigned char *sha1,
			      struct cache_entry **ac, int *entries, const char *base)
{
	int baselen = strlen(base);
	struct cache_entry *ce = *ac;
	const char *path2 = ce->name + baselen;
	unsigned int mode2 = ntohl(ce->ce_mode);
	const unsigned char *sha2 = ce->sha1;
	int cmp, pathlen1, pathlen2;
	char old_sha1_hex[50];

	pathlen1 = strlen(path1);
	pathlen2 = strlen(path2);
	cmp = cache_name_compare(path1, pathlen1, path2, pathlen2);
	if (cmp < 0) {
		if (S_ISDIR(mode1)) {
			char type[20];
			unsigned long size;
			void *tree = read_sha1_file(sha1, type, &size);
			char *newbase = malloc(baselen + 2 + pathlen1);

			memcpy(newbase, base, baselen);
			memcpy(newbase + baselen, path1, pathlen1);
			memcpy(newbase + baselen + pathlen1, "/", 2);
			if (!tree || strcmp(type, "tree"))
				die("unable to read tree object %s", sha1_to_hex(sha1));
			*entries = diff_cache(tree, size, ac, *entries, newbase);
			free(newbase);
			free(tree);
			return -1;
		}
		show_file("-", path1, mode1, sha1, base);
		return -1;
	}

	if (!cached_only) {
		static unsigned char no_sha1[20];
		int fd, changed;
		struct stat st;
		fd = open(ce->name, O_RDONLY);
		if (fd < 0 || fstat(fd, &st) < 0) {
			show_file("-", path1, mode1, sha1, base);
			return -1;
		}
		changed = cache_match_stat(ce, &st);
		close(fd);
		if (changed) {
			mode2 = st.st_mode;
			sha2 = no_sha1;
		}
	}

	if (cmp > 0) {
		show_file("+", path2, mode2, sha2, base);
		return 1;
	}
	if (!memcmp(sha1, sha2, 20) && mode1 == mode2)
		return 0;

	/*
	 * If the filemode has changed to/from a directory from/to a regular
	 * file, we need to consider it a remove and an add.
	 */
	if (S_ISDIR(mode1) || S_ISDIR(mode2)) {
		show_file("-", path1, mode1, sha1, base);
		show_file("+", path2, mode2, sha2, base);
		return 0;
	}

	strcpy(old_sha1_hex, sha1_to_hex(sha1));
	printf("*%o->%o\t%s\t%s->%s\t%s%s%c", mode1, mode2,
	       S_ISDIR(mode1) ? "tree" : "blob",
	       old_sha1_hex, sha1_to_hex(sha2), base, path1,
	       line_termination);
	return 0;
}

static int diff_cache(void *tree, unsigned long size, struct cache_entry **ac, int entries, const char *base)
{
	int baselen = strlen(base);

	for (;;) {
		struct cache_entry *ce;
		unsigned int mode;
		const char *path;
		const unsigned char *sha1;
		int left;

		/*
		 * No entries in the cache (with this base)?
		 * Output the tree contents.
		 */
		if (!entries || ce_namelen(ce = *ac) < baselen || memcmp(ce->name, base, baselen)) {
			if (!size)
				return entries;
			sha1 = extract(tree, size, &path, &mode);
			show_file("-", path, mode, sha1, base);
			update_tree_entry(&tree, &size);
			continue;
		}

		/*
		 * No entries in the tree? Output the cache contents
		 */
		if (!size) {
			show_file("+", ce->name, ntohl(ce->ce_mode), ce->sha1, "");
			ac++;
			entries--;
			continue;
		}

		sha1 = extract(tree, size, &path, &mode);
		left = entries;
		switch (compare_tree_entry(path, mode, sha1, ac, &left, base)) {
		case -1:
			update_tree_entry(&tree, &size);
			if (left < entries) {
				ac += (entries - left);
				entries = left;
			}
			continue;
		case 0:
			update_tree_entry(&tree, &size);
			/* Fallthrough */
		case 1:
			ac++;
			entries--;
			continue;
		}
		die("diff-cache: internal error");
	}
	return 0;
}

static char *diff_cache_usage = "diff-cache [-r] [-z] [--cached] <tree sha1>";

int main(int argc, char **argv)
{
	unsigned char tree_sha1[20];
	void *tree;
	unsigned long size;

	read_cache();
	while (argc > 2) {
		char *arg = argv[1];
		argv++;
		argc--;
		if (!strcmp(arg, "-r")) {
			recursive = 1;
			continue;
		}
		if (!strcmp(arg, "-z")) {
			line_termination = '\0';
			continue;
		}
		if (!strcmp(arg, "--cached")) {
			cached_only = 1;
			continue;
		}
		usage(diff_cache_usage);
	}

	if (argc != 2 || get_sha1_hex(argv[1], tree_sha1))
		usage(diff_cache_usage);

	tree = read_tree_with_tree_or_commit_sha1(tree_sha1, &size, 0);
	if (!tree)
		die("bad tree object %s", argv[1]);

	return diff_cache(tree, size, active_cache, active_nr, "");
}