#!/usr/bin/wish8.2

proc widgets {} {
    global widg_pipe
    set sizes [exec ./gui-plan-bot --sizes]
    frame .picture -background {} \
	    -width [lindex $sizes 0] \
	    -height [lindex $sizes 1]
    pack .picture
    tkwait visibility .picture
    set widg_pipe [open |[list ./gui-plan-bot \
	    [winfo id .picture] >&@ stderr] w]
}

proc setsegbyname {segfeatname command {posnum {}}} {
    global widg_pipe
#puts stderr "setsegbynum $num $idchar"
    set s "$command $segfeatname"
    if {[string length $posnum]} { append s " $posnum" }
    puts $widg_pipe $s
    puts ">> $s"
}

proc update_push {} {
    global widg_pipe
    flush $widg_pipe
}

# variables:
#   from map file
#        $segmovs($segname)        = [list $segname/$movfeat ...]
#        $movconfs($segname/$movfeat) = no. of configurations
#   state we are showing
#        $power                    = 0 or 1
#        $segrev($segname)         = 0 or 1
#        $segdet($segname)         = 0 or 1
#        $segown($segname)         = {} or t or f
#        $movpos($segname/$movfeat) = $pos (number) or {} meaning unknown

proc P {onoff} { # power
    global power
    set power $onoff
    update_allsegs
    update_push
}

proc R {now args} { # reverse segnames
    foreach segname $args {
	upvar #0 segrev($segname) r
	set r $now
	update_seg $segname
    }
    update_push
}

proc setsegs {segfoo value l} {
    foreach segname $l {
	upvar #0 ${segfoo}($segname) d
	set d $value
	update_seg $segname
    }
    update_push
}

proc D0 {args} { setsegs segdet 0 $args }
proc D1 {args} { setsegs segdet 1 $args }
proc OT {args} { setsegs segown t $args }
proc OF {args} { setsegs segown f $args }
proc ON {args} { setsegs segown {} $args }

proc M {segname mp {movfeat P}} { # mp==x is unknown
    upvar #0 movpos($segname/$movfeat) p
    upvar #0 movconfs($segname/$movfeat) n
    if {![string compare -nocase x $mp]} { set mp {} }
    if {$mp >= $n} { error "out of range $segname $movfeat $mp $n ?" }
    set p $mp
    update_seg $segname
    update_push
}

proc update_allsegs {} {
    global segmovs
    foreach segname [array names segmovs] { update_seg $segname }
}

proc update_seg {segname} {
    upvar #0 segrev($segname) r
    upvar #0 segdet($segname) d
    upvar #0 segown($segname) o
    upvar #0 segmovs($segname) movs
    global power

#puts stderr "update_seg $segname"

    if {!$power} {
        set command off
    } else {
	set command [expr {$d ? "det" : "on"}]
	if {$r} { set command "i$command" }
	set command $o$command
    }
    setsegbyname $segname $command

    foreach mov $movs {
#puts stderr "update_seg $segname mov $mov"
	upvar #0 movpos($mov) mp
	if {[string length $mp] && [string compare off $command]} {
	    setsegbyname $mov $command $mp
	} else {
	    setsegbyname $mov $command
	}
    }
}

proc setup {} {
    global segnum segmovs movconfs
    global power segrev segdet segown movpos
    set power 0
    set f [open ../layout/ours.dgram-bot.segcmap]
    fconfigure stdout -buffering none
    while {[gets $f l] >= 0} {
	if {[regexp {^S (\w+) (\w+)$} $l dummy segname num]} {
	    set segnum($segname) $num
	    set segmovs($segname) {}
	    set segrev($segname) 0
	    set segdet($segname) 0
	    set segown($segname) {}
	} elseif {[regexp {^F (\w+) \w+ (\w+) \w+ (\w+)$} \
		$l dummy  segname movfeat mc]} {
	    set segnum($segname)
	    set mov $segname/$movfeat
	    lappend segmovs($segname) $mov
	    set movconfs($mov) $mc
	    set movpos($mov) {}
	}
    }
}

proc main {} {
    setup
    widgets
    update_allsegs
    update_push
}

proc EOE {} { global exitoneof; set exitoneof 1}

main

while {[gets stdin l]>=0} {
    if {[regexp {^GUI ([A-Z][0-9a-zA-Z ]*)$} $l dummy cmd]} {
	puts "GUI $cmd"
	eval $cmd
    } else {
	puts $l
    }
}

if {[info exists exitoneof]} { exit 0 }