}

# OPCUA connect and retrieve tree into variable ::T,
# key is browse path, value a list of node ID and
# class path, thus variables can be identified
# with the pattern "*/Variable" on the class path.
# Variable ::R is for reverse mapping node ID to
# browse path. Namespace prefixes are stripped
# from browse paths, as long as they are unique
# among the entire address space.

log "starting up"
opcua new client C
log "connecting to $url"
opcua connect C $url
log "connected"

# Fetch custom types, if any
catch {opcua gentypes C}
log "fetched types, if any"

apply {tree {
    foreach {brpath nodeid clspath refid typeid} $tree {
	set short $brpath
	regsub -all -- {/[1-9][0-9]*:} $short {/} short
	incr t($short)
    }
    foreach {brpath nodeid clspath refid typeid} $tree {
	set short $brpath
	regsub -all -- {/[1-9][0-9]*:} $short {/} short
	if {$t($short) == 1} {
	    set brpath $short
	}
	set ::T($brpath) [list $nodeid $clspath]
	set ::R($nodeid) $brpath
    }
}} [opcua ptree C]
log "fetched tree"

# Fuse entry points; the "fs_getattr" function fills
# a cache when an OPCUA variable is referenced.
# Other functions work with cached entries later.

proc fs_getattr {context path} {
    log "getattr $path"
    if {$path eq "/"} {
        return [dict create type directory mode 0755 nlinks 2]
    }
    if {[info exists ::T($path)]} {
	lassign $::T($path) nodeid clspath
	if {[string match "*/Variable" $clspath]} {
	    set now [clock seconds]
	    # Fetch Value attribute into cache, if cache entry doesn't
	    # exist at all, or is not open and older than 10 seconds.
	    if {![info exists ::D($nodeid)] ||
		($::U($nodeid) <= 0 && $now - $::M($nodeid) >= 10)} {
		log "refresh $path"
		if {[catch {set ::D($nodeid) [opcua read C $nodeid]}]} {
		    return -code error -errorcode [list POSIX EIO {}]
		}
		set ::M($nodeid) $now
		set ::U($nodeid) 0
	    }
	    return [dict create mode 0666 nlinks 1 \
			mtime $::M($nodeid) \
			size [string length $::D($nodeid)]]
	}
	return [dict create type directory mode 0755 nlinks 2]
    }
    return -code error -errorcode [list POSIX ENOENT {}]
}

proc fs_open {context path fileinfo} {
    log "open $path"
    if {[info exists ::T($path)]} {
	lassign $::T($path) nodeid clspath
	if {[string match "*/Variable" $clspath]} {
	    # Cached Value attribute must exist
	    if {"RDONLY" ni [dict get $fileinfo flags] ||
		![info exists ::D($nodeid)]} {
		return -code error -errorcode [list POSIX EACCES {}]
	    }
	    # Success, increment use counter and return empty result.
	    incr ::U($nodeid)
	    return
	}
	return -code error -errorcode [list POSIX EACCES {}]
    }
    return -code error -errorcode [list POSIX ENOENT {}]
}

proc fs_readdir {context path fileinfo} {
    log "readdir $path"
    if {[info exists ::T($path)]} {

	    # Success, but nothing read
	    return
	}
    }
    return -code error -errorcode [list POSIX ENOENT {}]
}

proc fs_release {context path fileinfo} {
    log "release $path"
    if {[info exists ::T($path)]} {
	lassign $::T($path) nodeid clspath
	# Decrement use counter for cache entry.
	incr ::U($nodeid) -1




    }
    return
}

proc fs_destroy {context} {
    log "shutdown, disconnecting"
    catch {opcua disconnect C}
    log "exiting"
    exit 0
}

# Create and serve fuse file system

fuse create FS \
    -getattr fs_getattr \
    -readdir fs_readdir \
    -open fs_open \
    -read fs_read \
    -release fs_release \
    -destroy fs_destroy

FS $mountpoint -s -ononempty -ofsname=OPCUA
log "created/mounted file system"

# Remove old cache entries after 60 seconds
# and do some keep-alive/reconnect handling.

proc fs_cleanup {url} {
    log "cleanup ..."
    set status /Root/Objects/Server/ServerStatus
    if {[info exists ::T($status)]} {
	if {[catch {opcua read C [lindex $::T($status) 0]} error]} {
	    log "reading server status: $error"
	    catch {opcua disconnect C}
	    log "reconnecting to $url"
	    if {[catch {opcua connect C $url} error]} {
		log "connect failed: $error"
	    }
	}
    }
    set now [clock seconds]
    foreach nodeid [array names ::D] {



	if {$::U($nodeid) <= 0 && $now - $::M($nodeid) >= 60} {
	    log "expire $::R($nodeid)"
	    unset -nocomplain ::D($nodeid)
	    unset -nocomplain ::M($nodeid)
	    unset -nocomplain ::U($nodeid)
	}
    }
    after 10000 [list fs_cleanup $url]
}

fs_cleanup $url

# Start event loop

log "enter event loop"
vwait forever