// -------------------------------------------------
// ----------------- FILESYSTEM---------------------
// -------------------------------------------------
// Implementation of a unix filesystem in memory.

import { LOG_9P } from '../src/const.js'
import { h } from '../src/lib.js'
import { dbg_assert, dbg_log } from '../src/log.js'
import * as marshall from '../lib/marshall.js'
import { EEXIST, ENOTEMPTY, ENOENT, EPERM } from './9p.js'
import {
    P9_LOCK_SUCCESS,
    P9_LOCK_BLOCKED,
    P9_LOCK_TYPE_UNLCK,
    P9_LOCK_TYPE_WRLCK,
    P9_LOCK_TYPE_RDLCK,
} from './9p.js'

import type { QID } from '../lib/marshall.js'

// FileStorageInterface describes a backend for reading/writing file data.
export interface FileStorageInterface {
    read(
        sha256sum: string,
        offset: number,
        count: number,
        file_size: number,
    ): Promise<Uint8Array | null>
    cache(sha256sum: string, data: Uint8Array): Promise<void>
    uncache(sha256sum: string): void
}

export const S_IRWXUGO = 0x1ff
export const S_IFMT = 0xf000
export const S_IFSOCK = 0xc000
export const S_IFLNK = 0xa000
export const S_IFREG = 0x8000
export const S_IFBLK = 0x6000
export const S_IFDIR = 0x4000
export const S_IFCHR = 0x2000

//var S_IFIFO  0010000
//var S_ISUID  0004000
//var S_ISGID  0002000
//var S_ISVTX  0001000

const _O_RDONLY = 0x0000 // open for reading only
const _O_WRONLY = 0x0001 // open for writing only
const _O_RDWR = 0x0002 // open for reading and writing
const _O_ACCMODE = 0x0003 // mask for above modes

export const STATUS_INVALID = -0x1
export const STATUS_OK = 0x0
export const STATUS_ON_STORAGE = 0x2
export const STATUS_UNLINKED = 0x4
export const STATUS_FORWARDING = 0x5

const texten = new TextEncoder()

const JSONFS_VERSION = 3

const JSONFS_IDX_NAME = 0
const JSONFS_IDX_SIZE = 1
const JSONFS_IDX_MTIME = 2
const JSONFS_IDX_MODE = 3
const JSONFS_IDX_UID = 4
const JSONFS_IDX_GID = 5
const JSONFS_IDX_TARGET = 6
const JSONFS_IDX_SHA256 = 6

export interface QIDCounter {
    last_qidnumber: number
}

export interface SearchPathResult {
    id: number
    parentid: number
    name: string
    forward_path: string | null
}

export class FSLockRegion {
    type: number = P9_LOCK_TYPE_UNLCK
    start: number = 0
    length: number = Infinity
    proc_id: number = -1
    client_id: string = ''

    get_state(): any[] {
        const state: (number | string)[] = []

        state[0] = this.type
        state[1] = this.start
        // Infinity is not JSON.stringify-able
        state[2] = this.length === Infinity ? 0 : this.length
        state[3] = this.proc_id
        state[4] = this.client_id

        return state
    }

    set_state(state: any[]): void {
        this.type = state[0]
        this.start = state[1]
        this.length = state[2] === 0 ? Infinity : state[2]
        this.proc_id = state[3]
        this.client_id = state[4]
    }

    clone(): FSLockRegion {
        const new_region = new FSLockRegion()
        new_region.set_state(this.get_state())
        return new_region
    }

    conflicts_with(region: FSLockRegion): boolean {
        if (
            this.proc_id === region.proc_id &&
            this.client_id === region.client_id
        )
            return false
        if (
            this.type === P9_LOCK_TYPE_UNLCK ||
            region.type === P9_LOCK_TYPE_UNLCK
        )
            return false
        if (
            this.type !== P9_LOCK_TYPE_WRLCK &&
            region.type !== P9_LOCK_TYPE_WRLCK
        )
            return false
        if (this.start + this.length <= region.start) return false
        if (region.start + region.length <= this.start) return false
        return true
    }

    is_alike(region: FSLockRegion): boolean {
        return (
            region.proc_id === this.proc_id &&
            region.client_id === this.client_id &&
            region.type === this.type
        )
    }

    may_merge_after(region: FSLockRegion): boolean {
        return (
            this.is_alike(region) && region.start + region.length === this.start
        )
    }
}

export class Inode {
    direntries: Map<string, number> = new Map()
    status: number = 0
    size: number = 0x0
    uid: number = 0x0
    gid: number = 0x0
    fid: number = 0
    ctime: number = 0
    atime: number = 0
    mtime: number = 0
    major: number = 0x0
    minor: number = 0x0
    symlink: string = ''
    mode: number = 0x01ed
    qid: QID
    caps: Uint8Array | undefined = undefined
    nlinks: number = 0
    sha256sum: string = ''
    locks: FSLockRegion[] = []

    // For forwarders:
    mount_id: number = -1
    foreign_id: number = -1

    constructor(qidnumber: number) {
        this.qid = {
            type: 0,
            version: 0,
            path: qidnumber,
        }
    }

    get_state(): any[] {
        const state: any[] = []
        state[0] = this.mode

        if ((this.mode & S_IFMT) === S_IFDIR) {
            state[1] = [...this.direntries]
        } else if ((this.mode & S_IFMT) === S_IFREG) {
            state[1] = this.sha256sum
        } else if ((this.mode & S_IFMT) === S_IFLNK) {
            state[1] = this.symlink
        } else if ((this.mode & S_IFMT) === S_IFSOCK) {
            state[1] = [this.minor, this.major]
        } else {
            state[1] = null
        }

        state[2] = this.locks
        state[3] = this.status
        state[4] = this.size
        state[5] = this.uid
        state[6] = this.gid
        state[7] = this.fid
        state[8] = this.ctime
        state[9] = this.atime
        state[10] = this.mtime
        state[11] = this.qid.version
        state[12] = this.qid.path
        state[13] = this.nlinks

        //state[23] = this.mount_id;
        //state[24] = this.foreign_id;
        //state[25] = this.caps; // currently not writable
        return state
    }

