/*
 * Create a squashfs filesystem.  This is a highly compressed read only filesystem.
 *
 * Copyright (c) 2002, 2003, 2004 Phillip Lougher <plougher@users.sourceforge.net>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2,
 * or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * sort.c
 */

#define TRUE 1
#define FALSE 0

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>

#include <squashfs_fs.h>

#ifdef SQUASHFS_TRACE
#define TRACE(s, args...)		printf("mksquashfs: "s, ## args)
#else
#define TRACE(s, args...)
#endif

#define INFO(s, args...)		if(!silent) printf("mksquashfs: "s, ## args)
#define ERROR(s, args...)		fprintf(stderr, s, ## args)
#define EXIT_MKSQUASHFS()		exit(1)
#define BAD_ERROR(s, args...)		{\
					fprintf(stderr, "FATAL ERROR:" s, ##args);\
					EXIT_MKSQUASHFS();\
					}

struct sort_info {
	dev_t			st_dev;
	ino_t			st_ino;
	int			priority;
	struct sort_info	*next;
};

struct sort_info *sort_info_list[65536];

struct priority_entry {
	char *filename;
	long long size;
	ino_t st_ino;
	dev_t st_dev;
	struct priority_entry *next;
};

struct priority_entry *priority_list[65536];

struct sorted_inode_entry {
	squashfs_inode inode;
	ino_t	st_ino;
	dev_t	st_dev;
	struct sorted_inode_entry *next;
};

struct sorted_inode_entry *sorted_inode_list[65536];

extern int silent;
extern int excluded(char *filename, struct stat *buf);
extern squashfs_inode write_file(char *filename, long long size, int *c_size);


int add_to_sorted_inode_list(squashfs_inode inode, dev_t st_dev, ino_t st_ino)
{
	int hash = st_ino & 0xffff;
	struct sorted_inode_entry *new_sorted_inode_entry;

	if((new_sorted_inode_entry = malloc(sizeof(struct sorted_inode_entry))) == NULL) {
		ERROR("Out of memory allocating sorted inode entry\n");
		return FALSE;
	}

	new_sorted_inode_entry->inode = inode;
	new_sorted_inode_entry->st_ino = st_ino;
	new_sorted_inode_entry->st_dev = st_dev;
	new_sorted_inode_entry->next = sorted_inode_list[hash];
	sorted_inode_list[hash] = new_sorted_inode_entry;

	return TRUE;
}

	
squashfs_inode get_sorted_inode(struct stat *buf)
{
	int hash = buf->st_ino & 0xffff;
	struct sorted_inode_entry *sorted_inode_entry;

	for(sorted_inode_entry = sorted_inode_list[hash]; sorted_inode_entry; sorted_inode_entry = sorted_inode_entry->next)
		if(buf->st_ino == sorted_inode_entry->st_ino && buf->st_dev == sorted_inode_entry->st_dev)
			break;

	if(sorted_inode_entry)
		return sorted_inode_entry->inode;
	else
		return (squashfs_inode) 0;
}


int add_priority_list(char *filename, struct stat *buf, int priority)
{
	struct priority_entry *new_priority_entry;

	priority += 32768;
	if((new_priority_entry = malloc(sizeof(struct priority_entry))) == NULL) {
		ERROR("Out of memory allocating priority entry\n");
		return FALSE;
	}

	new_priority_entry->filename = strdup(filename);
	new_priority_entry->size = buf->st_size;
	new_priority_entry->st_dev = buf->st_dev;
	new_priority_entry->st_ino = buf->st_ino;
	new_priority_entry->next = priority_list[priority];
	priority_list[priority] = new_priority_entry;
	return TRUE;
}


int get_priority(char *filename, struct stat *buf, int priority)
{
	int hash = buf->st_ino & 0xffff;
	struct sort_info *s;

	for(s = sort_info_list[hash]; s; s = s->next)
		if((s->st_dev == buf->st_dev) && (s->st_ino == buf->st_ino)) {
			TRACE("returning priority %d (%s)\n", s->priority, filename);
			return s->priority;
		}
	TRACE("returning priority %d (%s)\n", priority, filename);
	return priority;
}


#define ADD_ENTRY(buf, priority) {\
	int hash = buf.st_ino & 0xffff;\
	struct sort_info *s;\
	if((s = malloc(sizeof(struct sort_info))) == NULL) {\
		ERROR("Out of memory allocating sort list entry\n");\
		return FALSE;\
	}\
	s->st_dev = buf.st_dev;\
	s->st_ino = buf.st_ino;\
	s->priority = priority;\
	s->next = sort_info_list[hash];\
	sort_info_list[hash] = s;\
	}
