package main

import (
	"C"
	"fmt"
	"io"
	"strings"
	"syscall"
	"unsafe"

	"golang.org/x/sys/unix"

	"libgocryptfs/v2/allocator"
	"libgocryptfs/v2/internal/configfile"
	"libgocryptfs/v2/internal/cryptocore"
	"libgocryptfs/v2/internal/nametransform"
	"libgocryptfs/v2/internal/syscallcompat"
)

func (volume *Volume) mkdirWithIv(dirfd int, cName string, mode uint32) error {
	// Between the creation of the directory and the creation of gocryptfs.diriv
	// the directory is inconsistent. Take the lock to prevent other readers
	// from seeing it.
	volume.dirIVLock.Lock()
	defer volume.dirIVLock.Unlock()
	err := unix.Mkdirat(dirfd, cName, mode)
	if err != nil {
		return err
	}
	dirfd2, err := syscallcompat.Openat(dirfd, cName, syscall.O_DIRECTORY|syscall.O_NOFOLLOW|syscallcompat.O_PATH, 0)
	if err == nil {
		// Create gocryptfs.diriv
		err = nametransform.WriteDirIVAt(dirfd2)
		syscall.Close(dirfd2)
	}
	if err != nil {
		// Delete inconsistent directory (missing gocryptfs.diriv!)
		syscallcompat.Unlinkat(dirfd, cName, unix.AT_REMOVEDIR)
	}
	return err
}

