#TODO Define bmon and hmm scan commands in separate namespaces

MakeScanCommand hmscan bm $cfPath(scan)/scan_common_1.hdd recover.bin
MakeScanCommand bmonscan bm $cfPath(scan)/scan_common_1.hdd recover.bin
MakeScanCommand scan2 bm $cfPath(scan)/scan_common_1.hdd recover.bin

namespace eval scancommand {
# List of counts
variable bmoncounts_array
variable bmoncounts_axis

variable bmonscanvar_axis_hpath
# hpath to values from bmoncounts_array
# we use this to get auto-notification on update of bmonscancounts_array_hpath
variable bmonscancounts_array_hpath

# bmonscan setup parameters and feedback variables.
VarMake bmonscan_var_name Text User
VarMake bmonscan_var_value Float User
VarMake bmonscan_var_start Float User
VarMake bmonscan_var_step Float User
VarMake bmonscan_mode Text User
VarMake bmonscan_preset Float User
VarMake bmonscan_np_target Int User
VarMake bmonscan_point_current Int User
VarMake bmonscan_counts Int User
VarMake bmonscan_numchannels Int User
VarMake bmonscan_channel Int User

# bmonscan graphdata variables.
VarMake bmonscan_np_graphics_target Int User
VarMake bmonscan_point_graphics_current Int User
VarMake bmonscan_var_graphics_value Float User

VarMake hmscan_var_name Text User
VarMake hmscan_var_value Float User
VarMake hmscan_var_start Float User
VarMake hmscan_var_step Float User
VarMake hmscan_mode Text User
VarMake hmscan_preset Float User
VarMake hmscan_np_target Int User
VarMake hmscan_point_current Int User
VarMake hmscan_numchannels Int User
VarMake hmscan_channel Int User

variable scanVariable scan_var scanVarStart 0 scanVarStep 1
  proc scan_collect {sobj uobj point} {
  }

  proc hmm_scan_prepare {sobj uobj} {
    variable scanVarStart;
    variable scanVarStep;
    variable scanVariable;

    nxcreatefile nexus_hmscan.dic;
    nxclosefile;
#  stdscan prepare $sobj $uobj;
    hmscan_np_target [SplitReply [$sobj np]]
    set vlist [split [$sobj getvarpar 0] = ];
    set scanVariable [string trim [lindex [split [lindex $vlist 0] . ] 1]];
    set scanVarStart [lindex $vlist 1];
    set scanVarStep [lindex $vlist 2];

    hmscan_var_name $scanVariable
    hmscan_var_start $scanVarStart
    hmscan_var_step $scanVarStep
    ::histogram_memory::prepare 
  }

  proc hmm_count {sobj uobj point mode preset} {
    variable scan_pt_start_time
    set scan_pt_start_time [sicstime]
    hmscan_point_current  $point;
    hmscan_mode $mode;
    hmscan_preset $preset;
    set scanvar [SplitReply [hmscan_var_name]]
    hmscan_var_value [SplitReply [$scanvar]]
    ::histogram_memory::count_bm_controlled $mode $preset; 
  }

  proc hmm_scan_finish {sobj uobj} {
    ::histogram_memory::finish;
    nxreopenfile;
    nxclosefile;
  }

  proc bm_scan_finish {sobj uobj} {
#    stdscan finish $sobj $uobj;
    nxreopenfile;
    nxclosefile;
  }
#proc hmm_scan_finish {sobj uobj} {
#  nxclosefile;
#}

# Add an nxentry for the current scan point
  proc write_nxentry {nxentryCmd point} {
    variable scanVarStart;
    variable scanVarStep;
    variable scanVariable;
    variable scan_pt_start_time;

    set scanVarPos [expr {$scanVarStart + $point * $scanVarStep} ];
    nxreopenfile;
#    $nxentryCmd nxscript scan_[format "%05d" $point] $scanVariable $scanVarPos $scanVarStep $scan_pt_start_time;
    $nxentryCmd nxscript entry1 $point $scanVariable $scanVarPos $scanVarStep $scan_pt_start_time;
    nxclosefile;
  }

  proc bm_writepoint {sobj uobj pt} {
    variable bmoncounts_array
    set bmoncounts_array [string map {\{ "" \} ""} [SplitReply [bmonscan getcounts]]];
    write_nxentry bm_addnxscanentry $pt;

    bmonscan_counts [SplitReply [bm getcounts]] 
    bmonscan_np_graphics_target [SplitReply [bmonscan_np_target]]
    bmonscan_point_graphics_current [SplitReply [bmonscan_point_current]]
    bmonscan_var_graphics_value [SplitReply [bmonscan_var_value]]
  }

#TODO Feedback for Histogram memory scan
  proc hmm_writepoint {sobj uobj pt} {
    write_nxentry hmm_addnxscanentry $pt;
  }