    set_state(state: any[]): void {
        this.mode = state[0]

        if ((this.mode & S_IFMT) === S_IFDIR) {
            this.direntries = new Map()
            for (const [name, entry] of state[1]) {
                this.direntries.set(name, entry)
            }
        } else if ((this.mode & S_IFMT) === S_IFREG) {
            this.sha256sum = state[1]
        } else if ((this.mode & S_IFMT) === S_IFLNK) {
            this.symlink = state[1]
        } else if ((this.mode & S_IFMT) === S_IFSOCK) {
            ;[this.minor, this.major] = state[1]
        } else {
            // Nothing
        }

        this.locks = []
        for (const lock_state of state[2]) {
            const lock = new FSLockRegion()
            lock.set_state(lock_state)
            this.locks.push(lock)
        }
        this.status = state[3]
        this.size = state[4]
        this.uid = state[5]
        this.gid = state[6]
        this.fid = state[7]
        this.ctime = state[8]
        this.atime = state[9]
        this.mtime = state[10]
        this.qid.type = (this.mode & S_IFMT) >> 8
        this.qid.version = state[11]
        this.qid.path = state[12]
        this.nlinks = state[13]

        //this.mount_id = state[23];
        //this.foreign_id = state[24];
        //this.caps = state[20];
    }
}

class FSMountInfo {
    fs: FS
    backtrack: Map<number, number>

    constructor(filesystem: FS) {
        this.fs = filesystem
        this.backtrack = new Map()
    }

    get_state(): any[] {
        const state: any[] = []

        state[0] = this.fs
        state[1] = [...this.backtrack]

        return state
    }

    set_state(state: any[]): void {
        this.fs = state[0]
        this.backtrack = new Map(state[1])
    }
}

interface JsonFS {
    version: number

    fsroot: any[]
    size: number
}

export class FS {
    inodes: Inode[]
    storage: FileStorageInterface
    qidcounter: QIDCounter
    inodedata: Record<number, Uint8Array>
    total_size: number
    used_size: number
    mounts: FSMountInfo[]

    constructor(storage: FileStorageInterface, qidcounter?: QIDCounter) {
        this.inodes = []
        this.storage = storage
        this.qidcounter = qidcounter || { last_qidnumber: 0 }
        this.inodedata = {}
        this.total_size = 256 * 1024 * 1024 * 1024
        this.used_size = 0
        this.mounts = []

        // root entry
        this.CreateDirectory('', -1)
    }

    get_state(): any[] {
        let state: any[] = []

        state[0] = this.inodes
        state[1] = this.qidcounter.last_qidnumber
        state[2] = []
        for (const [id, data] of Object.entries(this.inodedata)) {
            if ((this.inodes[Number(id)].mode & S_IFDIR) === 0) {
                state[2].push([id, data])
            }
        }
        state[3] = this.total_size
        state[4] = this.used_size
        state = state.concat(this.mounts)

        return state
    }

    set_state(state: any[]): void {
        this.inodes = state[0].map((s: any) => {
            const inode = new Inode(0)
            inode.set_state(s)
            return inode
        })
        this.qidcounter.last_qidnumber = state[1]
        this.inodedata = {}
        for (const [key, rawValue] of state[2]) {
            let value = rawValue
            if (value.buffer.byteLength !== value.byteLength) {
                // make a copy if we didn't get one
                value = value.slice()
            }

            this.inodedata[key] = value
        }
        this.total_size = state[3]
        this.used_size = state[4]
        this.mounts = state.slice(5)
    }

    // -----------------------------------------------------

    load_from_json(fs: JsonFS): void {
        dbg_assert(!!fs, 'Invalid fs passed to load_from_json')

        if (fs['version'] !== JSONFS_VERSION) {
            throw 'The filesystem JSON format has changed. Please recreate the filesystem JSON.'
        }

        const fsroot = fs['fsroot']
        this.used_size = fs['size']

        for (let i = 0; i < fsroot.length; i++) {
            this.LoadRecursive(fsroot[i], 0)
        }
    }

    private LoadRecursive(data: any[], parentid: number): void {
        const inode = this.CreateInode()

        const name = data[JSONFS_IDX_NAME]
        inode.size = data[JSONFS_IDX_SIZE]
        inode.mtime = data[JSONFS_IDX_MTIME]
        inode.ctime = inode.mtime
        inode.atime = inode.mtime
        inode.mode = data[JSONFS_IDX_MODE]
        inode.uid = data[JSONFS_IDX_UID]
        inode.gid = data[JSONFS_IDX_GID]

        const ifmt = inode.mode & S_IFMT

        if (ifmt === S_IFDIR) {
            this.PushInode(inode, parentid, name)
            this.LoadDir(this.inodes.length - 1, data[JSONFS_IDX_TARGET])
        } else if (ifmt === S_IFREG) {
            inode.status = STATUS_ON_STORAGE
            inode.sha256sum = data[JSONFS_IDX_SHA256]
            dbg_assert(!!inode.sha256sum)
            this.PushInode(inode, parentid, name)
        } else if (ifmt === S_IFLNK) {
            inode.symlink = data[JSONFS_IDX_TARGET]
            this.PushInode(inode, parentid, name)
        } else if (ifmt === S_IFSOCK) {
            // socket: ignore
        } else {
            dbg_log('Unexpected ifmt: ' + h(ifmt) + ' (' + name + ')', LOG_9P)
        }
    }

    private LoadDir(parentid: number, children: any[]): void {
        for (let i = 0; i < children.length; i++) {
            this.LoadRecursive(children[i], parentid)
        }
    }

    // -----------------------------------------------------

    private should_be_linked(inode: Inode): boolean {
        // Note: Non-root forwarder inode could still have a non-forwarder parent, so don't use
        // parent inode to check.
        return !this.is_forwarder(inode) || inode.foreign_id === 0
    }

    private link_under_dir(parentid: number, idx: number, name: string): void {
        const inode = this.inodes[idx]
        const parent_inode = this.inodes[parentid]

        dbg_assert(
            !this.is_forwarder(parent_inode),
            "Filesystem: Shouldn't link under fowarder parents",
        )
        dbg_assert(
            this.IsDirectory(parentid),
            "Filesystem: Can't link under non-directories",
        )
        dbg_assert(
            this.should_be_linked(inode),
            "Filesystem: Can't link across filesystems apart from their root",
        )
        dbg_assert(
            inode.nlinks >= 0,
            'Filesystem: Found negative nlinks value of ' + inode.nlinks,
        )
        dbg_assert(
            !parent_inode.direntries.has(name),
            "Filesystem: Name '" + name + "' is already taken",
        )

        parent_inode.direntries.set(name, idx)
        inode.nlinks++

        if (this.IsDirectory(idx)) {
            dbg_assert(
                !inode.direntries.has('..'),
                'Filesystem: Cannot link a directory twice',
            )

            if (!inode.direntries.has('.')) inode.nlinks++
            inode.direntries.set('.', idx)

            inode.direntries.set('..', parentid)
            parent_inode.nlinks++
        }
    }

