inode *minixfs_create_inode_for_path(file_system *fs, const char *path) {
    // Land ahoy!
	inode* new_inode = get_inode(fs, path);
    	inode_number inode_num = first_unused_inode(fs);
    	char* f = NULL;
    	inode* parent = parent_directory(fs, path, (const char**)&f);
    	int block_size = sizeof(data_block);
    	size_t inode_file_len = FILE_NAME_LENGTH + INODE_SIZE;
    	size_t inode_block_const = 16 * KILOBYTE;
    	char block[inode_file_len];

    	if (new_inode || inode_num == -1 || !valid_filename(f) || (parent->mode & 0700) != 0700) {
      	return NULL;
    	}

    	minixfs_dirent dirent;
    	dirent.name = f;
    	dirent.inode_num = inode_num;
    	make_string_from_dirent(block, dirent);

    	if (parent->size + inode_file_len <= NUM_DIRECT_BLOCKS * inode_block_const + NUM_INDIRECT_BLOCKS * inode_block_const) {

      		if (parent->indirect == -1) {
        		data_block_number unused_block = first_unused_data(fs);

       		 if (unused_block == -1) {
            		return NULL;
        	}

		set_data_used(fs, unused_block, 1);
        	parent->indirect = unused_block;
        	data_block_number* unused_block_ptr = (data_block_number*) (fs->data_root + unused_block);
        	data_block_number tmp_unused_block = first_unused_data(fs);

       		 if (tmp_unused_block == -1) {
            		return NULL;
        	 }

	        set_data_used(fs, tmp_unused_block, 1);
       		unused_block_ptr[0] = tmp_unused_block;
        	char* tmp_unused_block_ptr = (char*) (fs->data_root + tmp_unused_block);
        	memcpy(tmp_unused_block_ptr, block, inode_file_len);
      		}
      		else {
        		data_block_number* unused_block_ptr = (data_block_number*) (fs->data_root + parent->indirect);
        		if (parent->size % block_size) {
          			char* tmp_unused_block_ptr = (char*) (fs->data_root + unused_block_ptr[parent->size / block_size - NUM_DIRECT_BLOCKS]);
          			memcpy(tmp_unused_block_ptr, block, inode_file_len);
        		}
        		else {
          		data_block_number tmp_unused_block = first_unused_data(fs);
          		if (tmp_unused_block == -1) {
              			return NULL;
          		}

			set_data_used(fs, tmp_unused_block, 1);
          		unused_block_ptr[parent->size / block_size - NUM_DIRECT_BLOCKS] = tmp_unused_block;
          		char* tmp_unused_block_ptr = (char*) (fs->data_root + tmp_unused_block);
          		memcpy(tmp_unused_block_ptr, block, inode_file_len);
        		}
      		}
      		parent->size += inode_file_len;

    	}
	else if (parent->size + inode_file_len <= NUM_DIRECT_BLOCKS * inode_block_const) {
      		char* ptr = (char*) (fs->data_root + parent->direct[parent->size / block_size]);
     		 if (parent->size % block_size == 0) {
       		 	data_block_number unused_block = first_unused_data(fs);
        		if (unused_block == -1) {
            			return NULL;
          		}

			parent->direct[parent->size / block_size] = unused_block;
        		set_data_used(fs, unused_block, 1);
        		ptr = (char*) (fs->data_root + unused_block);
       			 memcpy(ptr, block, inode_file_len);
      		}
      		else {
       			 memcpy(ptr + (parent->size % block_size), block, inode_file_len);
      		}
      		parent->size += inode_file_len;
    	}
   	 else {
      		return NULL;
    	}
	inode* final_inode = fs->inode_root + inode_num;
    	init_inode(parent, final_inode);
   	return final_inode;
}