  proc donothing {args} {}

  proc bm_count {sobj uobj point mode preset} {
    variable scan_pt_start_time

    set scan_pt_start_time [sicstime]
    bmonscan_point_current $point
    bmonscan_mode $mode;
    bmonscan_preset $preset;
    set scanvar [SplitReply [bmonscan_var_name]]
    bmonscan_var_value [SplitReply [$scanvar]]
    bm setmode $mode
    bm count $preset;
  }

  proc bm_scan_prepare {sobj uobj} {
    variable scanVarStart;
    variable scanVarStep;
    variable scanVariable;
    variable bmoncounts_array;
    variable bmoncounts_axis;

    set bmoncounts_array [list]
#TODO Parameterise varindex in some way
    set varindex 0;

    nxcreatefile nexus_bmonscan.dic;
    nxclosefile;
    bmonscan_np_target [SplitReply [$sobj np]];
    set vlist [split [$sobj getvarpar $varindex] = ];
    set scanVariable [string trim [lindex [split [lindex $vlist 0] . ] 1]];
    set scanVarStart [lindex $vlist 1];
    set scanVarStep [lindex $vlist 2];
    set scanvar_pts [SplitReply [$sobj getvardata $varindex]]
    set bmoncounts_axis [string map {\{ "" \} ""} $scanvar_pts]
    bmonscan_var_name $scanVariable
    bmonscan_var_start $scanVarStart
    bmonscan_var_step $scanVarStep
    #stdscan prepare $sobj $uobj;
  }


  proc init {} {
    variable bmoncounts_array;
    variable bmoncounts_axis;
    
    bmonscan_numchannels [SplitReply [bmonscan getnumchan]]; 
    bmonscan_channel 0;
    bmonscan_np_target 0;
    bmonscan_point_current 0;

    hmscan_numchannels [SplitReply [hmscan getnumchan]];
    hmscan_channel 0;
    hmscan_np_target 0;
    hmscan_point_current 0;
    set bmoncounts_array [list];
    set bmoncounts_axis [list];
  }

  proc commands_hpath_setup {parent} {
    set feedbackPath $parent/bmonscan/feedback 

    hcommand $parent/bmonscan hdb_bmonscan
    hsetprop $parent/bmonscan type command
    hsetprop $parent/bmonscan priv user
    
    hattach $parent/bmonscan bmonscan_var_name scan_variable
    hsetprop $parent/bmonscan/scan_variable argtype drivable

    hattach $parent/bmonscan bmonscan_var_start scan_start
    hsetprop $parent/bmonscan/scan_start argtype float
    
    hattach $parent/bmonscan bmonscan_var_step scan_increment
    hsetprop $parent/bmonscan/scan_increment argtype float

    hattach $parent/bmonscan/ bmonscan_np_target NP
    hsetprop $parent/bmonscan/NP argtype int

    hmake $parent/bmonscan/mode user text
    hsetprop $parent/bmonscan/mode argtype text
    hsetprop $parent/bmonscan/mode values monitor,timer

    hmake $parent/bmonscan/preset user float
    hsetprop $parent/bmonscan/preset argtype float

    hattach $parent/bmonscan/ bmonscan_channel channel
    hsetprop $parent/bmonscan/channel argtype int
    hsetprop $parent/bmonscan/channel min 0
    hsetprop $parent/bmonscan/channel max [SplitReply [bmonscan getnumchan]]

# Optional feedback node
    hmake $feedbackPath spy none
    hattach $feedbackPath dataFileName filename
    hattach $feedbackPath bmonscan_mode  mode
    hattach $feedbackPath bmonscan_preset preset
    hmake $feedbackPath/scan_variable spy none
    hattach $feedbackPath/scan_variable bmonscan_var_value value 
    hmake $feedbackPath/NP spy none
    hattach $feedbackPath/NP bmonscan_point_current current
    hattach $feedbackPath bmonscan_counts counts;
    foreach fbNode [hlist $feedbackPath] {
      hsetprop $feedbackPath/$fbNode privilege READ_ONLY;
    }
#TODO Histogram memory scan command
  }