    private unlink_from_dir(parentid: number, name: string): void {
        const idx = this.Search(parentid, name)
        const inode = this.inodes[idx]
        const parent_inode = this.inodes[parentid]

        dbg_assert(
            !this.is_forwarder(parent_inode),
            "Filesystem: Can't unlink from forwarders",
        )
        dbg_assert(
            this.IsDirectory(parentid),
            "Filesystem: Can't unlink from non-directories",
        )

        const exists = parent_inode.direntries.delete(name)
        if (!exists) {
            dbg_assert(
                false,
                "Filesystem: Can't unlink non-existent file: " + name,
            )
            return
        }

        inode.nlinks--

        if (this.IsDirectory(idx)) {
            dbg_assert(
                inode.direntries.get('..') === parentid,
                'Filesystem: Found directory with bad parent id',
            )

            inode.direntries.delete('..')
            parent_inode.nlinks--
        }

        dbg_assert(
            inode.nlinks >= 0,
            'Filesystem: Found negative nlinks value of ' + inode.nlinks,
        )
    }

    PushInode(inode: Inode, parentid: number, name: string): void {
        if (parentid !== -1) {
            this.inodes.push(inode)
            inode.fid = this.inodes.length - 1
            this.link_under_dir(parentid, inode.fid, name)
            return
        } else {
            if (this.inodes.length === 0) {
                // if root directory
                this.inodes.push(inode)
                inode.direntries.set('.', 0)
                inode.direntries.set('..', 0)
                inode.nlinks = 2
                return
            }
        }

        dbg_assert(
            false,
            'Error in Filesystem: Pushed inode with name = ' +
                name +
                ' has no parent',
        )
    }

    private divert(parentid: number, filename: string): number {
        const old_idx = this.Search(parentid, filename)
        const old_inode = this.inodes[old_idx]
        const new_inode = new Inode(-1)

        dbg_assert(
            !!old_inode,
            'Filesystem divert: name (' + filename + ') not found',
        )
        dbg_assert(
            this.IsDirectory(old_idx) || old_inode.nlinks <= 1,
            "Filesystem: can't divert hardlinked file '" +
                filename +
                "' with nlinks=" +
                old_inode.nlinks,
        )

        // Shallow copy is alright.
        Object.assign(new_inode, old_inode)

        const idx = this.inodes.length
        this.inodes.push(new_inode)
        new_inode.fid = idx

        // Relink references
        if (this.is_forwarder(old_inode)) {
            this.mounts[old_inode.mount_id].backtrack.set(
                old_inode.foreign_id,
                idx,
            )
        }
        if (this.should_be_linked(old_inode)) {
            this.unlink_from_dir(parentid, filename)
            this.link_under_dir(parentid, idx, filename)
        }

        // Update children
        if (this.IsDirectory(old_idx) && !this.is_forwarder(old_inode)) {
            for (const [name, child_id] of new_inode.direntries) {
                if (name === '.' || name === '..') continue
                if (this.IsDirectory(child_id)) {
                    this.inodes[child_id].direntries.set('..', idx)
                }
            }
        }

        // Relocate local data if any.
        this.inodedata[idx] = this.inodedata[old_idx]
        delete this.inodedata[old_idx]

        // Retire old reference information.
        old_inode.direntries = new Map()
        old_inode.nlinks = 0

        return idx
    }

    private copy_inode(src_inode: Inode, dest_inode: Inode): void {
        Object.assign(dest_inode, src_inode, {
            fid: dest_inode.fid,
            direntries: dest_inode.direntries,
            nlinks: dest_inode.nlinks,
        })
    }

    CreateInode(): Inode {
        const now = Math.round(Date.now() / 1000)
        const inode = new Inode(++this.qidcounter.last_qidnumber)
        inode.atime = inode.ctime = inode.mtime = now
        return inode
    }

    // Note: parentid = -1 for initial root directory.
    CreateDirectory(name: string, parentid: number): number {
        const parent_inode = this.inodes[parentid]
        if (parentid >= 0 && this.is_forwarder(parent_inode)) {
            const foreign_parentid = parent_inode.foreign_id
            const foreign_id = this.follow_fs(parent_inode).CreateDirectory(
                name,
                foreign_parentid,
            )
            return this.create_forwarder(parent_inode.mount_id, foreign_id)
        }
        const x = this.CreateInode()
        x.mode = 0x01ff | S_IFDIR
        if (parentid >= 0) {
            x.uid = this.inodes[parentid].uid
            x.gid = this.inodes[parentid].gid
            x.mode = (this.inodes[parentid].mode & 0x1ff) | S_IFDIR
        }
        x.qid.type = S_IFDIR >> 8
        this.PushInode(x, parentid, name)
        this.NotifyListeners(this.inodes.length - 1, 'newdir')
        return this.inodes.length - 1
    }

    CreateFile(filename: string, parentid: number): number {
        const parent_inode = this.inodes[parentid]
        if (this.is_forwarder(parent_inode)) {
            const foreign_parentid = parent_inode.foreign_id
            const foreign_id = this.follow_fs(parent_inode).CreateFile(
                filename,
                foreign_parentid,
            )
            return this.create_forwarder(parent_inode.mount_id, foreign_id)
        }
        const x = this.CreateInode()
        x.uid = this.inodes[parentid].uid
        x.gid = this.inodes[parentid].gid
        x.qid.type = S_IFREG >> 8
        x.mode = (this.inodes[parentid].mode & 0x1b6) | S_IFREG
        this.PushInode(x, parentid, filename)
        this.NotifyListeners(this.inodes.length - 1, 'newfile')
        return this.inodes.length - 1
    }

    CreateNode(
        filename: string,
        parentid: number,
        major: number,
        minor: number,
    ): number {
        const parent_inode = this.inodes[parentid]
        if (this.is_forwarder(parent_inode)) {
            const foreign_parentid = parent_inode.foreign_id
            const foreign_id = this.follow_fs(parent_inode).CreateNode(
                filename,
                foreign_parentid,
                major,
                minor,
            )
            return this.create_forwarder(parent_inode.mount_id, foreign_id)
        }
        const x = this.CreateInode()
        x.major = major
        x.minor = minor
        x.uid = this.inodes[parentid].uid
        x.gid = this.inodes[parentid].gid
        x.qid.type = S_IFSOCK >> 8
        x.mode = this.inodes[parentid].mode & 0x1b6
        this.PushInode(x, parentid, filename)
        return this.inodes.length - 1
    }

    CreateSymlink(filename: string, parentid: number, symlink: string): number {
        const parent_inode = this.inodes[parentid]
        if (this.is_forwarder(parent_inode)) {
            const foreign_parentid = parent_inode.foreign_id
            const foreign_id = this.follow_fs(parent_inode).CreateSymlink(
                filename,
                foreign_parentid,
                symlink,
            )
            return this.create_forwarder(parent_inode.mount_id, foreign_id)
        }
        const x = this.CreateInode()
        x.uid = this.inodes[parentid].uid
        x.gid = this.inodes[parentid].gid
        x.qid.type = S_IFLNK >> 8
        x.symlink = symlink
        x.mode = S_IFLNK
        this.PushInode(x, parentid, filename)
        return this.inodes.length - 1
    }