//export gcf_list_dir
func gcf_list_dir(sessionID int, dirName string) (*C.char, *C.int, C.int) {
	value, ok := OpenedVolumes.Load(sessionID)
	if !ok {
		return nil, nil, 0
	}
	volume := value.(*Volume)
	parentDirFd, cDirName, err := volume.prepareAtSyscallMyself(dirName)
	if err != nil {
		return nil, nil, 0
	}
	defer syscall.Close(parentDirFd)
	// Read ciphertext directory
	fd, err := syscallcompat.Openat(parentDirFd, cDirName, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
	if err != nil {
		return nil, nil, 0
	}
	defer syscall.Close(fd)
	cipherEntries, err := syscallcompat.Getdents(fd)
	if err != nil {
		return nil, nil, 0
	}
	// Get DirIV (stays nil if PlaintextNames is used)
	var cachedIV []byte
	if !volume.plainTextNames {
		// Read the DirIV from disk
		cachedIV, err = volume.nameTransform.ReadDirIVAt(fd)
		if err != nil {
			return nil, nil, 0
		}
	}
	// Decrypted directory entries
	var plain strings.Builder
	var modes []uint32
	// Filter and decrypt filenames
	for i := range cipherEntries {
		cName := cipherEntries[i].Name
		if dirName == "/" && cName == configfile.ConfDefaultName {
			// silently ignore "gocryptfs.conf" in the top level dir
			continue
		}
		if volume.plainTextNames {
			plain.WriteString(cipherEntries[i].Name + "\x00")
			modes = append(modes, cipherEntries[i].Mode)
			continue
		}
		if cName == nametransform.DirIVFilename {
			// silently ignore "gocryptfs.diriv" everywhere if dirIV is enabled
			continue
		}
		// Handle long file name
		isLong := nametransform.NameType(cName)
		if isLong == nametransform.LongNameContent {
			cNameLong, err := nametransform.ReadLongNameAt(fd, cName)
			if err != nil {
				continue
			}
			cName = cNameLong
		} else if isLong == nametransform.LongNameFilename {
			// ignore "gocryptfs.longname.*.name"
			continue
		}
		name, err := volume.nameTransform.DecryptName(cName, cachedIV)
		if err != nil {
			continue
		}
		// Override the ciphertext name with the plaintext name but reuse the rest
		// of the structure
		cipherEntries[i].Name = name
		plain.WriteString(cipherEntries[i].Name + "\x00")
		modes = append(modes, cipherEntries[i].Mode)
	}
	p := allocator.Malloc(len(modes))
	for i := 0; i < len(modes); i++ {
		offset := C.sizeof_int * uintptr(i)
		*(*C.int)(unsafe.Pointer(uintptr(p) + offset)) = (C.int)(modes[i])
	}
	return C.CString(plain.String()), (*C.int)(p), (C.int)(len(modes))
}

//export gcf_mkdir
func gcf_mkdir(sessionID int, path string, mode uint32) bool {
	value, ok := OpenedVolumes.Load(sessionID)
	if !ok {
		return false
	}
	volume := value.(*Volume)
	dirfd, cName, err := volume.prepareAtSyscall(path)
	if err != nil {
		return false
	}
	defer syscall.Close(dirfd)

	if volume.plainTextNames {
		err = unix.Mkdirat(dirfd, cName, mode)
		if err != nil {
			return false
		}
		var ust unix.Stat_t
		err = syscallcompat.Fstatat(dirfd, cName, &ust, unix.AT_SYMLINK_NOFOLLOW)
		if err != nil {
			return false
		}
	} else {
		// We need write and execute permissions to create gocryptfs.diriv.
		// Also, we need read permissions to open the directory (to avoid
		// race-conditions between getting and setting the mode).
		origMode := mode
		mode := mode | 0700

		// Handle long file name
		if nametransform.IsLongContent(cName) {
			// Create ".name"
			err = volume.nameTransform.WriteLongNameAt(dirfd, cName, path)
			if err != nil {
				return false
			}

			// Create directory
			err = volume.mkdirWithIv(dirfd, cName, mode)
			if err != nil {
				nametransform.DeleteLongNameAt(dirfd, cName)
				return false
			}
		} else {
			err = volume.mkdirWithIv(dirfd, cName, mode)
			if err != nil {
				return false
			}
		}

		fd, err := syscallcompat.Openat(dirfd, cName,
			syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
		if err != nil {
			return false
		}
		defer syscall.Close(fd)

		var st syscall.Stat_t
		err = syscall.Fstat(fd, &st)
		if err != nil {
			return false
		}

		// Fix permissions
		if origMode != mode {
			// Preserve SGID bit if it was set due to inheritance.
			origMode = uint32(st.Mode&^0777) | origMode
			syscall.Fchmod(fd, origMode)
		}
	}

	return true
}

//export gcf_rmdir
func gcf_rmdir(sessionID int, relPath string) bool {
	value, ok := OpenedVolumes.Load(sessionID)
	if !ok {
		return false
	}
	volume := value.(*Volume)
	parentDirFd, cName, err := volume.prepareAtSyscall(relPath)
	if err != nil {
		return false
	}
	defer syscall.Close(parentDirFd)
	if volume.plainTextNames {
		// Unlinkat with AT_REMOVEDIR is equivalent to Rmdir
		err = unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR)
		return errToBool(err)
	}
	dirfd, err := syscallcompat.Openat(parentDirFd, cName, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
	if err != nil {
		return false
	}
	defer syscall.Close(dirfd)
	// Check directory contents
	children, err := syscallcompat.Getdents(dirfd)
	if err == io.EOF {
		// The directory is empty
		err = unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR)
		return errToBool(err)
	}
	if err != nil {
		return false
	}
	// If the directory is not empty besides gocryptfs.diriv, do not even
	// attempt the dance around gocryptfs.diriv.
	if len(children) > 1 {
		return false
	}
	// Move "gocryptfs.diriv" to the parent dir as "gocryptfs.diriv.rmdir.XYZ"
	tmpName := fmt.Sprintf("%s.rmdir.%d", nametransform.DirIVFilename, cryptocore.RandUint64())
	// The directory is in an inconsistent state between rename and rmdir.
	// Protect against concurrent readers.
	volume.dirIVLock.Lock()
	defer volume.dirIVLock.Unlock()
	err = syscallcompat.Renameat(dirfd, nametransform.DirIVFilename, parentDirFd, tmpName)
	if err != nil {
		return false
	}
	// Actual Rmdir
	err = syscallcompat.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR)
	if err != nil {
		// This can happen if another file in the directory was created in the
		// meantime, undo the rename
		syscallcompat.Renameat(parentDirFd, tmpName, dirfd, nametransform.DirIVFilename)
		return errToBool(err)
	}
	// Delete "gocryptfs.diriv.rmdir.XYZ"
	syscallcompat.Unlinkat(parentDirFd, tmpName, 0)
	// Delete .name file
	if nametransform.IsLongContent(cName) {
		nametransform.DeleteLongNameAt(parentDirFd, cName)
	}
	volume.dirCache.Delete(relPath)
	return true
}