  proc graphics_hpath_setup {parent} {
    variable bmonscanvar_axis_hpath
    variable bmonscancounts_array_hpath
    variable bmoncounts_array
    variable bmoncounts_axis

    set bmonscanvar_axis_hpath $parent/beam_monitor_scan/axis 
    set bmonscancounts_array_hpath $parent/beam_monitor_scan/data 
    set defdim 100
    hmake $parent/beam_monitor_scan spy none;
    hsetprop $parent/beam_monitor_scan type graphdata;
    hsetprop $parent/beam_monitor_scan viewer default;
    hsetprop $parent/beam_monitor_scan rank 1;
    hattach $parent/beam_monitor_scan bmonscan_np_graphics_target dim;
    hattach $parent/beam_monitor_scan bmonscan_point_graphics_current point;
    hattach $parent/beam_monitor_scan bmonscan_var_graphics_value lastaxis 
    hattach $parent/beam_monitor_scan bmonscan_counts lastdata 
    hmakescript $bmonscanvar_axis_hpath "set ::scancommand::bmoncounts_axis" hdbReadOnly floatvarar $defdim
    hsetprop $bmonscanvar_axis_hpath type axis
    sicspoll del $bmonscanvar_axis_hpath
    hmakescript $bmonscancounts_array_hpath "set ::scancommand::bmoncounts_array" hdbReadOnly floatvarar $defdim
    hsetprop $bmonscancounts_array_hpath type data
    sicspoll del $bmonscancounts_array_hpath

#TODO histogram_memory_scan
#    hmake $parent/histogram_memory_scan spy none;
#    hsetprop $parent/histogram_memory_scan type graphdata;
#    hsetprop $parent/histogram_memory_scan viewer default;
#    hsetprop $parent/histogram_memory_scan rank 2;
#    hattach $parent/histogram_memory_scan hmscan_np_target dim0;
#    hattach $parent/histogram_memory_scan hmscan_np_target dim1;
#    hattach $parent/histogram_memory_scan hmscan_point_current point;
  }
}

publish ::scancommand::scan_collect user
publish ::scancommand::write_nxentry user
publish ::scancommand::hmm_count user
publish ::scancommand::hmm_scan_prepare user
publish ::scancommand::hmm_scan_finish user
publish ::scancommand::hmm_writepoint user
publish ::scancommand::donothing user

publish ::scancommand::bm_scan_prepare user
publish ::scancommand::bm_scan_finish user
publish ::scancommand::bm_writepoint user
publish ::scancommand::bm_count user

bmonscan configure script
bmonscan function writeheader ::scancommand::donothing
bmonscan function writepoint ::scancommand::bm_writepoint
bmonscan function count ::scancommand::bm_count
#bmonscan function collect ::scancommand::scan_collect
bmonscan function prepare ::scancommand::bm_scan_prepare
bmonscan function finish ::scancommand::bm_scan_finish


#scan2 function writeheader ::scancommand::donothing
#scan2 function writepoint ::scancommand::nxaddpoint
#scan2 function prepare ::scancommand::hmm_scan_prepare
# Configure script mode, then we can configure all the scan callbacks.
# The scan list command can be used to check that the callbacks
# are properly defined. 
# A different count callback is defined in the two cases.
#
scan2 configure script

#scan2 function prepare ::histogram_memory::prepare
scan2 function count  ::histogram_memory::hs_count_hs_controlled
#scan2 function collect  ::histogram_memory::hs_collect
scan2 function finish  ::histogram_memory::hs_finish
#
# That's all, folks...

hmscan configure script
#hmscan function prepare hdbprepare
#hmscan function collect hdbcollect
hmscan function writeheader ::scancommand::donothing
hmscan function writepoint ::scancommand::hmm_writepoint
hmscan function count ::scancommand::hmm_count
#hmscan function collect ::scancommand::scan_collect
bmonscan function prepare ::scancommand::bm_scan_prepare
hmscan function prepare ::scancommand::hmm_scan_prepare
hmscan function finish ::scancommand::hmm_scan_finish
# Wombat proc hdb_hmscan {scanvar scanstart scanincr scanend mode preset} {
proc hdb_bmonscan {scanvar scanstart scanincr np mode preset channel} {
    bmonscan clear
#    bmonscan configure script

    bmonscan add $scanvar $scanstart $scanincr
    bmonscan setchannel $channel;
    set status [catch {bmonscan run $np $mode $preset} msg]
#    bmonscan configure soft
    if {$status == 0} {
      return $msg
    } else {
      clientput "hdb_bmonscan ERROR: $msg"
      error $msg
    }
}

publish hdb_bmonscan user