    async CreateTextFile(
        filename: string,
        parentid: number,
        str: string,
    ): Promise<number> {
        const parent_inode = this.inodes[parentid]
        if (this.is_forwarder(parent_inode)) {
            const foreign_parentid = parent_inode.foreign_id
            const foreign_id = await this.follow_fs(
                parent_inode,
            ).CreateTextFile(filename, foreign_parentid, str)
            return this.create_forwarder(parent_inode.mount_id, foreign_id)
        }
        const id = this.CreateFile(filename, parentid)
        const x = this.inodes[id]
        const data = new Uint8Array(str.length)
        x.size = str.length
        for (let j = 0; j < str.length; j++) {
            data[j] = str.charCodeAt(j)
        }
        await this.set_data(id, data)
        return id
    }

    async CreateBinaryFile(
        filename: string,
        parentid: number,
        buffer: Uint8Array,
    ): Promise<number> {
        const parent_inode = this.inodes[parentid]
        if (this.is_forwarder(parent_inode)) {
            const foreign_parentid = parent_inode.foreign_id
            const foreign_id = await this.follow_fs(
                parent_inode,
            ).CreateBinaryFile(filename, foreign_parentid, buffer)
            return this.create_forwarder(parent_inode.mount_id, foreign_id)
        }
        const id = this.CreateFile(filename, parentid)
        const x = this.inodes[id]
        const data = new Uint8Array(buffer.length)
        data.set(buffer)
        await this.set_data(id, data)
        x.size = buffer.length
        return id
    }

    async OpenInode(id: number, mode: number | undefined): Promise<void> {
        const inode = this.inodes[id]
        if (this.is_forwarder(inode)) {
            return await this.follow_fs(inode).OpenInode(inode.foreign_id, mode)
        }
        if ((inode.mode & S_IFMT) === S_IFDIR) {
            this.FillDirectory(id)
        }
    }

    async CloseInode(id: number): Promise<void> {
        const inode = this.inodes[id]
        if (this.is_forwarder(inode)) {
            return await this.follow_fs(inode).CloseInode(inode.foreign_id)
        }
        if (inode.status === STATUS_ON_STORAGE) {
            this.storage.uncache(inode.sha256sum)
        }
        if (inode.status === STATUS_UNLINKED) {
            inode.status = STATUS_INVALID
            await this.DeleteData(id)
        }
    }

    async Rename(
        olddirid: number,
        oldname: string,
        newdirid: number,
        newname: string,
    ): Promise<number> {
        if (olddirid === newdirid && oldname === newname) {
            return 0
        }
        const oldid = this.Search(olddirid, oldname)
        if (oldid === -1) {
            return -ENOENT
        }

        // For event notification near end of method.
        const oldpath = this.GetFullPath(olddirid) + '/' + oldname

        const newid = this.Search(newdirid, newname)
        if (newid !== -1) {
            const ret = this.Unlink(newdirid, newname)
            if (ret < 0) return ret
        }

        const idx = oldid // idx contains the id which we want to rename
        const inode = this.inodes[idx]
        const olddir = this.inodes[olddirid]
        const newdir = this.inodes[newdirid]

        if (!this.is_forwarder(olddir) && !this.is_forwarder(newdir)) {
            // Move inode within current filesystem.

            this.unlink_from_dir(olddirid, oldname)
            this.link_under_dir(newdirid, idx, newname)

            inode.qid.version++
        } else if (
            this.is_forwarder(olddir) &&
            olddir.mount_id === newdir.mount_id
        ) {
            // Move inode within the same child filesystem.

            const ret = await this.follow_fs(olddir).Rename(
                olddir.foreign_id,
                oldname,
                newdir.foreign_id,
                newname,
            )

            if (ret < 0) return ret
        } else if (this.is_a_root(idx)) {
            // The actual inode is a root of some descendant filesystem.
            // Moving mountpoint across fs not supported - needs to update all corresponding forwarders.
            dbg_log(
                'XXX: Attempted to move mountpoint (' + oldname + ') - skipped',
                LOG_9P,
            )
            return -EPERM
        } else if (!this.IsDirectory(idx) && this.GetInode(idx).nlinks > 1) {
            // Move hardlinked inode vertically in mount tree.
            dbg_log(
                'XXX: Attempted to move hardlinked file (' +
                    oldname +
                    ') ' +
                    'across filesystems - skipped',
                LOG_9P,
            )
            return -EPERM
        } else {
            // Jump between filesystems.

            // Can't work with both old and new inode information without first diverting the old
            // information into a new idx value.
            const diverted_old_idx = this.divert(olddirid, oldname)
            const old_real_inode = this.GetInode(idx)

            const data = await this.Read(
                diverted_old_idx,
                0,
                old_real_inode.size,
            )

            if (this.is_forwarder(newdir)) {
                // Create new inode.
                const foreign_fs = this.follow_fs(newdir)
                const foreign_id = this.IsDirectory(diverted_old_idx)
                    ? foreign_fs.CreateDirectory(newname, newdir.foreign_id)
                    : foreign_fs.CreateFile(newname, newdir.foreign_id)

                const new_real_inode = foreign_fs.GetInode(foreign_id)
                this.copy_inode(old_real_inode, new_real_inode)

                // Point to this new location.
                this.set_forwarder(idx, newdir.mount_id, foreign_id)
            } else {
                // Replace current forwarder with real inode.
                this.delete_forwarder(inode)
                this.copy_inode(old_real_inode, inode)

                // Link into new location in this filesystem.
                this.link_under_dir(newdirid, idx, newname)
            }

            // Rewrite data to newly created destination.
            await this.ChangeSize(idx, old_real_inode.size)
            if (data && data.length) {
                await this.Write(idx, 0, data.length, data)
            }

            // Move children to newly created destination.
            if (this.IsDirectory(idx)) {
                for (const child_filename of this.GetChildren(
                    diverted_old_idx,
                )) {
                    const ret = await this.Rename(
                        diverted_old_idx,
                        child_filename,
                        idx,
                        child_filename,
                    )
                    if (ret < 0) return ret
                }
            }

            // Perform destructive changes only after migration succeeded.
            await this.DeleteData(diverted_old_idx)
            const ret = this.Unlink(olddirid, oldname)
            if (ret < 0) return ret
        }

        this.NotifyListeners(idx, 'rename', { oldpath: oldpath })

        return 0
    }

