package main

import (
	"log"
	"os"
    "context"
    "syscall"
	"github.com/hanwen/go-fuse/v2/fs"
	"github.com/hanwen/go-fuse/v2/fuse"
)

type ITProperty struct {
	name string
	Ino uint64
}

type ITNode struct {
	fs.Inode
	kind int
	Ino uint64
}

var properties = []ITProperty {
	ITProperty{"heartrate", 2},
	ITProperty{"battery", 3},
	ITProperty{"motion", 4},
	ITProperty{"stepcount", 5},
	ITProperty{"version", 6},
	ITProperty{"address", 7},
}

var _ = (fs.NodeReaddirer)((*ITNode)(nil))

// Readdir is part of the NodeReaddirer interface
func (n *ITNode) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
	switch n.kind {
	case 0:
		// root folder
		r := make([]fuse.DirEntry, 2)
		r[0] = fuse.DirEntry{
			Name: "device",
			Ino:  0,
			Mode: fuse.S_IFDIR,
		}
		r[1] = fuse.DirEntry{
			Name: "fs",
			Ino:  1,
			Mode: fuse.S_IFDIR,
		}
		return fs.NewListDirStream(r), 0

	case 1:
		// device folder
		r := make([]fuse.DirEntry, 6)
		for ind, value := range properties {
			r[ind] = fuse.DirEntry{
				Name: value.name,
				Ino:  value.Ino,
				Mode: fuse.S_IFREG,
			}
		}

		return fs.NewListDirStream(r), 0
	}
	r := make([]fuse.DirEntry, 0)
	return fs.NewListDirStream(r), 0
}

var _ = (fs.NodeLookuper)((*ITNode)(nil))
func (n *ITNode) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
	switch n.kind {
	case 0:
		// root folder
		if name == "device" {
			stable := fs.StableAttr{
				Mode: fuse.S_IFDIR,
				Ino: uint64(0),
			}
			operations := &ITNode{kind: 1, Ino: 0}
			child := n.NewInode(ctx, operations, stable)
			return child, 0
		} else if name == "fs" {
			stable := fs.StableAttr{
				Mode: fuse.S_IFDIR,
				Ino: uint64(1),
			}
			operations := &ITNode{kind: 2, Ino: 1}
			child := n.NewInode(ctx, operations, stable)
			return child, 0
		}
	case 1:
		// device folder
		for _, value := range properties {
			if value.name == name {
				stable := fs.StableAttr{
					Mode: fuse.S_IFREG,
					Ino: uint64(value.Ino),
				}
				operations := &ITNode{kind: 3, Ino: value.Ino}
				child := n.NewInode(ctx, operations, stable)
				return child, 0
			}
		}
		return nil, syscall.ENOENT
	}
	return nil, syscall.ENOENT
}

type bytesFileHandle struct {
	content []byte
}
var _ = (fs.FileReader)((*bytesFileHandle)(nil))

func (fh *bytesFileHandle) Read(ctx context.Context, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
	end := off + int64(len(dest))
	if end > int64(len(fh.content)) {
		end = int64(len(fh.content))
	}
	return fuse.ReadResultData(fh.content[off:end]), 0
}

var _ = (fs.NodeOpener)((*ITNode)(nil))
func (f *ITNode) Open(ctx context.Context, openFlags uint32) (fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
	switch f.kind {
	case 3:
		// Device file

		// disallow writes
		if fuseFlags&(syscall.O_RDWR|syscall.O_WRONLY) != 0 {
			return nil, 0, syscall.EROFS
		}

		for _, value := range properties {
			if value.Ino == f.Ino {
				fh = &bytesFileHandle{
					content: []byte(value.name),
				}
				return fh, fuse.FOPEN_DIRECT_IO, 0
			}
		}
	}
	return nil, 0, syscall.EROFS
}

func main() {
	// This is where we'll mount the FS
	mntDir := "/tmp/x"
	os.Mkdir(mntDir, 0755)
	root := &ITNode{kind: 0}
	server, err := fs.Mount(mntDir, root, &fs.Options{
		MountOptions: fuse.MountOptions{
			// Set to true to see how the file system works.
			Debug: false,
		},
	})
	if err != nil {
		log.Panic(err)
	}

	log.Printf("Mounted on %s", mntDir)
	log.Printf("Unmount by calling 'fusermount -u %s'", mntDir)

	// Wait until unmount before exiting
	server.Wait()
}