/***************************************
 * API - setup the mailbox directory
 * 
 * IN:
 *  nodeid      - node id for this node
 *  create_link - not 0 if symbolic link
  *               needs to be created
 ***************************************/
int
mb_init_mailboxes(cmm_nodeid_t nodeid,
                  int create_link)
{
    char buffer[MAXPATHLEN];
    char localnode[MAXPATHLEN];
    int err;

    snprintf(buffer, sizeof(buffer), "%s/%d",
             MAILBOX_PATH, nodeid);

    err = check_dir(buffer, NULL);
    if (err) {
        return(1);
    }

    if (!create_link) {
        return(0);
    }

    /* Create the link */

    snprintf(localnode, sizeof(buffer), "%s/0",
             MAILBOX_PATH);
    
    err = check_dir(localnode, buffer);
    if (err) {
        return(1);
    }
    return(0);
}

static void
amgtar_selfcheck(
    application_argument_t *argument)
{
    amgtar_build_exinclude(&argument->dle, 1, NULL, NULL, NULL, NULL);

    printf("OK amgtar\n");
    if (gnutar_path) {
	check_file(gnutar_path, X_OK);
    } else {
	printf(_("ERROR [GNUTAR program not available]\n"));
    }

    set_root_privs(1);
    if (gnutar_listdir && strlen(gnutar_listdir) == 0)
	gnutar_listdir = NULL;
    if (gnutar_listdir) {
	check_dir(gnutar_listdir, R_OK|W_OK);
    } else {
	printf(_("ERROR [No GNUTAR-LISTDIR]\n"));
    }

    if (argument->dle.disk) {
	char *qdisk = quote_string(argument->dle.disk);
	fprintf(stdout, "OK %s\n", qdisk);
	amfree(qdisk);
    }
    if (gnutar_directory) {
	check_dir(gnutar_directory, R_OK);
    } else if (argument->dle.device) {
	check_dir(argument->dle.device, R_OK);
    }
    set_root_privs(0);
}

END_TEST

START_TEST(test_private_ccache_dir_in_user_dir)
{
    int ret;
    char *cwd;
    char *user_dir;
    char *dn1;
    char *dn2;
    char *dn3;
    char *filename;
    uid_t uid = getuid();
    gid_t gid = getgid();

    if (uid == 0) {
        uid = 12345;
        gid = 12345;
    }

    cwd = getcwd(NULL, 0);
    fail_unless(cwd != NULL, "getcwd failed.");

    user_dir = talloc_asprintf(tmp_ctx, "%s/%s/user", cwd, TESTS_PATH);
    free(cwd);
    fail_unless(user_dir != NULL, "talloc_asprintf failed.");
    ret = mkdir(user_dir, 0700);
    fail_unless(ret == EOK, "mkdir failed.");
    ret = chown(user_dir, uid, gid);
    fail_unless(ret == EOK, "chown failed.");

    dn1 = talloc_asprintf(tmp_ctx, "%s/a", user_dir);
    fail_unless(dn1 != NULL, "talloc_asprintf failed.");
    dn2 = talloc_asprintf(tmp_ctx, "%s/b", dn1);
    fail_unless(dn2 != NULL, "talloc_asprintf failed.");
    dn3 = talloc_asprintf(tmp_ctx, "%s/c", dn2);
    fail_unless(dn3 != NULL, "talloc_asprintf failed.");
    filename = talloc_asprintf(tmp_ctx, "%s/ccfile", dn3);
    fail_unless(filename != NULL, "talloc_asprintf failed.");

    ret = chmod(user_dir, 0600);
    fail_unless(ret == EOK, "chmod failed.");
    ret = cc_file_create(filename, NULL, uid, gid, true);
    fail_unless(ret == EINVAL, "cc_file_create does not return EINVAL "
                               "while x-bit is missing.");

    ret = chmod(user_dir, 0700);
    fail_unless(ret == EOK, "chmod failed.");
    ret = cc_file_create(filename, NULL, uid, gid, true);
    fail_unless(ret == EOK, "cc_file_create failed.");

    check_dir(dn3, uid, gid, 0700);
    RMDIR(dn3);
    check_dir(dn2, uid, gid, 0700);
    RMDIR(dn2);
    check_dir(dn1, uid, gid, 0700);
    RMDIR(dn1);
    RMDIR(user_dir);
}