    async Write(
        id: number,
        offset: number,
        count: number,
        buffer: Uint8Array | null,
    ): Promise<void> {
        this.NotifyListeners(id, 'write')
        const inode = this.inodes[id]

        if (this.is_forwarder(inode)) {
            const foreign_id = inode.foreign_id
            await this.follow_fs(inode).Write(foreign_id, offset, count, buffer)
            return
        }

        let data = await this.get_buffer(id)

        if (!data || data.length < offset + count) {
            await this.ChangeSize(id, Math.floor(((offset + count) * 3) / 2))
            inode.size = offset + count
            data = await this.get_buffer(id)
        } else if (inode.size < offset + count) {
            inode.size = offset + count
        }
        if (buffer && data) {
            data.set(buffer.subarray(0, count), offset)
        }
        if (data) {
            await this.set_data(id, data)
        }
    }

    async Read(
        inodeid: number,
        offset: number,
        count: number,
    ): Promise<Uint8Array | null> {
        const inode = this.inodes[inodeid]
        if (this.is_forwarder(inode)) {
            const foreign_id = inode.foreign_id
            return await this.follow_fs(inode).Read(foreign_id, offset, count)
        }

        return await this.get_data(inodeid, offset, count)
    }

    Search(parentid: number, name: string): number {
        const parent_inode = this.inodes[parentid]

        if (this.is_forwarder(parent_inode)) {
            const foreign_parentid = parent_inode.foreign_id
            const foreign_id = this.follow_fs(parent_inode).Search(
                foreign_parentid,
                name,
            )
            if (foreign_id === -1) return -1
            return this.get_forwarder(parent_inode.mount_id, foreign_id)
        }

        const childid = parent_inode.direntries.get(name)
        return childid === undefined ? -1 : childid
    }

    CountUsedInodes(): number {
        let count = this.inodes.length
        for (const { fs, backtrack } of this.mounts) {
            count += fs.CountUsedInodes()

            // Forwarder inodes don't count.
            count -= backtrack.size
        }
        return count
    }

    CountFreeInodes(): number {
        let count = 1024 * 1024
        for (const { fs } of this.mounts) {
            count += fs.CountFreeInodes()
        }
        return count
    }

    GetTotalSize(): number {
        let size = this.used_size
        for (const { fs } of this.mounts) {
            size += fs.GetTotalSize()
        }
        return size
    }

    GetSpace(): number {
        let size = this.total_size
        for (const { fs } of this.mounts) {
            size += fs.GetSpace()
        }
        return size
    }

    GetDirectoryName(idx: number): string {
        const parent_inode = this.inodes[this.GetParent(idx)]

        if (this.is_forwarder(parent_inode)) {
            return this.follow_fs(parent_inode).GetDirectoryName(
                this.inodes[idx].foreign_id,
            )
        }

        // Root directory.
        if (!parent_inode) return ''

        for (const [name, childid] of parent_inode.direntries) {
            if (childid === idx) return name
        }

        dbg_assert(
            false,
            "Filesystem: Found directory inode whose parent doesn't link to it",
        )
        return ''
    }

    GetFullPath(idx: number): string {
        dbg_assert(
            this.IsDirectory(idx),
            'Filesystem: Cannot get full path of non-directory inode',
        )

        let path = ''

        while (idx !== 0) {
            path = '/' + this.GetDirectoryName(idx) + path
            idx = this.GetParent(idx)
        }
        return path.substring(1)
    }

    Link(parentid: number, targetid: number, name: string): number {
        if (this.IsDirectory(targetid)) {
            return -EPERM
        }

        const parent_inode = this.inodes[parentid]
        const inode = this.inodes[targetid]

        if (this.is_forwarder(parent_inode)) {
            if (
                !this.is_forwarder(inode) ||
                inode.mount_id !== parent_inode.mount_id
            ) {
                dbg_log(
                    'XXX: Attempted to hardlink a file into a child filesystem - skipped',
                    LOG_9P,
                )
                return -EPERM
            }
            return this.follow_fs(parent_inode).Link(
                parent_inode.foreign_id,
                inode.foreign_id,
                name,
            )
        }

        if (this.is_forwarder(inode)) {
            dbg_log(
                'XXX: Attempted to hardlink file across filesystems - skipped',
                LOG_9P,
            )
            return -EPERM
        }

        this.link_under_dir(parentid, targetid, name)
        return 0
    }

    Unlink(parentid: number, name: string): number {
        if (name === '.' || name === '..') {
            // Also guarantees that root cannot be deleted.
            return -EPERM
        }
        const idx = this.Search(parentid, name)
        const inode = this.inodes[idx]
        const parent_inode = this.inodes[parentid]

        // forward if necessary
        if (this.is_forwarder(parent_inode)) {
            dbg_assert(
                this.is_forwarder(inode),
                'Children of forwarders should be forwarders',
            )

            const foreign_parentid = parent_inode.foreign_id
            return this.follow_fs(parent_inode).Unlink(foreign_parentid, name)

            // Keep the forwarder dangling - file is still accessible.
        }

        if (this.IsDirectory(idx) && !this.IsEmpty(idx)) {
            return -ENOTEMPTY
        }

        this.unlink_from_dir(parentid, name)

        if (inode.nlinks === 0) {
            // don't delete the content. The file is still accessible
            inode.status = STATUS_UNLINKED
            this.NotifyListeners(idx, 'delete')
        }
        return 0
    }

    async DeleteData(idx: number): Promise<void> {
        const inode = this.inodes[idx]
        if (this.is_forwarder(inode)) {
            await this.follow_fs(inode).DeleteData(inode.foreign_id)
            return
        }
        inode.size = 0
        delete this.inodedata[idx]
    }

    private async get_buffer(idx: number): Promise<Uint8Array | null> {
        const inode = this.inodes[idx]
        dbg_assert(
            !!inode,
            `Filesystem get_buffer: idx ${idx} does not point to an inode`,
        )

        if (this.inodedata[idx]) {
            return this.inodedata[idx]
        } else if (inode.status === STATUS_ON_STORAGE) {
            dbg_assert(
                !!inode.sha256sum,
                'Filesystem get_data: found inode on server without sha256sum',
            )
            return await this.storage.read(
                inode.sha256sum,
                0,
                inode.size,
                inode.size,
            )
        } else {
            return null
        }
    }

    private async get_data(
        idx: number,
        offset: number,
        count: number,
    ): Promise<Uint8Array | null> {
        const inode = this.inodes[idx]
        dbg_assert(
            !!inode,
            `Filesystem get_data: idx ${idx} does not point to an inode`,
        )

        if (this.inodedata[idx]) {
            return this.inodedata[idx].subarray(offset, offset + count)
        } else if (inode.status === STATUS_ON_STORAGE) {
            dbg_assert(
                !!inode.sha256sum,
                'Filesystem get_data: found inode on server without sha256sum',
            )
            return await this.storage.read(
                inode.sha256sum,
                offset,
                count,
                inode.size,
            )
        } else {
            return null
        }
    }

