#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>

#define WRONG_ARGS_NUM 1

typedef int MyFunc(const char*, const struct stat*, int);

static MyFunc myfunc;
static int myftw(char*, MyFunc*);
static int dopath(MyFunc*);

static long nreg, ndir, nblk, nchr, nfifo, nslink, nsock, ntot;

int main(int argc, char* argv[])
{
    if (argc != 2)
    {
        printf("Usage: ./nFilesDir <dir>\n");
        return WRONG_ARGS_NUM;
    }

    int ret_val = myftw(argv[1], myfunc);

    ntot = nreg + ndir + nblk + nchr + nfifo + nslink + nsock;
    ntot = (ntot == 0) ? 1 : ntot;

    printf("Rgular files:\t\t %7ld, %5.2f %%\n", nreg, nreg*100.0/ntot);
    printf("Directories:\t\t %7ld, %5.2f %%\n", ndir, ndir*100.0/ntot);
    printf("Special block files:\t %7ld, %5.2f %%\n", nblk, nblk*100.0/ntot);
    printf("Special symbolic files:\t %7ld, %5.2f %%\n", nchr, nchr*100.0/ntot);
    printf("FIFO:\t\t\t %7ld, %5.2f %%\n", nfifo, nfifo*100.0/ntot);
    printf("Symbolic links:\t\t %7ld, %5.2f %%\n", nslink, nslink*100.0/ntot);
    printf("Sockets:\t\t %7ld, %5.2f %%\n", nsock, nsock*100.0/ntot);

    return ret_val;
}

#define FTW_F 1     // File, not directory
#define FTW_D 2     // Directory
#define FTW_DNR 3   // Private directory
#define FTW_NS 4    // Can't get info about file with stat()

static char *fullpath;

static int myftw(char* pathname, MyFunc *func)
{
    int len;

    //fullpath = path_alloc(&len);
    fullpath = calloc(PATH_MAX+1, sizeof(char));
    len = PATH_MAX;

    strncpy(fullpath, pathname, len);
    fullpath[len-1] = 0;

    return dopath(func);
}

static int dopath(MyFunc *func)
{
    struct stat statbuf;
    struct dirent *dirp;
    DIR *dp;
    int ret;
    char *ptr;

    if (lstat(fullpath, &statbuf) < 0)  // stat ERROR
    {
        return func(fullpath, &statbuf, FTW_NS);
    }

    if (S_ISDIR(statbuf.st_mode) == 0) // Not dir
    {
        return func(fullpath, &statbuf, FTW_F);
    }

    // Working with dir
    if ((ret = func(fullpath, &statbuf, FTW_D)) != 0)
    {
        return ret;
    }

    ptr = fullpath + strlen(fullpath);
    *ptr++ = '/';
    *ptr = 0;

    if ((dp = opendir(fullpath)) == NULL)
    {
        return func(fullpath, &statbuf, FTW_DNR);
    }

    while ((dirp = readdir(dp)) != NULL)
    {
        if ((strcmp(dirp->d_name, ".") == 0) || (strcmp(dirp->d_name, "..") == 0))
        {
            continue;
        }

        strcpy(ptr, dirp->d_name);

        if ((ret = dopath(func)) != 0)
        {
            break;
        }
    }

    ptr[-1] = 0;

    if (closedir(dp) < 0)
    {
        printf("Can't close dir %s", fullpath);
    }

    return ret;
}

static int myfunc(const char *pathname, const struct stat *statptr, int type)
{
    switch (type)
    {
        case FTW_F:
            switch (statptr->st_mode & S_IFMT)
            {
                case S_IFREG: nreg++; break;
                case S_IFBLK: nblk++; break;
                case S_IFCHR: nchr++; break;
                case S_IFIFO: nfifo++; break;
                case S_IFLNK: nslink++; break;
                case S_IFSOCK: nsock++; break;
                case S_IFDIR: printf("S_IFDIR for %s", pathname);
            }
            break;
        case FTW_D:
            ndir++;
            break;
        case FTW_DNR:
            printf("Private dir %s", pathname);
            break;
        case FTW_NS:
            printf("Can't stat() %s", pathname);
            break;
        default:
            printf("Unknown type %d for %s", type, pathname);
            break;
    }

    return 0;
}