int main() {
	printf("input.txt is a regular file? %s\n",
	    check_reg("input.txt") ? "yes" : "no");
	printf("docs is a directory? %s\n",
	    check_dir("docs") ? "yes" : "no");
	printf("/input.txt is a regular file? %s\n",
	    check_reg("/input.txt") ? "yes" : "no");
	printf("/docs is a directory? %s\n",
	    check_dir("/docs") ? "yes" : "no");
	return 0;
}

void check_dir(char *search_dir, int fd)
{
	DIR *dir;
        struct dirent *ent;
        dir = opendir (search_dir);
        if (dir != NULL)
	{

	        /* print all the files and directories within directory */
	        while ((ent = readdir (dir)) != NULL)
		{
	        	if(ent->d_type & DT_DIR)
		        {
				if(ent->d_name[0] != '.' || strlen(ent->d_name)>2)
				{
				
				printf("Letar i mappen %s\n", search_dir);
				printf("Hittade den nya mappen %s\n", ent->d_name);
				

				char *directory = malloc(strlen(search_dir) + strlen(ent->d_name) + 2);
				strcpy(directory,search_dir);
				strcat(directory,"/");
				strcat(directory,ent->d_name);

				inotify_add_watch(fd,directory,IN_MODIFY | IN_CREATE | IN_DELETE);
				check_dir(directory, fd);
				}
		        }                
		}
	}
	closedir (dir);
	}

int
create_dir (char *path)
{
  char *parent;
  char *tmp;
  int rc;

  tmp = strdup (path);		/* preserve our string */
  parent = dirname (tmp);
  rc = check_dir (parent);
  if (strcmp (parent, "/") == 0)
    {
      return -1;		/* stop endless loop */
    }
  if (rc == MISC_NOT_DIR || rc == MISC_NOT_WRITABLE)
    {
      return -1;
    }
  else if (rc == MISC_DOES_NOT_EXISTS)
    {
      /* recursively create */
      if (create_dir (parent) != 0)
	{
	  fprintf (stderr, "failed to create %s\n", parent);
	  return -1;
	}
    }
  rc = mkdir (path, 0755);
  free (tmp);
  return rc;
}

//handling readlink request
void readlink_handler(Msg *msg, int sender_pid)
{

    char symname[MAXPATHNAMELEN];
    memset(symname,'\0',MAXPATHNAMELEN);
    CopyFrom(sender_pid,symname,msg->ptr1,msg->num2+1);
    int return_len=msg->num3;

    char* filename = symname+msg->num2;
    int direct_len = msg->num2;
    while ((*filename)!='/' && filename!=symname) {
        filename--;
        direct_len--;
    }
    if ((*filename)=='/') {
        direct_len++;
        filename++;
    }

    int parent_inum=path_to_inum(symname,direct_len,msg->num1,0);
    int sym_inum=check_dir(parent_inum,filename);
    if(sym_inum<=0){
        msg->type=-1;
        return;
    }
    inode_cache *sym_inode=read_inode(sym_inum);
    block_cache *sym_block=read_block(sym_inode->data.direct[0]);
    if(sym_inode->data.size<return_len)
        return_len=sym_inode->data.size;

    CopyTo(sender_pid,msg->ptr2,sym_block->data,return_len);

    msg->num3=return_len;

}

//handling stat request
void stat_handler(Msg *msg, int sender_pid)
{
    char pathname[MAXPATHNAMELEN];
    CopyFrom(sender_pid,pathname,msg->ptr1,msg->num1+1);

    char* filename = pathname+msg->num2;
    int direct_len = msg->num2;
    while ((*filename)!='/' && filename!=pathname) {
        filename--;
        direct_len--;
    }
    if ((*filename)=='/') {
        direct_len++;
        filename++;
    }

    int parent_inum = path_to_inum(pathname,direct_len,msg->num2,0);
    int inum=check_dir(parent_inum,filename);
    struct Stat s;
    inode_cache *n = read_inode(inum);
    s.inum = inum;
    s.type = n->data.type;
    s.size = n->data.size;
    s.nlink = n->data.nlink;
    CopyTo(sender_pid,msg->ptr2,&s,sizeof(struct Stat));

}