    private async set_data(idx: number, buffer: Uint8Array): Promise<void> {
        // Current scheme: Save all modified buffers into local inodedata.
        this.inodedata[idx] = buffer
        if (this.inodes[idx].status === STATUS_ON_STORAGE) {
            this.inodes[idx].status = STATUS_OK
            this.storage.uncache(this.inodes[idx].sha256sum)
        }
    }

    GetInode(idx: number): Inode {
        dbg_assert(!isNaN(idx), 'Filesystem GetInode: NaN idx')
        dbg_assert(
            idx >= 0 && idx < this.inodes.length,
            'Filesystem GetInode: out of range idx:' + idx,
        )

        const inode = this.inodes[idx]
        if (this.is_forwarder(inode)) {
            return this.follow_fs(inode).GetInode(inode.foreign_id)
        }

        return inode
    }

    async ChangeSize(idx: number, newsize: number): Promise<void> {
        const inode = this.GetInode(idx)
        const temp = await this.get_data(idx, 0, inode.size)
        if (newsize === inode.size) return
        const data = new Uint8Array(newsize)
        inode.size = newsize
        if (temp) {
            const size = Math.min(temp.length, inode.size)
            data.set(temp.subarray(0, size), 0)
        }
        await this.set_data(idx, data)
    }

    SearchPath(path: string): SearchPathResult {
        path = path.replace('//', '/')
        const walk = path.split('/')
        if (walk.length > 0 && walk[walk.length - 1].length === 0) walk.pop()
        if (walk.length > 0 && walk[0].length === 0) walk.shift()
        const n = walk.length

        let parentid = -1
        let id = 0
        let forward_path: string | null = null
        let i
        for (i = 0; i < n; i++) {
            parentid = id
            id = this.Search(parentid, walk[i])
            if (!forward_path && this.is_forwarder(this.inodes[parentid])) {
                forward_path = '/' + walk.slice(i).join('/')
            }
            if (id === -1) {
                if (i < n - 1)
                    return {
                        id: -1,
                        parentid: -1,
                        name: walk[i],
                        forward_path,
                    }
                return {
                    id: -1,
                    parentid: parentid,
                    name: walk[i],
                    forward_path,
                }
            }
        }
        return { id: id, parentid: parentid, name: walk[i], forward_path }
    }

    // -----------------------------------------------------

    GetRecursiveList(
        dirid: number,
        list: { parentid: number; name: string }[],
    ): void {
        if (this.is_forwarder(this.inodes[dirid])) {
            const foreign_fs = this.follow_fs(this.inodes[dirid])
            const foreign_dirid = this.inodes[dirid].foreign_id
            const mount_id = this.inodes[dirid].mount_id

            const foreign_start = list.length
            foreign_fs.GetRecursiveList(foreign_dirid, list)
            for (let i = foreign_start; i < list.length; i++) {
                list[i].parentid = this.get_forwarder(
                    mount_id,
                    list[i].parentid,
                )
            }
            return
        }
        for (const [name, id] of this.inodes[dirid].direntries) {
            if (name !== '.' && name !== '..') {
                list.push({ parentid: dirid, name })
                if (this.IsDirectory(id)) {
                    this.GetRecursiveList(id, list)
                }
            }
        }
    }

    RecursiveDelete(path: string): void {
        const toDelete: { parentid: number; name: string }[] = []
        const ids = this.SearchPath(path)
        if (ids.id === -1) return

        this.GetRecursiveList(ids.id, toDelete)

        for (let i = toDelete.length - 1; i >= 0; i--) {
            const ret = this.Unlink(toDelete[i].parentid, toDelete[i].name)
            dbg_assert(
                ret === 0,
                'Filesystem RecursiveDelete failed at parent=' +
                    toDelete[i].parentid +
                    ", name='" +
                    toDelete[i].name +
                    "' with error code: " +
                    -ret,
            )
        }
    }

    DeleteNode(path: string): void {
        const ids = this.SearchPath(path)
        if (ids.id === -1) return

        if ((this.inodes[ids.id].mode & S_IFMT) === S_IFREG) {
            const ret = this.Unlink(ids.parentid, ids.name)
            dbg_assert(
                ret === 0,
                'Filesystem DeleteNode failed with error code: ' + -ret,
            )
        } else if ((this.inodes[ids.id].mode & S_IFMT) === S_IFDIR) {
            this.RecursiveDelete(path)
            const ret = this.Unlink(ids.parentid, ids.name)
            dbg_assert(
                ret === 0,
                'Filesystem DeleteNode failed with error code: ' + -ret,
            )
        }
    }

    NotifyListeners(_id: number, _action: string, _info?: any): void {
        //if(info==undefined)
        //    info = {};
        //var path = this.GetFullPath(id);
        //if (this.watchFiles[path] === true && action=='write') {
        //  message.Send("WatchFileEvent", path);
        //}
        //for (var directory of this.watchDirectories) {
        //    if (this.watchDirectories.hasOwnProperty(directory)) {
        //        var indexOf = path.indexOf(directory)
        //        if(indexOf === 0 || indexOf === 1)
        //            message.Send("WatchDirectoryEvent", {path: path, event: action, info: info});
        //    }
        //}
    }

    Check(): void {
        for (let i = 1; i < this.inodes.length; i++) {
            if (this.inodes[i].status === STATUS_INVALID) continue

            const inode = this.GetInode(i)
            if (inode.nlinks < 0) {
                dbg_log(
                    'Error in filesystem: negative nlinks=' +
                        inode.nlinks +
                        ' at id =' +
                        i,
                    LOG_9P,
                )
            }

            if (this.IsDirectory(i)) {
                const inode = this.GetInode(i)
                if (this.IsDirectory(i) && this.GetParent(i) < 0) {
                    dbg_log(
                        'Error in filesystem: negative parent id ' + i,
                        LOG_9P,
                    )
                }
                for (const [name, id] of inode.direntries) {
                    if (name.length === 0) {
                        dbg_log(
                            'Error in filesystem: inode with no name and id ' +
                                id,
                            LOG_9P,
                        )
                    }

                    for (const c of name) {
                        if (c < ' ') {
                            dbg_log(
                                'Error in filesystem: Unallowed char in filename',
                                LOG_9P,
                            )
                        }
                    }
                }
            }
        }
    }

