/* vi: set sw=4 ts=4:
 *
 * du.c - disk usage program.
 *
 * Copyright 2012 Ashwini Kumar <ak.ashwini@gmail.com>
 *
 * See http://opengroup.org/onlinepubs/9699919799/utilities/du.html

USE_DU(NEWTOY(du, "d#<0hmlcaHkLsx", TOYFLAG_USR|TOYFLAG_BIN))

config DU
	bool "du"
	default y
	help
	  usage: du [-d N] [-askxHLlmc] [file...]

	  Estimate file space usage (default in unit of 512 blocks).
	  -a    Show all file sizes
	  -H    Follow symlinks on cmdline
	  -L    Follow all symlinks
	  -k    Show size in units of 1024.
	  -s    Show only the total Size for each file specified
	  -x    Estimate size only on the same device
	  -c    Print total size of all arguments
	  -d N  Limit output to directories (and files with -a) of depth < N
	  -l    Count sizes many times if hard linked
	  -h    Sizes in human readable format (e.g., 1K 243M 2G )
	  -m    Sizes in megabytes
*/

#include "toys.h"

DEFINE_GLOBALS(
    long maxdepth;
    long depth;
	long *dirsum;
	long total;
    dev_t st_dev;
    struct arg_list *inodes;
)

#define TT this.du

#define FLAG_x	1
#define FLAG_s	2
#define FLAG_L	4
#define FLAG_k	8
#define FLAG_H	16
#define FLAG_a	32
#define FLAG_c	64
#define FLAG_l	128
#define FLAG_m	256
#define FLAG_h	512
#define FLAG_d	1024

typedef struct node_size {
    struct dirtree *node;
    long size;
}node_size;

typedef struct inode_ent {
    ino_t ino;
    dev_t dev;
}inode_ent_t;

/*
 * Adding '/' to the name if name is '.' or '..'
 */

char *make_pathproper(char *str)
{
    char *path = str;
    switch(strlen(str)) {
        case 1:
            if(str[0] == '.') path = xstrdup("./");
            break;
        case 2:
            if(str[0] == '.' && str[1] == '.') path = xstrdup("../");
            break;
        default:
            break;
    }
    return path;
}

/*
 * Print the size of the given entry in specified format, default in blocks of 512 bytes
 */
void print(long size, char* name)
{
    unsigned long long tempsize = (unsigned long long)size * 512;
    unsigned long unit = 512;
    char *sizestr = NULL;
    if(TT.depth > TT.maxdepth) return;
    if(toys.optflags & FLAG_h) unit = 0;
    if(toys.optflags & FLAG_k) unit = 1024;
    if(toys.optflags & FLAG_m) unit = 1024*1024;
    sizestr =  make_human_readable(tempsize, unit); //make human readable string, depending upon unit size.
    xprintf("%s\t%s\n",sizestr, name);
    free(sizestr);
}

/*
 * free the inodes which are stored for hard link reference 
 */
void free_inodes(void *data)
{
    void *arg = ((struct arg_list*)data)->arg;
    if(arg) free(arg);
    free(data);
}

/*
 * allocate and add a node to the list
 */
static void llist_add_inode(struct arg_list **old, void *data)
{           
    struct arg_list *new = xmalloc(sizeof(struct arg_list));

    new->arg = (char*)data;
    new->next = *old;
    *old = new;
}

/*
 * check if the given stat entry is already there in list or not
 */
int is_inode_present(struct stat *st)
{
    struct arg_list *temparg = NULL;
    inode_ent_t *ent = NULL;
    if(!TT.inodes) return 0;
    for(temparg = TT.inodes; temparg; temparg = (struct arg_list *)temparg->next) {
        ent = (inode_ent_t*)temparg->arg;
        if(ent && ent->ino == st->st_ino && ent->dev == st->st_dev) return 1;
    }
    return 0;
}

/*
 * Compute the size of the node
 */
int do_du(struct dirtree *node)
{
    inode_ent_t *ino_details = NULL;
    node_size *nd = NULL;
    if(!dirtree_notdotdot(node)) return 0;
    if((toys.optflags & FLAG_x) && (TT.st_dev != node->st.st_dev)) //if file not on same device, don't count size
        return DIRTREE_RECURSE;

    if(!(toys.optflags & FLAG_l) && node->st.st_nlink > 1 && !node->extra) { //keeping reference for hard links
        if(is_inode_present(&node->st)) return DIRTREE_RECURSE;
        ino_details = xzalloc(sizeof(inode_ent_t));
        ino_details->ino = node->st.st_ino;
        ino_details->dev = node->st.st_dev;
        llist_add_inode(&TT.inodes, (void*)ino_details);
    }

    if(S_ISDIR(node->st.st_mode)) {
        if(!(node->extra && (long)((node_size*)(node->extra))->node == (long)node)) {
            nd = xzalloc(sizeof(node_size));
            nd->node = node;
            nd->size = 0;
            TT.dirsum = (long*)&(nd->size);
            node->extra = (long)nd;
            *TT.dirsum = 0;
            TT.depth++;
            return (DIRTREE_RECURSE|DIRTREE_COMEAGAIN | ((toys.optflags & FLAG_L) ? DIRTREE_SYMFOLLOW : 0)); //DIRTREE_COMEAGAIN to comeback and print the entry.
        }
        else if(node->extra) { //extra is set for a returning DIR entry.
            long offset = 0;
            nd = (node_size*)node->extra;
            offset = nd->size;
            nd->size += node->st.st_blocks;
            TT.depth--;
            if(!(toys.optflags & FLAG_s))
                print(*TT.dirsum, dirtree_path(node, NULL));
            if((node->parent) && (node->parent->extra)) { 
                /* when returning from internal directory, get the saved size of the parent and continue from there */
                nd = (node_size*)node->parent->extra;
                TT.dirsum = (long*)&(nd->size);
                *TT.dirsum += offset;
                *TT.dirsum += node->st.st_blocks;
                return DIRTREE_RECURSE;
            }
            else if(!node->parent) {
                /*if node has no parent, it means it is the top in the tree, stop recursing here */
                TT.total += *TT.dirsum;
                if((toys.optflags & FLAG_s))
                    print(*TT.dirsum, dirtree_path(node, NULL));
                return 0;
            }
        }
    }
    else if(!(node->parent)) {
        /* this is the file specified on cmdline */
        TT.total += node->st.st_blocks;
        print(node->st.st_blocks, dirtree_path(node, NULL));
        return 0;
    }
    if(TT.dirsum) *TT.dirsum += node->st.st_blocks;
    if(toys.optflags & FLAG_a && !(toys.optflags & FLAG_s))
        print(node->st.st_blocks, dirtree_path(node, NULL));
    return DIRTREE_RECURSE;
}

/*
 * DU utility main function
 */
void du_main(void)
{
    int symfollow = toys.optflags & (FLAG_H | FLAG_L);
    TT.total = 0;
    TT.inodes = NULL;
    
    if(!(toys.optflags & FLAG_d)) TT.maxdepth = INT_MAX;
    if(toys.optc == 0) toys.optargs[0] = "./";
    while(*toys.optargs) {
        TT.depth = 0;
        char *path = make_pathproper(*toys.optargs);
        struct dirtree *root = dirtree_add_node(AT_FDCWD, path, symfollow); //create a node
        if(root) {
            TT.st_dev = root->st.st_dev;
            handle_callback(root, do_du); //this will recurse thru the DIR children.
        }
        toys.optargs++;
    }
    if(TT.inodes) llist_traverse(TT.inodes, free_inodes); //free the stored nodes
    if(toys.optflags & FLAG_c) print(TT.total, "total");
}