void init_maps(void)
{
	uint32 i = 0;
	uint32 n = 0;
	char *path;

	map_array = (map_t *)calloc(MAX_MAPS, sizeof(map_t));
	map_array_cache = (buffer_t *)calloc(MAX_MAPS, sizeof(buffer_t));

	for( i = 0; i < MAX_MAPS; i++){
		map_array[i].name = (char *)calloc(MAX_NAME_LENGTH, sizeof(char));
		map_array[i].npc = (map_npc_t *)calloc(MAX_MAP_NPCS, sizeof(map_npc_t));
		map_array[i].tile = (tile_t *)calloc(MAX_MAPX * MAX_MAPY, sizeof(tile_t));
		map_array[i].items = (map_item_t *)calloc(MAX_MAP_ITEMS, sizeof(map_item_t));

		for( n = 0; n < MAX_MAP_NPCS; n++)
			map_array[i].npc[n].vitals = (uint16 *)calloc(VITAL_COUNT, sizeof(uint16));

		path = get_path(MAP_PATH, i, FILE_ENDING);

		check_dir(MAP_PATH);

		if(file_readable(path))
			read_map(path,i);
		else
			write_map(path,i);

		mapcache_create(i);
	}
}

void change_dir(char *currdir, const char *dir)
{
	char tempdir[1024];

	if(dir == NULL)
	{
		printf("ERROR: Must supply a directory argument\n");
		return;
	}

	if(strcmp(dir, "..") == 0)
	{
		up_dir(currdir);
		return;
	}

	(void) snprintf(tempdir, sizeof(tempdir), "%s/%s", currdir, dir);
	if(check_dir(tempdir))
	{
		strcpy(currdir, tempdir);
	}
	else
	{
		printf("ERROR: Invalid directory '%s'\n", tempdir);
	}
}

void init_server(void)
{
	printf("Initializing Data. \n");
	check_dir(LOG_PATH);

	printf("Loading Items. \n");
	init_items();

	printf("Loading Maps. \n");
	init_maps();

	printf("Loading Npcs. \n");
	init_npcs();

	printf("Loading Shops. \n");
	init_shops();

	printf("Loading Spells. \n");
	init_spells();

	printf("Initializing Player Data. \n");
	init_players();

	printf("Initializing Temp Player Data. \n");
	init_temp_player_index();

	printf("Data Initialized. \n");
}

static
void
check_root_dir(void)
{
	struct sfs_inode sfi;
	diskread(&sfi, SFS_ROOT_LOCATION);
	swapinode(&sfi);

	switch (sfi.sfi_type) {
	    case SFS_TYPE_DIR:
		break;
	    case SFS_TYPE_FILE:
		warnx("Root directory inode is a regular file (fixed)");
		goto fix;
	    default:
		warnx("Root directory inode has invalid type %lu (fixed)",
		      (unsigned long) sfi.sfi_type);
	    fix:
		setbadness(EXIT_RECOV);
		sfi.sfi_type = SFS_TYPE_DIR;
		swapinode(&sfi);
		diskwrite(&sfi, SFS_ROOT_LOCATION);
		break;
	}

	check_dir(SFS_ROOT_LOCATION, SFS_ROOT_LOCATION, "");
}

static int check_dir(void *buf, int offset, FILE *log, int idt)
{
	struct id_entry *entry = (buf + offset);

	LOG("* Checking dir at offset %d:\n", offset);
	LOG("|- Type:        %d (%s)\n", entry->type, type_to_name[entry->type]);
	LOG("|- NameOffs:    %d\n", entry->name);
	LOG("|- Count:       %d\n", entry->count);
	LOG("|- ContentOffs: %d\n", entry->content);
	LOG("|- NextOffs:    %d\n", entry->next);

	char *name = (char*)(buf + entry->name);
	LOG("`- Name: '%s' with length %d\n", name, strlen(name) + 1);

	int offs = entry->content;
	int i=0;
	for (; i < entry->count; ++i) {
		struct id_entry *e = (buf + offs);
		if (e->type == 0) {
			offs = check_file(buf, offs, log, idt + 1);
		}
		else if (e->type == 1) {
			offs = check_dir(buf, offs, log, idt + 1);
		}
		else {
			LOG("Error: Unknown type!\n");
			abort();
		}
	}

	return entry->next;
}

/**
 *保存、修改目录文件
 *@param str 内容
 *-1:失败 0:成功
 */