    FillDirectory(dirid: number): void {
        const inode = this.inodes[dirid]
        if (this.is_forwarder(inode)) {
            // XXX: The ".." of a mountpoint should point back to an inode in this fs.
            // Otherwise, ".." gets the wrong qid and mode.
            this.follow_fs(inode).FillDirectory(inode.foreign_id)
            return
        }

        let size = 0
        for (const name of inode.direntries.keys()) {
            size += 13 + 8 + 1 + 2 + texten.encode(name).length
        }
        const data = (this.inodedata[dirid] = new Uint8Array(size))
        inode.size = size

        let offset = 0x0
        for (const [name, id] of inode.direntries) {
            const child = this.GetInode(id)
            offset += marshall.Marshall(
                ['Q', 'd', 'b', 's'],
                [
                    child.qid,
                    offset + 13 + 8 + 1 + 2 + texten.encode(name).length,
                    child.mode >> 12,
                    name,
                ],
                data,
                offset,
            )
        }
    }

    RoundToDirentry(dirid: number, offset_target: number): number {
        const data = this.inodedata[dirid]
        dbg_assert(
            !!data,
            `FS directory data for dirid=${dirid} should be generated`,
        )
        dbg_assert(
            data.length > 0,
            'FS directory should have at least an entry',
        )

        if (offset_target >= data.length) {
            return data.length
        }

        let offset = 0
        while (true) {
            const next_offset = marshall.Unmarshall(['Q', 'd'], data, {
                offset,
            })[1]
            if (next_offset > offset_target) break
            offset = next_offset
        }

        return offset
    }

    IsDirectory(idx: number): boolean {
        const inode = this.inodes[idx]
        if (this.is_forwarder(inode)) {
            return this.follow_fs(inode).IsDirectory(inode.foreign_id)
        }
        return (inode.mode & S_IFMT) === S_IFDIR
    }

    IsEmpty(idx: number): boolean {
        const inode = this.inodes[idx]
        if (this.is_forwarder(inode)) {
            return this.follow_fs(inode).IsDirectory(inode.foreign_id)
        }
        for (const name of inode.direntries.keys()) {
            if (name !== '.' && name !== '..') return false
        }
        return true
    }

    GetChildren(idx: number): string[] {
        dbg_assert(
            this.IsDirectory(idx),
            'Filesystem: cannot get children of non-directory inode',
        )
        const inode = this.inodes[idx]
        if (this.is_forwarder(inode)) {
            return this.follow_fs(inode).GetChildren(inode.foreign_id)
        }
        const children: string[] = []
        for (const name of inode.direntries.keys()) {
            if (name !== '.' && name !== '..') {
                children.push(name)
            }
        }
        return children
    }

    GetParent(idx: number): number {
        dbg_assert(
            this.IsDirectory(idx),
            'Filesystem: cannot get parent of non-directory inode',
        )

        const inode = this.inodes[idx]

        if (this.should_be_linked(inode)) {
            return inode.direntries.get('..') ?? -1
        } else {
            const foreign_dirid = this.follow_fs(inode).GetParent(
                inode.foreign_id,
            )
            dbg_assert(
                foreign_dirid !== -1,
                'Filesystem: should not have invalid parent ids',
            )
            return this.get_forwarder(inode.mount_id, foreign_dirid)
        }
    }

    // -----------------------------------------------------

    // only support for security.capabilities
    PrepareCAPs(id: number): number {
        const inode = this.GetInode(id)
        if (inode.caps) return inode.caps.length
        inode.caps = new Uint8Array(20)
        // format is little endian
        // note: getxattr returns -EINVAL if using revision 1 format.
        // note: getxattr presents revision 3 as revision 2 when revision 3 is not needed.
        // magic_etc (revision=0x02: 20 bytes)
        inode.caps[0] = 0x00
        inode.caps[1] = 0x00
        inode.caps[2] = 0x00
        inode.caps[3] = 0x02

        // lower
        // permitted (first 32 capabilities)
        inode.caps[4] = 0xff
        inode.caps[5] = 0xff
        inode.caps[6] = 0xff
        inode.caps[7] = 0xff
        // inheritable (first 32 capabilities)
        inode.caps[8] = 0xff
        inode.caps[9] = 0xff
        inode.caps[10] = 0xff
        inode.caps[11] = 0xff

        // higher
        // permitted (last 6 capabilities)
        inode.caps[12] = 0x3f
        inode.caps[13] = 0x00
        inode.caps[14] = 0x00
        inode.caps[15] = 0x00
        // inheritable (last 6 capabilities)
        inode.caps[16] = 0x3f
        inode.caps[17] = 0x00
        inode.caps[18] = 0x00
        inode.caps[19] = 0x00

        return inode.caps.length
    }

    // -----------------------------------------------------

    private set_forwarder(
        idx: number,
        mount_id: number,
        foreign_id: number,
    ): void {
        const inode = this.inodes[idx]

        dbg_assert(
            inode.nlinks === 0,
            'Filesystem: attempted to convert an inode into forwarder before unlinking the inode',
        )

        if (this.is_forwarder(inode)) {
            this.mounts[inode.mount_id].backtrack.delete(inode.foreign_id)
        }

        inode.status = STATUS_FORWARDING
        inode.mount_id = mount_id
        inode.foreign_id = foreign_id

        this.mounts[mount_id].backtrack.set(foreign_id, idx)
    }

    private create_forwarder(mount_id: number, foreign_id: number): number {
        const inode = this.CreateInode()

        const idx = this.inodes.length
        this.inodes.push(inode)
        inode.fid = idx

        this.set_forwarder(idx, mount_id, foreign_id)
        return idx
    }

    private is_forwarder(inode: Inode): boolean {
        return inode.status === STATUS_FORWARDING
    }

    private is_a_root(idx: number): boolean {
        return this.GetInode(idx).fid === 0
    }

    private get_forwarder(mount_id: number, foreign_id: number): number {
        const mount = this.mounts[mount_id]

        dbg_assert(
            foreign_id >= 0,
            'Filesystem get_forwarder: invalid foreign_id: ' + foreign_id,
        )
        dbg_assert(
            !!mount,
            'Filesystem get_forwarder: invalid mount number: ' + mount_id,
        )

        const result = mount.backtrack.get(foreign_id)

        if (result === undefined) {
            // Create if not already exists.
            return this.create_forwarder(mount_id, foreign_id)
        }

        return result
    }

    private delete_forwarder(inode: Inode): void {
        dbg_assert(
            this.is_forwarder(inode),
            'Filesystem delete_forwarder: expected forwarder',
        )

        inode.status = STATUS_INVALID
        this.mounts[inode.mount_id].backtrack.delete(inode.foreign_id)
    }

    private follow_fs(inode: Inode): FS {
        const mount = this.mounts[inode.mount_id]

        dbg_assert(
            this.is_forwarder(inode),
            'Filesystem follow_fs: inode should be a forwarding inode',
        )
        dbg_assert(
            !!mount,
            'Filesystem follow_fs: inode<id=' +
                inode.fid +
                '> should point to valid mounted FS',
        )

        return mount.fs
    }

