func writeFile(fs vfs.Filesystem, name string, flags int, mode os.FileMode, b []byte) (int, error) {
	f, err := fs.OpenFile(name, flags, mode)
	if err != nil {
		return 0, err
	}
	return f.Write(b)
}

func readFile(fs vfs.Filesystem, name string) ([]byte, error) {
	f, err := fs.OpenFile(name, os.O_RDONLY, 0)
	if err != nil {
		return nil, err
	}
	return ioutil.ReadAll(f)
}

func GetInputPath(fs vfs.Filesystem, env venv.Env) string {

	var fn string

	fn = env.Getenv("TF_STATE")
	if fn != "" {
		return fn
	}

	fn = env.Getenv("TI_TFSTATE")
	if fn != "" {
		return fn
	}

	fn = "terraform.tfstate"
	_, err := fs.Stat(fn)
	if err == nil {
		return fn
	}

	fn = ".terraform/terraform.tfstate"
	_, err = fs.Stat(fn)
	if err == nil {
		return fn
	}

	return ""
}

func ExampleMyFilesystem() {
	// Simply bootstrap your filesystem
	var fs vfs.Filesystem = MyFS()

	err := fs.Mkdir("/tmp", 0777)
	if err != nil {
		fatal("Error will be: Not implemented yet!")
	}
}

func ExampleMyWrapper() {

	// Disable Mkdirs on the OS Filesystem
	var fs vfs.Filesystem = NoNewDirs(vfs.OS())

	err := fs.Mkdir("/tmp", 0777)
	if err != nil {
		fatal("Mkdir disabled!")
	}
}

func ExampleOsFS_myWrapper() {

	// Disable Mkdirs on the OS Filesystem
	var fs vfs.Filesystem = NoNewDirs(vfs.OS())

	err := fs.Mkdir("/tmp", 0777)
	if err != nil {
		fmt.Printf("Mkdir disabled!\n")
	}
}

// port of ioutil.Writefile for vfs
func writeFile(fs vfs.Filesystem, filename string, data []byte, perm os.FileMode) error {
	f, err := fs.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
	if err != nil {
		return err
	}
	n, err := f.Write(data)
	if err == nil && n < len(data) {
		err = io.ErrShortWrite
	}
	if err1 := f.Close(); err == nil {
		err = err1
	}
	return err
}

func ExampleDummyFS() {
	// Simply bootstrap your filesystem
	var fs vfs.Filesystem = MyFS()

	// Your mkdir implementation
	fs.Mkdir("/tmp", 0777)

	// All necessary methods like OpenFile (therefor Create) are stubbed
	// and return the dummys error
	_, err := vfs.Create(fs, "/tmp/vfs/example.txt")
	if err != nil {
		fmt.Printf("Error will be: Not implemented yet!\n")
	}

}

func Example() {
	// Create a vfs accessing the filesystem of the underlying OS
	var osfs vfs.Filesystem = vfs.OS()
	osfs.Mkdir("/tmp", 0777)

	// Make the filesystem read-only:
	osfs = vfs.ReadOnly(osfs) // Simply wrap filesystems to change its behaviour

	// os.O_CREATE will fail and return vfs.ErrReadOnly
	// os.O_RDWR is supported but Write(..) on the file is disabled
	f, _ := osfs.OpenFile("/tmp/example.txt", os.O_RDWR, 0)

	// Return vfs.ErrReadOnly
	_, err := f.Write([]byte("Write on readonly fs?"))
	if err != nil {
		fmt.Errorf("Filesystem is read only!\n")
	}

	// Create a fully writable filesystem in memory
	mfs := memfs.Create()
	mfs.Mkdir("/root", 0777)

	// Create a vfs supporting mounts
	// The root fs is accessing the filesystem of the underlying OS
	fs := mountfs.Create(osfs)

	// Mount a memfs inside /memfs
	// /memfs may not exist
	fs.Mount(mfs, "/memfs")

	// This will create /testdir inside the memfs
	fs.Mkdir("/memfs/testdir", 0777)

	// This would create /tmp/testdir inside your OS fs
	// But the rootfs `osfs` is read-only
	fs.Mkdir("/tmp/testdir", 0777)
}

func listCollect(fs vfs.Filesystem, realPath, virtualPath string, filter FilterFile) ([]string, error) {
	files := []string{}
	contents, err := fs.ReadDir(realPath)
	if err != nil {
		return nil, err
	}
	sort.Sort(byName(contents))
	for _, content := range contents {
		if content.IsDir() {
			if filter(virtualPath+content.Name(), true) {
				subfiles, err := listCollect(fs, realPath+content.Name()+"/", virtualPath+content.Name()+"/", filter)
				if err != nil {
					return nil, err
				}
				files = append(files, subfiles...)
			}
		} else {
			if filter(virtualPath+content.Name(), false) {
				files = append(files, virtualPath+content.Name())
			}
		}
	}
	return files, nil
}

func TestInterface(t *testing.T) {
	var fs vfs.Filesystem
	fs = Create()
	fs.Mkdir("/tmp", 0777)
}