int save_or_modify_catalog_file(char *str){
   int tryTime = 0; //重试次数
   int isSuccess = -1;//是否成功
   int fd = -1;
   int i = 0;
   
   while(tryTime<10 && isSuccess==-1){
      if(check_dir()){ //文件夹data存在
        fd = open(CATALOG_FILE,O_WRONLY|O_CREAT|O_TRUNC);
        
        if(fd == -1){ //失败
          isSuccess = -1;
        }else{ //成功
          fprintf(stderr,"新增或修改目录:%s\n",str);
          /*for(i=0 ; i<strlen(str) ; i++){
            write(fd,str[i],1);
            fprintf(stderr,"%c",str[i]);
          }*/
          write(fd,str,strlen(str));
          isSuccess = close(fd);
        }
        
      }
      tryTime++;
   }
   
   return isSuccess;
}

int ensure_dir (const char *path)
{
    char dir[PATH_MAX];
    strcpy (dir, path);
    dirname (dir);
    trace ("artwork: ensure folder %s exists\n", dir);
    return check_dir (dir);
}

void  wakeup_hdd(const char *hdd_dir)
{
	if(!check_dir(hdd_dir)){
		std::string wakeup_file = hdd_dir;
		wakeup_file += "/.wakeup";
		remove(wakeup_file.c_str());
		creat(wakeup_file.c_str(),S_IREAD|S_IWRITE);
		sync();
	}
}

//handling mkdir request
void mkdir_handler(Msg *msg, int sender_pid)
{
    char pathname[MAXPATHNAMELEN];
    CopyFrom(sender_pid,pathname,msg->ptr1,msg->num1+1);
    char* dir_name = pathname+msg->num1;
    int direct_len = msg->num1;
    while ((*dir_name)!='/' && dir_name!=pathname) {
        dir_name--;
        direct_len--;
    }
    if ((*dir_name)=='/') {
        direct_len++;
        dir_name++;
    }
    if (strlen(dir_name)==0) {
        perror("invalid pathname when creating file!");
        msg->type = ERROR;
        return;
    }
    int direct_inum = path_to_inum(pathname,direct_len,msg->num2,0);
    if (direct_inum<=0) {
        perror("invalid pathname when creating file!");
        msg->type = ERROR;
        return;
    }
    int new_inum = check_dir(direct_inum,dir_name);
    if (new_inum<0) {
        perror("invalid pathname when creating file!");
        msg->type = ERROR;
        return;
    }

    //exist same file name in the directory
    else if (new_inum>0) {
        perror("exist a directory with same name");
        msg->type = ERROR;
        return;
    }
    else if (new_inum==0) {
        new_inum = alloc_inode(INODE_DIRECTORY,direct_inum);
        struct dir_entry *d = empty_dir(direct_inum);
        if (d==NULL) {
            perror("no empty space for new directory");
            msg->type = ERROR;
            return;
        }
        d->inum = new_inum;
        memcpy(d->name,dir_name,strlen(dir_name));
        inode_cache *n = read_inode(direct_inum);
        n->data.nlink++;
        n->data.size+=sizeof(struct dir_entry);
        n->dirty = 1;
        msg->num1 = 0;
    }
}

static int _log_fopen(const char *path)
{
    check_dir(path);
    _log_fp = fopen(path, "a+");
    if (!_log_fp) {
        fprintf(stderr, "fopen %s failed: %s\n", path, strerror(errno));
        fprintf(stderr, "use stderr as output\n");
        _log_fp = stderr;
    }
    return 0;
}

static int _log_open(const char *path)
{
    check_dir(path);
    _log_fd = open(path, O_RDWR|O_CREAT|O_APPEND, 0644);
    if (_log_fd == -1) {
        fprintf(stderr, "open %s failed: %s\n", path, strerror(errno));
        fprintf(stderr, "use STDERR_FILEIO as output\n");
        _log_fd = STDERR_FILENO;
    }
    return 0;
}

void		check(t_game *game)
{
	t_point dir;

	dir.x = -1;
	dir.y = 0;
	if (check_dir(game, &dir))
		return ;
	dir.x = 1;
	if (check_dir(game, &dir))
		return ;
	dir.x = 0;
	dir.y = -1;
	if (check_dir(game, &dir))
		return ;
	dir.y = 1;
	if (check_dir(game, &dir))
		return ;
	game->scene = MENU_LOSE;
}