#TODO Define bmon and hmm scan commands in separate namespaces

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

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 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

variable scanVariable scan_var scanVarStart 0 scanVarStep 1
  proc 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::hs_prepare $sobj $uobj
  }

  proc hm_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::hs_count_bm_controlled $sobj $uobj $point $mode $preset;

  }

  proc hm_scan_finish {sobj uobj} {
    ::histogram_memory::hs_finish $sobj $uobj;
    nxreopenfile;
    nxclosefile;
  }

  proc bm_scan_finish {sobj uobj} {
#    stdscan finish $sobj $uobj;
    nxreopenfile;
    nxclosefile;
  }
#proc hm_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;
    nxclosefile;
  }

  proc bm_writepoint {sobj uobj pt} {
    variable bmoncounts_array
    set counts [SplitReply [bm getcounts]]
    bmonscan_counts $counts
    lappend bmoncounts_array $counts
    write_nxentry bm_addnxscanentry $pt;
  }

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

  proc donothing {args} {}

  proc bmcount {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 {} {
#TODO HSET bmonscan_np_target IN SCAN FUNCTION
    variable bmoncounts_array
    variable bmoncounts_axis

    bmonscan_np_target 0;
    bmonscan_point_current 0;
    hmscan_np_target 0;
    hmscan_point_current 0;
    set bmoncounts_array [list];
    set bmoncounts_axis [list];
  }

  proc commands_hpath_setup {parent} {
    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

# Optional feedback node
    hmake $parent/bmonscan/feedback spy none
    hattach $parent/bmonscan/feedback dataFileName filename
    hattach $parent/bmonscan/feedback bmonscan_mode  mode
    hattach $parent/bmonscan/feedback bmonscan_preset preset
    hmake $parent/bmonscan/feedback/scan_variable spy none
    hattach $parent/bmonscan/feedback/scan_variable bmonscan_var_value value 
    hmake $parent/bmonscan/feedback/NP spy none
    hattach $parent/bmonscan/feedback/NP bmonscan_point_current current
    hattach $parent/bmonscan/feedback bmonscan_counts counts;
#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/scan_axis 
    set bmonscancounts_array_hpath $parent/beam_monitor_scan/counts 
    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_target dim;
    hattach $parent/beam_monitor_scan bmonscan_point_current point;
    hmake $parent/beam_monitor_scan/scan_variable spy none
    hattach $parent/beam_monitor_scan/scan_variable bmonscan_var_value value 
    hmake $parent/beam_monitor_scan/scan_counts spy none
    hattach $parent/beam_monitor_scan/scan_counts bmonscan_counts value 
    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::write_nxentry user
publish ::scancommand::hm_count user
publish ::scancommand::scan_prepare user
publish ::scancommand::hm_scan_finish user
publish ::scancommand::hm_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::bmcount user

MakeScanCommand bmonscan bm $cfPath(scan)/scan_common_1.hdd recover.bin
bmonscan configure script
bmonscan function writeheader ::scancommand::donothing
bmonscan function writepoint ::scancommand::bm_writepoint
bmonscan function count ::scancommand::bmcount
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::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.
#
MakeScanCommand hmscan bm $cfPath(scan)/scan_common_1.hdd recover.bin
hmscan configure script
#hmscan function prepare hs_prepare
MakeScanCommand scan2 bm $cfPath(scan)/scan_common_1.hdd recover.bin
scan2 configure script
#
# That's all, folks...

#hmscan function prepare hdbprepare
#hmscan function collect hdbcollect
hmscan function writeheader ::scancommand::donothing
hmscan function writepoint ::scancommand::hm_writepoint
hmscan function count ::scancommand::hm_count
hmscan function prepare ::scancommand::scan_prepare
hmscan function finish ::scancommand::hm_scan_finish
# Wombat proc hdb_hmscan {scanvar scanstart scanincr scanend mode preset} {
proc hdb_bmonscan {scanvar scanstart scanincr np mode preset} {
    bmonscan clear
#    bmonscan configure script

    bmonscan add $scanvar $scanstart $scanincr
    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