    Mount(path: string, fs: FS): number {
        dbg_assert(
            fs.qidcounter === this.qidcounter,
            "Cannot mount filesystem whose qid numbers aren't synchronised with current filesystem.",
        )

        const path_infos = this.SearchPath(path)

        if (path_infos.parentid === -1) {
            dbg_log('Mount failed: parent for path not found: ' + path, LOG_9P)
            return -ENOENT
        }
        if (path_infos.id !== -1) {
            dbg_log(
                'Mount failed: file already exists at path: ' + path,
                LOG_9P,
            )
            return -EEXIST
        }
        if (path_infos.forward_path) {
            const parent = this.inodes[path_infos.parentid]
            const ret = this.follow_fs(parent).Mount(
                path_infos.forward_path,
                fs,
            )
            if (ret < 0) return ret
            return this.get_forwarder(parent.mount_id, ret)
        }

        const mount_id = this.mounts.length
        this.mounts.push(new FSMountInfo(fs))

        const idx = this.create_forwarder(mount_id, 0)
        this.link_under_dir(path_infos.parentid, idx, path_infos.name)

        return idx
    }

    DescribeLock(
        type: number,
        start: number,
        length: number,
        proc_id: number,
        client_id: string,
    ): FSLockRegion {
        dbg_assert(
            type === P9_LOCK_TYPE_RDLCK ||
                type === P9_LOCK_TYPE_WRLCK ||
                type === P9_LOCK_TYPE_UNLCK,
            'Filesystem: Invalid lock type: ' + type,
        )
        dbg_assert(
            start >= 0,
            'Filesystem: Invalid negative lock starting offset: ' + start,
        )
        dbg_assert(
            length > 0,
            'Filesystem: Invalid non-positive lock length: ' + length,
        )

        const lock = new FSLockRegion()
        lock.type = type
        lock.start = start
        lock.length = length
        lock.proc_id = proc_id
        lock.client_id = client_id

        return lock
    }

    GetLock(id: number, request: FSLockRegion): FSLockRegion | null {
        const inode = this.inodes[id]

        if (this.is_forwarder(inode)) {
            const foreign_id = inode.foreign_id
            return this.follow_fs(inode).GetLock(foreign_id, request)
        }

        for (const region of inode.locks) {
            if (request.conflicts_with(region)) {
                return region.clone()
            }
        }
        return null
    }

    Lock(id: number, request: FSLockRegion, flags: number): number {
        const inode = this.inodes[id]

        if (this.is_forwarder(inode)) {
            const foreign_id = inode.foreign_id
            return this.follow_fs(inode).Lock(foreign_id, request, flags)
        }

        request = request.clone()

        // (1) Check whether lock is possible before any modification.
        if (request.type !== P9_LOCK_TYPE_UNLCK && this.GetLock(id, request)) {
            return P9_LOCK_BLOCKED
        }

        // (2) Subtract requested region from locks of the same owner.
        for (let i = 0; i < inode.locks.length; i++) {
            const region = inode.locks[i]

            dbg_assert(
                region.length > 0,
                'Filesystem: Found non-positive lock region length: ' +
                    region.length,
            )
            dbg_assert(
                region.type === P9_LOCK_TYPE_RDLCK ||
                    region.type === P9_LOCK_TYPE_WRLCK,
                'Filesystem: Found invalid lock type: ' + region.type,
            )
            dbg_assert(
                !inode.locks[i - 1] || inode.locks[i - 1].start <= region.start,
                'Filesystem: Locks should be sorted by starting offset',
            )

            // Skip to requested region.
            if (region.start + region.length <= request.start) continue

            // Check whether we've skipped past the requested region.
            if (request.start + request.length <= region.start) break

            // Skip over locks of different owners.
            if (
                region.proc_id !== request.proc_id ||
                region.client_id !== request.client_id
            ) {
                dbg_assert(
                    !region.conflicts_with(request),
                    'Filesytem: Found conflicting lock region, despite already checked for conflicts',
                )
                continue
            }

            // Pretend region would be split into parts 1 and 2.
            const start1 = region.start
            const start2 = request.start + request.length
            const length1 = request.start - start1
            const length2 = region.start + region.length - start2

            if (length1 > 0 && length2 > 0 && region.type === request.type) {
                // Requested region is already locked with the required type.
                // Return early - no need to modify anything.
                return P9_LOCK_SUCCESS
            }

            if (length1 > 0) {
                // Shrink from right / first half of the split.
                region.length = length1
            }

            if (length1 <= 0 && length2 > 0) {
                // Shrink from left.
                region.start = start2
                region.length = length2
            } else if (length2 > 0) {
                // Add second half of the split.

                // Fast-forward to correct location.
                while (i < inode.locks.length && inode.locks[i].start < start2)
                    i++

                inode.locks.splice(
                    i,
                    0,
                    this.DescribeLock(
                        region.type,
                        start2,
                        length2,
                        region.proc_id,
                        region.client_id,
                    ),
                )
            } else if (length1 <= 0) {
                // Requested region completely covers this region. Delete.
                inode.locks.splice(i, 1)
                i--
            }
        }

        // (3) Insert requested lock region as a whole.
        // No point in adding the requested lock region as fragmented bits in the above loop
        // and having to merge them all back into one.
        if (request.type !== P9_LOCK_TYPE_UNLCK) {
            let new_region = request
            let has_merged = false
            let i = 0

            // Fast-forward to requested position, and try merging with previous region.
            for (; i < inode.locks.length; i++) {
                if (new_region.may_merge_after(inode.locks[i])) {
                    inode.locks[i].length += request.length
                    new_region = inode.locks[i]
                    has_merged = true
                }
                if (request.start <= inode.locks[i].start) break
            }

            if (!has_merged) {
                inode.locks.splice(i, 0, new_region)
                i++
            }

            // Try merging with the subsequent alike region.
            for (; i < inode.locks.length; i++) {
                if (!inode.locks[i].is_alike(new_region)) continue

                if (inode.locks[i].may_merge_after(new_region)) {
                    new_region.length += inode.locks[i].length
                    inode.locks.splice(i, 1)
                }

                // No more mergable regions after this.
                break
            }
        }

        return P9_LOCK_SUCCESS
    }

    read_dir(path: string): string[] | undefined {
        const p = this.SearchPath(path)

        if (p.id === -1) {
            return undefined
        }

        const dir = this.GetInode(p.id)

        return Array.from(dir.direntries.keys()).filter(
            (path) => path !== '.' && path !== '..',
        )
    }

    read_file(file: string): Promise<Uint8Array | null> {
        const p = this.SearchPath(file)

        if (p.id === -1) {
            return Promise.resolve(null)
        }

        const inode = this.GetInode(p.id)

        return this.Read(p.id, 0, inode.size)
    }
}