/**
 * Original:
 * https://blpr.net/?p=210
 *
 * 20201130 @miura added #include<unistd.h> to prevent warning of implicit declaration of functions:
 * read / close.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/inotify.h>
#include <sys/select.h>
#include <limits.h>
// @miura added
#include <unistd.h>
#include <time.h>

#define WATCH_DIR "."

//イベントサイズは16バイト境界
#define INOTIFY_EVENT_MAX (((sizeof(struct inotify_event)+NAME_MAX+1)+16)&~16)

typedef struct _WD_INFO
{
   struct _WD_INFO* prev;
   struct _WD_INFO* next;
   int wd;
   char* path;
} WD_INFO;

static WD_INFO* topWdInfo = NULL;

static void getWdInfo(int fd, char* dirname)
{
   DIR* dir = NULL;
   struct dirent* entry;
   struct stat st;
   int wd;
   int dirname_len;
   int entname_len;
   char* fullpath = NULL;
   WD_INFO* newWdInfo;

   newWdInfo = (WD_INFO*)malloc(sizeof(WD_INFO));

   if(topWdInfo == NULL){
      // first
      topWdInfo = newWdInfo;
      topWdInfo->prev = topWdInfo;
      topWdInfo->next = topWdInfo;
   }else{
      newWdInfo->prev = topWdInfo->prev;
      topWdInfo->prev->next = newWdInfo;
      topWdInfo->prev = newWdInfo;
      newWdInfo->next = topWdInfo;
   }

   newWdInfo->wd = inotify_add_watch(fd, dirname, IN_ALL_EVENTS);
   newWdInfo->path = strdup(dirname);

   //Search Sub directry
   dir = opendir(dirname);

   dirname_len = strlen(dirname);

   while((entry = readdir(dir)) != NULL){

      if(strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0){
         continue;
      }

      //エントリのタイプ種別を非標準のd_typeを使わず、statで取得
      entname_len = strlen(entry->d_name);
      fullpath = (char*)malloc(dirname_len + 1 + entname_len + 1);
      strcpy(fullpath, dirname);
      strcat(fullpath, "/");
      strcat(fullpath, entry->d_name);
      stat(fullpath, &st);

      if(S_ISDIR(st.st_mode)){
         //再帰呼び出し
         getWdInfo(fd, fullpath);
      }

      free(fullpath);
   }

   closedir(dir);
}


static char* wd2path(int wd)
{
   WD_INFO* p;

   if(topWdInfo == NULL){
      return NULL;
   }

   p = topWdInfo;
   do{
      if(p->wd == wd){
         return p->path;
      }
      p = p->next;
   }while(p != topWdInfo);

   return NULL;
}

static void closeAllWdInfo(int fd)
{
   WD_INFO* p;

   if(topWdInfo == NULL){
      return;
   }

   p = topWdInfo;
   do{
      WD_INFO* del;
      del = p;
      p = p->next;
      free(del->path);
      inotify_rm_watch(fd, del->wd);
      free(del);
   }while(p != topWdInfo);
   topWdInfo = NULL;
}

static void deleteWdInfo(int wd)
{
   WD_INFO* p;

   if(topWdInfo == NULL){
      return;
   }

   p = topWdInfo;
   do{
      if(p->wd == wd){
         if(p->next == p->prev){
            topWdInfo = NULL;
         }else{
            if(p == topWdInfo){
               topWdInfo = p->next;
            }
            p->next->prev = p->prev;
            p->prev->next = p->next;
         }
         free(p->path);
         free(p);

         return;
      }
      p = p->next;
   }while(p != topWdInfo);

   return;
}

/** @miura added */
void print_datetime()
{
   time_t t = time(NULL);
   struct tm *lcl = localtime(&t);
   printf("%02d/%02d %02d:%02d:%02d ", lcl->tm_mon+1, lcl->tm_mday,
         lcl->tm_hour, lcl->tm_min, lcl->tm_sec);
}

int main(int argc, char** argv)
{
   struct timeval waitval;
   int fd;
   int ret;
   fd_set readfds;

   fd = inotify_init();

   getWdInfo(fd, (char*)WATCH_DIR);

   while(1){
      FD_ZERO(&readfds);
      FD_SET(fd, &readfds);
      ret = select(fd+1, &readfds, NULL, NULL, NULL);
      if(0 < ret){
         if(FD_ISSET(fd, &readfds)){
            char* buf;
            int len;
            struct inotify_event* event;

            buf = (char*)malloc(INOTIFY_EVENT_MAX);

            //INOTIFY_EVENT_MAXを指定し、最低でも一つのイベントは読み込む。
            len = read(fd, buf, INOTIFY_EVENT_MAX);

            event = (struct inotify_event*)buf;

            //複数イベントがあるかもしれない。全部処理するまでループ。
            while(len > 0){
               char* target;
               if(event->len){
                  target = event->name;
               }else{
                  target = wd2path(event->wd);
               }

               print_datetime();


               if(event->mask & IN_ACCESS){
                  printf("[%s] was accessed.\n", target);
               }
               if(event->mask & IN_MODIFY){
                  printf("[%s] was modified.\n", target);
               }
               if(event->mask & IN_ATTRIB){
                  printf("Metadata of [%s] changed.\n", target);
               }
               if(event->mask & IN_CLOSE_WRITE){
                  printf("Writtable [%s] was closed.\n", target);
               }
               if(event->mask & IN_CLOSE_NOWRITE){
                  printf("Unwrittable [%s] closed.\n", target);
               }
               if(event->mask & IN_OPEN){
                  printf("[%s] was opened.\n", target);
               }
               if(event->mask & IN_MOVED_FROM){
                  printf("[%s] was moved from X.\n", target);
               }
               if(event->mask & IN_MOVED_TO){
                  printf("[%s] was moved to Y.\n", target);
               }
               if(event->mask & IN_CREATE){
                  printf("[%s] was created in [%s].\n", event->name, wd2path(event->wd));
                  char* dirname;
                  int dirname_len;
                  int eventname_len;
                  char* fullpath;
                  struct stat st;

                  dirname = wd2path(event->wd);
                  eventname_len = strlen(event->name);
                  fullpath = (char*)malloc(dirname_len + 1 + eventname_len + 1);
                  strcpy(fullpath, dirname);
                  strcat(fullpath, "/");
                  strcat(fullpath, event->name);
                  stat(fullpath, &st);

                  if(S_ISDIR(st.st_mode)){
                     //監視対象追加
                     getWdInfo(fd, fullpath);
                  }

               }
               if(event->mask & IN_DELETE){
                  printf("[%s] was deleted in [%s].\n", event->name, wd2path(event->wd));
               }
               if(event->mask & IN_DELETE_SELF){
                  printf("[%s] was deleted.\n", target);
               }
               if(event->mask & IN_MOVE_SELF){
                  printf("[%s] was moved.\n", target);
               }

               if(event->mask & IN_IGNORED){
                  printf("[%s] was ignored.\n", target);
                  //監視対象削除
                  deleteWdInfo(event->wd);
               }

               len -= (sizeof(struct inotify_event) + event->len);
               event = (struct inotify_event*)(((char*)event)+sizeof(struct inotify_event) + event->len);
            }
            free(buf);
         }
      }
   }

   closeAllWdInfo(fd);
   close(fd);

   return 0;
}