int add_sort_list(char *path, int priority, int source, char *source_path[])
{
	int i;
	char buffer[4096], filename[4096];
	struct stat buf;

	TRACE("add_sort_list: filename %s, priority %d\n", path, priority);
	if(strlen(path) > 1 && strcmp(path + strlen(path) - 2, "/*") == 0)
		path[strlen(path) - 2] = '\0';

	TRACE("add_sort_list: filename %s, priority %d\n", path, priority);
	if(path[0] == '/' || strncmp(path, "./", 2) == 0 || strncmp(path, "../", 3) == 0) {
		if(lstat(path, &buf) == -1) {
			sprintf(buffer, "Cannot stat sort_list dir/file %s, ignoring", path);
			perror(buffer);
			return TRUE;
		}
		TRACE("adding filename %s, priority %d, st_dev %Lx, st_ino %Lx\n", path, priority, buf.st_dev, buf.st_ino);
		ADD_ENTRY(buf, priority);
		return TRUE;
	}

	for(i = 0; i < source; i++) {
		strcat(strcat(strcpy(filename, source_path[i]), "/"), path);
		if(lstat(filename, &buf) == -1) {
			if(!(errno == ENOENT || errno == ENOTDIR)) {
				sprintf(buffer, "Cannot stat sort_list dir/file %s, ignoring", filename);
				perror(buffer);
			}
			continue;
		}
		ADD_ENTRY(buf, priority);
	}
	return TRUE;
}


void generate_file_priorities(char *pathname, int priority, struct stat *buf)
{
	char filename[8192];
	DIR *linuxdir;
	struct dirent *d_name;
	
	priority = get_priority(pathname, buf, priority);

	if((linuxdir = opendir(pathname)) == NULL) {
		ERROR("Could not open %s, skipping...\n", pathname);
		return;
	}
	
	while((d_name = readdir(linuxdir)) != NULL) {
		if(strcmp(d_name->d_name, ".") == 0 || strcmp(d_name->d_name, "..") == 0)
			continue;
		strcat(strcat(strcpy(filename, pathname), "/"), d_name->d_name);

		if(lstat(filename, buf) == -1) {
			char buffer[8192];
			sprintf(buffer, "Cannot stat dir/file %s, ignoring", filename);
			perror(buffer);
			continue;
		}

		if(excluded(filename, buf))
			continue;

		switch(buf->st_mode & S_IFMT) {
			case S_IFREG:
				add_priority_list(filename, buf, get_priority(filename, buf, priority));
				break;
			case S_IFDIR:
				generate_file_priorities(filename, priority, buf);
				break;
		}
	}

	closedir(linuxdir);
}


int read_sort_file(char *filename, int source, char *source_path[])
{
	FILE *fd;
	char sort_filename[16385];
	int priority;

	if((fd = fopen(filename, "r")) == NULL) {
		perror("Could not open sort_list file...");
		return FALSE;
	}
	while(fscanf(fd, "%s %d", sort_filename, &priority) != EOF)
		if(priority >= -32768 && priority <= 32767)
			add_sort_list(sort_filename, priority, source, source_path);
		else
			ERROR("Sort file %s, priority %d outside range of -32767:32768 - skipping...\n", sort_filename, priority);
	fclose(fd);
	return TRUE;
}


void sort_files_and_write(int source, char *source_path[])
{
	struct stat buf;
	int i, c_size;
	struct priority_entry *entry;
	squashfs_inode inode;

	for(i = 0; i < source; i++) {
		if(lstat(source_path[i], &buf) == -1) {
			char buffer[8192];
			sprintf(buffer, "Cannot stat dir/file %s, ignoring", source_path[i]);
			perror(buffer);
			continue;
		}

		if(excluded(source_path[i], &buf))
			continue;

		switch(buf.st_mode & S_IFMT) {
			case S_IFREG:
				add_priority_list(source_path[i], &buf, get_priority(source_path[i], &buf, 0));
				break;
			case S_IFDIR:
				generate_file_priorities(source_path[i], 0, &buf);
				break;
		}
	}

	for(i = 0; i < 65536; i++)
		for(entry = priority_list[i]; entry; entry = entry->next) {
			TRACE("%d: %s\n", i - 32768, entry->filename);
			inode = write_file(entry->filename, entry->size, &c_size);
			INFO("file %s, size %d bytes, inode 0x%Lx\n", entry->filename, c_size, inode);
			INFO("\t%.2f%% of uncompressed file size (%Ld bytes)\n", ((float) c_size / entry->size) * 100.0, entry->size);
			add_to_sorted_inode_list(inode, entry->st_dev, entry->st_ino);
		}
}