#require 'testmgr'
require 'CmdShellMgr'

module Scoutui::Base

  class VisualTestFramework

    STEP_KEY='page'
    CMD_KEY='dut'   # Used to indicate the command file (YML) to execute

    def initialize()

    end


    def self.processPageElement(my_driver, k, xpath)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processPageElement(#{xpath})"
      processed=false
      _obj=nil

      if !xpath.match(/^\s*page\(.*\)\s*$/).nil?

        processed=true

        # Check if this is a form

        page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(xpath)
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process page request #{page_elt} => #{page_elt.class.to_s}"


        sub_elts=0
        if page_elt.is_a?(Hash)
          sub_elts = page_elt.select { |_s| page_elt[_s].has_key?("locator") if page_elt[_s].is_a?(Hash) &&  !page_elt[_s].nil?  }.size
        end

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SubElts => #{sub_elts}"

        if page_elt.is_a?(Hash) && page_elt.has_key?('locator')

          ##
          # expected:
          #   wait: page(abc).get(def)    where this page_elt has "locator"

          xpath = page_elt['locator'].to_s

          _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)




          _req = nil

          if page_elt.has_key?('reqid')
            _req=page_elt['reqid'].to_s
          end

          Scoutui::Base::Assertions.instance.assertPageElement(k, page_elt, _obj, my_driver, _req)



        elsif sub_elts > 0
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Validate form"



          page_elt.each_pair do |_k, _v|

            begin

              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " k,v :: #{_k.to_s}, #{_v.to_s}  (#{_v.class.to_s})"

              _obj=nil

              if _v.is_a?(Array)
                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Arrays - TBD => #{_v}"
              end


              if _v.is_a?(String)
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
                next
              end

              if _v.has_key?('assert_when') && _v['assert_when'].match(/role\s*\=/i)
                _role = _v['assert_when'].match(/role\s*\=(.*)/i)[1].to_s
                _expected_role = Scoutui::Utils::TestUtils.instance.getRole()

                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Trigger: expected : #{_expected_role.to_s}, actual: #{_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

                if !_expected_role.nil? && !_role.match(/#{_expected_role}/i)
                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Skip assertion since conditional assertion #{_v['assert_when']} not met" if Scoutui::Utils::TestUtils.instance.isDebug?
                  next
                elsif _expected_role.nil?
                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Skip role based assertion since role was not provided" if Scoutui::Utils::TestUtils.instance.isDebug?
                  next
                end
                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Verify object exists since the role #{_role} matches expected role #{_expected_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
              end


              if Scoutui::Base::Assertions.instance.visible_when_skip(_k, _v)
                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SKIP #{_k.to_s} - #{_v.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
                next
              end

              _req = nil

              if _v.has_key?('reqid')
                _req=_v['reqid'].to_s
              end

              if _v.has_key?('locator')
                _locator = _v['locator'].to_s
                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator

                #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])

                _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator, Scoutui::Commands::Utils.instance.getTimeout())

                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{(!_obj.nil?).to_s}"  # if Scoutui::Utils::TestUtils.instance.isDebug?
              end

              if Scoutui::Base::Assertions.instance.visible_when_always(_k, _v, _obj, _req)
                next
              elsif Scoutui::Base::Assertions.instance.visible_when_never(_k, _v, _obj, _req)
                next
              elsif Scoutui::Base::Assertions.instance.visible_when_title(_k, _v, _obj, my_driver, _req)
                next
              elsif Scoutui::Base::Assertions.instance.visible_when_value(_k, _v, my_driver, _req)
                next
              elsif _v.has_key?('visible_when') && !_v['visible_when'].is_a?(Array)

                if _v['visible_when'].match(/role\=/i)
                  _role = _v['visible_when'].match(/role\=(.*)/i)[1].to_s
                  _expected_role = Scoutui::Utils::TestUtils.instance.getRole()

                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Verify object exists if the role #{_role} matches expected role #{_expected_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

                  if _role==_expected_role.to_s
                    Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} #{_locator}  visible when role #{_role} - #{!_obj.nil?.to_s}"
                    Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify #{_k} #{_locator}  visible when role #{_role}")
                  end

                end
              elsif _v.has_key?('visible_when') && _v['visible_when'].is_a?(Array)
                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " visible_when : (Array) - TBD  #{_v['visible_when']}"

                _v['visible_when'].each do |_vwhen|
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_vwhen}  #{_vwhen.class}"

                  Scoutui::Base::Assertions.instance.assertPageElement(_k, _vwhen, _obj, my_driver, _req)


                end
              end


            rescue => ex
              Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Error during processing: #{ex}"
              Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
            end


          end

          return


        elsif xpath.is_a?(Hash)
          xpath.each_pair do |_k, _v|

            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " k,v :: #{_k.to_s}, #{_v.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

            if _v.has_key?('locator')
              _locator = _v['locator'].to_s
              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator if Scoutui::Utils::TestUtils.instance.isDebug?

              #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])

              _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator)

              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{!_obj.nil?}" if Scoutui::Utils::TestUtils.instance.isDebug?
            end

          end

          # next
        end


      end

      _obj

    end


    def self.processCommand(_action, e, my_driver)
      _req = Scoutui::Utils::TestUtils.instance.getReq()
      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ===  Process ACTION : #{_action}  ==="  if Scoutui::Utils::TestUtils.instance.isDebug?

      if Scoutui::Commands::Utils.instance.isExistsAlert?(_action)
        _c = Scoutui::Commands::JsAlert::ExistsAlert.new(_action)
        _rc = _c.execute(my_driver)
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " existsAlert => #{_rc}"

        Scoutui::Logger::LogMgr.instance.asserts.info "Verify alert is present - #{!_rc.nil?.to_s}"
        Testmgr::TestReport.instance.getReq(_req).get_child('expectJsAlert').add(!_rc.nil?, "Verify alert is present")

      elsif Scoutui::Commands::Utils.instance.isVerifyForm?(_action)
        _c = Scoutui::Commands::VerifyForm.new(_action)
        _c.execute(my_driver)

      elsif !_action.match(/fillform\(/).nil? && false

     #   _c = Scoutui::Commands::FillForm.new(_action)

        _form = _action.match(/fillform\((.*)\s*\)/)[1].to_s
     #  _dut = _action.match(/fillform\(.*,\s*(.*)\)/)[1].to_s

        dut = e[STEP_KEY]['dut']

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " DUT => #{dut}" if Scoutui::Utils::TestUtils.instance.isDebug?
        _f = Scoutui::Utils::TestUtils.instance.getForm(_form)
        _f.dump()
        _f.verifyForm(my_driver)
        _f.fillForm(my_driver, dut)

      elsif !_action.match(/submitform\(/).nil? && false
        _cmd = Scoutui::Commands::SubmitForm.new(_action)
     #   _cmd.execute(my_driver)

        _form = _action.match(/submitform\((.*)\s*\)/)[1].to_s
        _f = Scoutui::Utils::TestUtils.instance.getForm(_form)
        _f.submitForm(my_driver)

      elsif !_action.match(/type\(/).nil?  && false
        _xpath = _action.match(/type\((.*),\s*/)[1].to_s
        _val   = _action.match(/type\(.*,\s*(.*)\)/)[1].to_s

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + "Process TYPE #{_val} into  #{_xpath}"  if Scoutui::Utils::TestUtils.instance.isDebug?

        obj = Scoutui::Base::QBrowser.getObject(my_driver, _xpath, Scoutui::Commands::Utils.instance.getTimeout)

        if !obj.nil? && !obj.attribute('type').downcase.match(/(text|password|email)/).nil?
          Scoutui::Logger::LogMgr.instance.commands.info "send_keys(#{_val})"
          obj.send_keys(Scoutui::Base::UserVars.instance.get(_val))
        else
          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Unable to process command TYPE => #{obj.to_s}"
        end

      end


    end

    def self.isRun(e)
      _run=nil
      if e[STEP_KEY].has_key?("run")
        _run = e[STEP_KEY].has_key?("run").to_s
      end
      _run
    end

    def self.isSnapIt(e)
      _snapit=false

      if e[STEP_KEY].has_key?("snapit")
        _snapit = !(e[STEP_KEY]["snapit"].to_s.match(/true/i).nil?)
      end
      _snapit
    end


    def self.verifyCondition(my_driver, xpath)
      rc=false

      if !xpath.match(/^page\([\w\d]+\)/).nil?

        page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(xpath)

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process page request #{page_elt} => #{page_elt.class.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

        if page_elt.is_a?(Hash) && page_elt.has_key?('locator')

          ##
          # expected:
          #   wait: page(abc).get(def)    where this page_elt has "locator"

          xpath = page_elt['locator'].to_s

        elsif xpath.is_a?(Hash)
          xpath.each_pair do |_k, _v|

            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " k,v :: #{_k.to_s}, #{_v.to_s}"

            if _v.has_key?('locator')
              _locator = _v['locator'].to_s
              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator

              #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])

              _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator)

              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{!_obj.nil?}"
            end

          end


        end

      end

    end

    def self.processAssertions(my_driver, e)
      processConditions(my_driver, e, 'assertions')
    end

    def self.processAsserts(my_driver, _execute_when, _enableAsserts=true)

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processAsserts#{_execute_when}"

      result=true

      if !_execute_when.nil? && _execute_when.is_a?(Array)

        _req = Scoutui::Utils::TestUtils.instance.getReq()

        _execute_when.each do |_a|
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assert: => #{_a}"

          _rc=nil


          _assertType=Scoutui::Base::Assertions.instance.isValidAssertType(_a)

          if !_assertType.nil?


            if _assertType[:cmd].match(/^\s*isEnabled\s*$/i)  # Scoutui::Base::Assertions.instance.isEnabledCmd?(_a)
              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a, _enableAsserts)
            elsif _assertType[:cmd]=='visible'
              _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a, _enableAsserts)
            elsif _assertType[:cmd]=='isSelected'
              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
            elsif _assertType[:cmd]=='isText'
              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
            elsif _assertType[:cmd]=='isValue'
              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
            end

          elsif Scoutui::Base::Assertions.instance.isRoleCmd?(_a)
            _rc=Scoutui::Base::Assertions.instance.isRole?(_a)
#          elsif Scoutui::Base::Assertions.instance.isVisibleCmd?(_a)
#            _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a)
          elsif Scoutui::Base::Assertions.instance.isSelectedCmd?(_a)
            _rc=Scoutui::Base::Assertions.instance.isSelected?(my_driver, _a)
          elsif Scoutui::Base::Assertions.instance.isValueCmd?(_a)
            _rc=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
          elsif Scoutui::Base::Assertions.instance.isTitleCmd?(_a)
            _rc=Scoutui::Base::Assertions.instance.isTitle(my_driver, _a)
          elsif _a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)

            _reqID=_a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)[2].to_s

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  Process REQ ASSERT: #{_reqID}";
            _reqAsserts=Scoutui::Base::Requirements.instance.get(_reqID)
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{_reqAsserts}"

            _req = Scoutui::Utils::TestUtils.instance.setReq(_reqID)
            _rc=processAsserts(my_driver, _reqAsserts, _enableAsserts)
            Scoutui::Utils::TestUtils.instance.setReq(_req)
          end

          if !_rc.nil?

            if _enableAsserts
              Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_a} - #{_rc}"
              Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(_rc, "Verify #{_a}")
            end

            Scoutui::Commands::Utils.instance.resetFrameSearch()

            result=(result && _rc)
          end

        end
      end

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " *************  processAsserts() => #{result}"
      result

    end


    def self.processConditions(my_driver, e, _conditionType)
      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " === ProcessAssertions(#{e.to_s} ====" if Scoutui::Utils::TestUtils.instance.isDebug?

      if !e[STEP_KEY].has_key?(_conditionType)
        return
      end

      if !e[STEP_KEY][_conditionType].is_a?(Array)
        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " \'assertions\' field must be type Array."
        return
      end

      _req = Scoutui::Utils::TestUtils.instance.getReq()

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "======= #{e[STEP_KEY][_conditionType]} ========="


      e[STEP_KEY][_conditionType].each do |elt|

        begin


        _k = elt.keys[0].to_s
        a = elt[_k]

        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Assert => #{_k} :  #{a.to_s}"

    #    _k = 'generic-assertion'
        _v={}

        if a.is_a?(Hash)
          _v=a


          if _v.has_key?('reqid')
            _req = _v['reqid']

            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Temp req #{_req} for assertion"
          end

          if _v.has_key?('locator')  && _v['locator'].is_a?(String) && _v.has_key?('enabled_when')

            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process pageObject #{_v} for enabled_when - TBD";  # TBD gets;
            isVisible=Scoutui::Base::Assertions.instance.isEnabled(my_driver, _v['locator'], _req)

          elsif _v.has_key?('locator')  && _v['locator'].is_a?(String) && !_v.has_key?('visible_when')
            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process pageObject #{_v}"
            isVisible=Scoutui::Base::Assertions.instance.isVisible(my_driver, _v['locator'], _req)

          elsif _v.has_key?('locator')
            _locator = _v['locator'].to_s

            if !_locator.match(/^page\([\w\d]+\)/).nil?
              _obj = processPageElement(my_driver, _k, _locator)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Processed #{_locator} => #{_obj.class.to_s}"
            else

              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator

              #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])

              _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator, Scoutui::Commands::Utils.instance.getTimeout())

              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{!_obj.nil?}" if Scoutui::Utils::TestUtils.instance.isDebug?
            end

          end

          if _v.has_key?('visible_when')

            if _v['visible_when'].match(/value\((\$\{.*\})\)=(.*)/)

              user_var = _v['visible_when'].match(/value\((\$\{.*\})\)=(.*)/)[1]
              expected_v = _v['visible_when'].match(/value\((\$\{.*\})\)=(.*)/)[2]

              _uservar_val = Scoutui::Base::UserVars.instance.getVar(user_var)



              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _uservar_val : #{_uservar_val}"
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Assert user variable - #{user_var} matches #{expected_v} => #{_uservar_val.match(expected_v)}"


              if _uservar_val.match(expected_v) || _uservar_val==expected_v
                # 5150

                Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + "Verify conditional assertion #{_k} - #{!_obj.nil?}"
                Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify assertion #{_k} - #{_locator} visible when #{_v['visible_when']}")
              else
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Conditional Assertion skipped - trigger #{_v['visible_when']} is false"
              end



            elsif _v['visible_when'].match(/always/i)
              Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify assertion #{_k} - #{_locator} visible - #{!_obj.nil?.to_s}"
              Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify assertion #{_k} - #{_locator} visible")
            elsif Scoutui::Base::Assertions.instance.visible_when_never(_k, _v, _obj, _req)
              ;
            elsif _v['visible_when'].match(/role\=/i)
              _role = _v['visible_when'].match(/role\=(.*)/i)[1].to_s
              _expected_role = Scoutui::Utils::TestUtils.instance.getRole()

              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Verify assertion object exists if the role #{_role} matches expected role #{_expected_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

              if _role==_expected_role.to_s
                Scoutui::Logger::LogMgr.instance.asserts.info "Verify assertion #{_k} #{_locator}  visible when role #{_role} - #{!_obj.nil?.to_s}"
                Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify assertion #{_k} #{_locator}  visible when role #{_role}")
              end

            end




          end


        end

        rescue => ex

          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " abort processing."
          Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{ex}"
          Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
        end


      end


    end


    def self.processExpected(my_driver, e)

      _req = Scoutui::Utils::TestUtils.instance.getReq()

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + "processExpected()"

      Scoutui::Base::Assertions.instance.setDriver(my_driver)

      if e[STEP_KEY].has_key?('expected')

        expected_list=e[STEP_KEY]['expected']
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{expected_list}"


        if expected_list.is_a?(Array)

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process Arr of Expected"
          expected_list.each do |_condition|
            verifyCondition(my_driver, _condition)
          end
        end

        if expected_list.is_a?(Hash)

          expected_list.each_pair do |link_name, xpath|

            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s +  "\t\t#{link_name} => #{xpath}"

            # Check if the verification is a "windows.*" verification

            if !xpath.match(/^\*window[s]\.length\s*\(\d+\)/).nil?
              _expected_length=xpath.match(/window[s]\.length\s*\((.*)\)/i)[1].to_s

              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "\tExpect window.length is #{_expected_length}"

              if _expected_length =~ /\A\d+\z/
                # 5150
                totalWindows = my_driver.window_handles.length

                if Scoutui::Utils::TestUtils.instance.assertExpected?
                  Testmgr::TestReport.instance.getReq(_req).get_child('window_size').add(totalWindows==_expected_length.to_i, "Verify number of windows is #{_expected_length}  actual(#{totalWindows})")
                end

              end

              next
            end

            # Not Visible
            if !xpath.match(/^\s*!visible\(.*\)$/).nil?
              _rc = false
              _e=nil
              _timeout=12

              if xpath.match(/^\s*!visible\((.*,\s*\d+\s*)\)$/)
                _e = xpath.match(/^\s*!visible\((.*),\s*\d+\s*\)$/)[1].to_s.strip
                _timeout=xpath.match(/^\s*!visible\((.*),\s*(\d+)\s*\)$/)[2].to_i
              else
                _e = xpath.match(/^\s*!visible\((.*)\)$/)[1].to_s.strip
              end

              _obj =  Scoutui::Base::QBrowser.getObject(my_driver, _e, Scoutui::Commands::Utils.instance.getTimeout)

              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Wait until element #{xpath} => #{_e} is not visible #{_obj}.class.to_s"

              if _obj.nil?
                _rc = true
              else
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _obj => #{_obj} : exists: #{!_obj.nil?}"

                begin
                  Selenium::WebDriver::Wait.new(timeout: _timeout).until {
                    _obj = Scoutui::Base::QBrowser.getObject(my_driver, _e, 5)
                    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"

                    _obj.nil?
                  }

                rescue Selenium::WebDriver::Error::TimeOutError
                   _rc=_obj.nil?
                end


              end

              Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_e} - is not visible - #{_rc}"
              if Scoutui::Utils::TestUtils.instance.assertExpected?
                Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(_rc, "Verify #{_e} - is not visible")
              end

              next
            end

            if !xpath.match(/\$\{.*\}/).nil?
          #    xpath = Scoutui::Base::UserVars.instance.get(xpath)
              xpath = Scoutui::Base::UserVars.instance.normalize(xpath)
            end


            if !xpath.match(/^page\([\w\d]+\)/).nil?


              # Check if this is a form

              page_elt = Scoutui::Utils::TestUtils.instance.getPageElement(xpath)
              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Process page request #{page_elt} => #{page_elt.class.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

              sub_elts=0
              if page_elt.is_a?(Hash)
                sub_elts = page_elt.select { |_s| page_elt[_s].has_key?("locator") if page_elt[_s].is_a?(Hash) &&  !page_elt[_s].nil?  }.size
              end

              Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SubElts => #{sub_elts}" if Scoutui::Utils::TestUtils.instance.isDebug?

              if page_elt.is_a?(Hash) && page_elt.has_key?('locator')

                ##
                # expected:
                #   wait: page(abc).get(def)    where this page_elt has "locator"

                xpath = page_elt['locator'].to_s

              elsif sub_elts > 0
                Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Validate form" if Scoutui::Utils::TestUtils.instance.isDebug?

                page_elt.each_pair do |_k, _v|

                  begin

                    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " k,v :: #{_k.to_s}, #{_v.to_s}  (#{_v.class.to_s})" if Scoutui::Utils::TestUtils.instance.isDebug?

                    _obj=nil


                    if _v.is_a?(String)
                      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " #{_v} is a string - next"
                      next
                    end

                    if _v.has_key?('assert_when') && _v['assert_when'].match(/role\s*\=/i)
                      _role = _v['assert_when'].match(/role\s*\=(.*)/i)[1].to_s
                      _expected_role = Scoutui::Utils::TestUtils.instance.getRole()

                      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Trigger: expected : #{_expected_role.to_s}, actual: #{_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

                      if !_expected_role.nil? && !_role.match(/#{_expected_role}/i)
                        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Skip assertion since conditional assertion #{_v['assert_when']} not met" if Scoutui::Utils::TestUtils.instance.isDebug?
                        next
                      elsif _expected_role.nil?
                        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Skip role based assertion since role was not provided" if Scoutui::Utils::TestUtils.instance.isDebug?
                        next
                      end
                      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Verify object exists since the role #{_role} matches expected role #{_expected_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
                    end


                    if Scoutui::Base::Assertions.instance.visible_when_skip(_k, _v)
                      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SKIP #{_k.to_s} - #{_v.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?
                      next
                    end

                    if _v.has_key?('locator')
                      _locator = _v['locator'].to_s
                      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator if Scoutui::Utils::TestUtils.instance.isDebug?

                      #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])

                      _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator, Scoutui::Commands::Utils.instance.getTimeout())

                      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{!_obj.nil?}" if Scoutui::Utils::TestUtils.instance.isDebug?
                    end

                    if Scoutui::Base::Assertions.instance.visible_when_always(_k, _v, _obj)
                      next
                    elsif _v.has_key?('visible_when')

                      if _v['visible_when'].match(/always/i)
                        Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_k} - #{_locator} visible - #{!_obj.nil?.to_s}"

                        if Scoutui::Utils::TestUtils.instance.assertExpected?
                          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify #{_k} - #{_locator} visible")
                        end

                      elsif _v['visible_when'].match(/never/i)
                        Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} #{_locator} never visible - #{obj.nil?.to_s}"

                        if Scoutui::Utils::TestUtils.instance.assertExpected?
                          Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(obj.nil?, "Verify #{_k} #{_locator} not visible")
                        end

                      elsif _v['visible_when'].match(/role\=/i)
                        _role = _v['visible_when'].match(/role\=(.*)/i)[1].to_s
                        _expected_role = Scoutui::Utils::TestUtils.instance.getRole()

                        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Verify object exists if the role #{_role} matches expected role #{_expected_role.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

                        if _role==_expected_role.to_s
                          Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_k} #{_locator}  visible when role #{_role} - #{!_obj.nil?.to_s}"

                          if Scoutui::Utils::TestUtils.instance.assertExpected?
                            Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!_obj.nil?, "Verify #{_k} #{_locator}  visible when role #{_role}")
                          end

                        end

                      end
                    end


                  rescue => ex
                    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Invalid file: #{datafile} - abort processing."
                    Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
                  end


                end

                return


              elsif xpath.is_a?(Hash)
                xpath.each_pair do |_k, _v|

                  Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " k,v :: #{_k.to_s}, #{_v.to_s}" if Scoutui::Utils::TestUtils.instance.isDebug?

                  if _v.has_key?('locator')
                    _locator = _v['locator'].to_s
                    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " " + _k.to_s + " => " + _locator if Scoutui::Utils::TestUtils.instance.isDebug?

                  #  _locator = Scoutui::Utils::TestUtils.instance.getPageElement(_v['locator'])

                    _obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, _locator, Scoutui::Commands::Utils.instance.getTimeout())

                    Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " HIT #{_locator} => #{!_obj.nil?}" if Scoutui::Utils::TestUtils.instance.isDebug?
                  end

                end

                next
              end


            end

            obj = Scoutui::Base::QBrowser.getFirstObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout())

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " obj : #{obj}"

            Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{xpath} visible - #{obj.kind_of?(Selenium::WebDriver::Element).to_s}"


            if Scoutui::Utils::TestUtils.instance.assertExpected?
              Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(!obj.nil?, __FILE__ + (__LINE__).to_s + " Verify #{xpath} visible")
            end

            if obj.nil?
              Scoutui::Logger::LogMgr.instance.warn " NOT FOUND : #{link_name} with xpath #{xpath}" if Scoutui::Utils::TestUtils.instance.isDebug?
            else
              Scoutui::Logger::LogMgr.instance.warn " link object(#{link_name} with xpath #{xpath}=> #{obj.displayed?}"  if Scoutui::Utils::TestUtils.instance.isDebug?
            end

          end
        end
      end

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " [end]: processExpected()"
    end

    # Scoutui::Base::VisualTestFramework.processFile(@drv, @eyes, @test_settings['host'], @test_settings['dut'])
    def self.processFile(eyeScout, test_settings, strategy=nil)

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " [enter]:processFile(#{test_settings['dut']})"
      my_driver = eyeScout.drv()

      baseUrl = Scoutui::Base::UserVars.instance.getHost()
      datafile = test_settings['dut']

      Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " processFile(#{eyeScout}, #{baseUrl}, #{datafile})" if Scoutui::Utils::TestUtils.instance.isDebug?

      valid_file=false
      i=0
      begin
        dut_dupes = YAML.load_stream File.read(datafile)
        valid_file=true
      rescue => ex
        Scoutui::Utils::TestUtils.instance.setState(:abort, "Unable to read #{datafile}.")
        Scoutui::Logger::LogMgr.instance.fatal __FILE__ + (__LINE__).to_s + " #{ex.class}: Invalid file: #{datafile} - abort processing."
        Scoutui::Logger::LogMgr.instance.info ex.backtrace
      end

      return if !valid_file

      dut_dupes.each do |e|

        if Scoutui::Utils::TestUtils.instance.abort?
          Scoutui::Logger::LogMgr.instance.error __FILE__ + (__LINE__).to_s + " ABORT"
          return
        end

        totalWindows = my_driver.window_handles.length

        Scoutui::Logger::LogMgr.instance.debug '-' * 72
        Scoutui::Logger::LogMgr.instance.debug " [Pre-cmd]: Total Windows : #{totalWindows.to_s}"
        Scoutui::Logger::LogMgr.instance.debug " #{i.to_s}. Processing #{e.inspect}"
        i+=1

        Scoutui::Utils::TestUtils.instance.setReq('UI')
        Scoutui::Commands::Utils.instance.resetTimeout(Scoutui::Utils::TestUtils.instance.getDefaultWait)

        _action = e[STEP_KEY]["action"]

      # _name   = e[STEP_KEY]["name"]
        _name   = Scoutui::Base::UserVars.instance.normalize(e[STEP_KEY]["name"])
        _url    = e[STEP_KEY]["url"]
        _skip   = e[STEP_KEY]["skip"]
        _region = e[STEP_KEY]["region"]
        _reqid  = e[STEP_KEY]["reqid"]
        _execute_when = e[STEP_KEY]["execute_when"]
        _use_frames = e[STEP_KEY]["frames"]


        Scoutui::Commands::Utils.instance.reset(e)

        if e[STEP_KEY].has_key?("timeout")
         Scoutui::Commands::Utils.instance.setTimeout(e[STEP_KEY]["timeout"])
        end

        if Scoutui::Utils::TestUtils.instance.isDebug?
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " action: #{_action}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " name: #{_name}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " url : #{_url}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " skip: #{_skip}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " region: #{_region}"
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " reqid: #{_reqid}"
        end

        if !_reqid.nil? && !_reqid.to_s.empty?
          Testmgr::TestReport.instance.getReq(_reqid)
          Scoutui::Utils::TestUtils.instance.setReq(_reqid)
        else
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  REQID was not provided"
        end


        if !_execute_when.nil? && !_execute_when.to_s.empty?

          if _execute_when.is_a?(String) && _execute_when.match(/^\s*(existsalert|existsalert|exists\(alert\))/i)

            if QBrowser.existsAlert?(my_driver)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Execution continues - alert IS present #{e[STEP_KEY]}"
            else
#              puts __FILE__ + (__LINE__).to_s + " + Execution skipped - alert is NOT present";; gets()
              next;
            end

          elsif _execute_when.is_a?(String) && _execute_when.match(/^\s*(\$\{.*\})\s*(==)(.*)$/)

            _match = _execute_when.match(/^\s*(\$\{.*\})\s*(==)(.*)$/)
            _var  = _match[1]
            _cond = _match[2]
            _val  = _match[3]

            _uservar_val = Scoutui::Base::UserVars.instance.getVar(_var)
            _uservar_val = Scoutui::Base::UserVars.instance.get(_var)  if _uservar_val.nil?

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when.condition => #{_uservar_val} equals #{_val}"

            _rc=(_uservar_val.match(/#{_val}/) || _uservar_val==_val)

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _rc => #{_rc} is nil (#{_rc.nil?})"

            if !_rc
              Scoutui::Logger::LogMgr.instance.info " Execute_When: #{_uservar_val} == #{_val} : false - skip #{e[STEP_KEY]}"
               next
            end

          elsif _execute_when.is_a?(String) && _execute_when.match(/^\s*[!]*isEnabled\((.*)\)\s*$/i)


            if !Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _execute_when)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled => false"
              next
            end

          elsif _execute_when.is_a?(String) && _execute_when.match(/^\s*[!]*isSelected\((.*)\)\s*$/i)

            if !Scoutui::Base::Assertions.instance.isSelected?(my_driver, _execute_when)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isSelected => false"
              next
            end

          elsif _execute_when.is_a?(Array)
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Process series of execute_when : #{_execute_when}"

            _executeIt=true

            _execute_when.each do |_a|
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when => #{_a.class} : #{_a}"


              if _a.to_s.match(/^\s*(\$\{.*\})\s*(==|!=)(.*)$/)

                _match = _a.match(/^\s*(\$\{.*\})\s*(==|!=)(.*)$/)
                _var  = _match[1]
                _cond = _match[2]
                _val  = _match[3]

                _uservar_val = Scoutui::Base::UserVars.instance.getVar(_var)
                _uservar_val = Scoutui::Base::UserVars.instance.get(_var)  if _uservar_val.nil?

                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute_when.condition => #{_uservar_val} equals #{_val}"

                if _cond=='=='
                  _executeIt=(_uservar_val.match(/#{_val}/) || _uservar_val==_val)
                else
                  _executeIt=(!_uservar_val.match(/#{_val}/) || _uservar_val!=_val)
                end


              elsif Scoutui::Base::Assertions.instance.isEnabledCmd?(_a)
                if !Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled #{_a} : failed"
                  _executeIt=false
                else
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " IS_ENABLED : #{_a}";
                end


              elsif Scoutui::Base::Assertions.instance.isRoleCmd?(_a)

                if !Scoutui::Base::Assertions.instance.isRole?(_a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isRole #{_a} : failed"
                  _executeIt = false
                else
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " execute => role matched"
                end

              elsif Scoutui::Base::Assertions.instance.isVisibleCmd?(_a)

                if !Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " visible #{_a} : failed"
                  _executeIt = false
                end

              elsif Scoutui::Base::Assertions.instance.isSelectedCmd?(_a)

                if !Scoutui::Base::Assertions.instance.isSelected?(my_driver, _a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isSelected => false"
                  _executeIt=false
                end

              elsif Scoutui::Base::Assertions.instance.isValueCmd?(_a)

                if !Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " value doesnt match"
                  _executeIt = false
                end

              end

              if !_executeIt
                break
              end

            end

            if !_executeIt
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Dont execute"
              next
            end


          elsif _execute_when.is_a?(String)
            _rc=Scoutui::Base::Assertions.instance.isVisible(my_driver, _execute_when, _reqid, true)

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " EXECUTE_WHEN  #{_rc}";

            if !_rc
              Scoutui::Logger::LogMgr.instance.info " Execute_When: true - skip #{e[STEP_KEY]}"
              next
            end
          end

        end



        skipIt = (!_skip.nil?) && (_skip.to_s.strip.downcase=='true')
        Scoutui::Logger::LogMgr.instance.info "\to skip : #{skipIt}" if Scoutui::Utils::TestUtils.instance.isDebug?

        if skipIt
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " SKIP - #{_name}" if Scoutui::Utils::TestUtils.instance.isDebug?
          next
        end

        if e[STEP_KEY].has_key?('load') && e[STEP_KEY]['load'].has_key?('command')
          _id = e[STEP_KEY]['load']['id'].to_s
          _c = e[STEP_KEY]['load']['command'].to_s
          CmdShellMgr::DSL.instance.cmd(:cmd => "command(#{_id}, #{_c})")
          next
        end

        if e[STEP_KEY].has_key?('command')
          _id = e[STEP_KEY]['command']['id'].to_s
          _rc=CmdShellMgr::DSL.instance.cmd(:cmd => "execute(#{_id})")
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " rc => #{_rc}"
          next
        end

        if e[STEP_KEY].has_key?('getResults')
          _id = e[STEP_KEY]['getResults']['id'].to_s
          _rc = CmdShellMgr::DSL.instance.cmd(:cmd => "getResults(#{_id})")
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " rc => #{_rc}"

          if e[STEP_KEY]['getResults'].has_key?('capture')
            m2=CmdShellMgr::DSL.instance.cmd(:cmd => "getResult(#{_id}).capture(#{e[STEP_KEY]['getResults']['capture'].to_s})")
            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Capture => #{m2}"


            if e[STEP_KEY]['getResults'].has_key?('assignto')
              Scoutui::Base::UserVars.instance.setVar(e[STEP_KEY]['getResults']['assignto'], m2)
            end
          end


          next
        end


        if !isRun(e).nil?

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ========> RUN <================="
          tmpSettings=test_settings.dup
          tmpSettings["dut"]=e[STEP_KEY]["run"].to_s

          Scoutui::Logger::LogMgr.instance.info " RUN Command file : #{tmpSettings["dut"]}"
          processFile(eyeScout, tmpSettings, strategy)
          Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " Completed execution of subfile"
          next

        end

        if !(_action.nil? || _action.to_s.empty?)

          Scoutui::Logger::LogMgr.instance.asserts.info "Verify #{_action} is a valid command - #{Scoutui::Commands::Utils.instance.isValid?(_action).to_s}"
          Testmgr::TestReport.instance.getReq('Command').get_child('isValid').add(Scoutui::Commands::Utils.instance.isValid?(_action), "Verify #{_action} is a valid command")

          begin

            if _action.is_a?(String) && _action=='stop'
              Scoutui::Logger::LogMgr.instance.info " STOP TEST"
              break;
            end

            _command = eyeScout.getStrategy().processCommand(_action, e)

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " _command.Result => #{_command}, Passed? : #{_command.passed?}"

            if my_driver.window_handles.length > totalWindows
              Scoutui::Logger::LogMgr.instance.info "[post-cmd] Total Windows : #{my_driver.window_handles.length.to_s}"
            end


          #  if !eyeScout.getStrategy().processCommand(_action, e)
            if !_command.wasExecuted?
              processCommand(_action, e, my_driver)
            else
              if Scoutui::Utils::TestUtils.instance.isFailFast? && !_command.passed?
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Failfast.";
                Scoutui::Utils::TestUtils.instance.setState(:abort)
                return
              end
              Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Command #{_action} was already executed in Strategy"
            end

            processExpected(my_driver, e)
            processAssertions(my_driver, e)
            _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])

            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ======  assertResults : #{_assertResult}"



            if e[STEP_KEY].has_key?("highlight") && e[STEP_KEY]["highlight"].has_key?("locators")
              _cmd="Highlight"

              begin
                _c = Scoutui::Commands::Highlight.new('highlight')

                if e[STEP_KEY]["highlight"].has_key?("assert") && e[STEP_KEY]["highlight"]["assert"].to_s.match(/\s*true\s*$/)
                  _c.enableAsserts()
                else
                  _c.disableAsserts()
                end

                _pg={"page" => { "locators" => e[STEP_KEY]["highlight"]["locators"]} }
                _c.run(driver: my_driver, dut: _pg)

              rescue => ex
                Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex.class}"
                Scoutui::Logger::LogMgr.instance.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
              end

            end

            if !_assertResult && Scoutui::Utils::TestUtils.instance.isFailFast?
              Scoutui::Utils::TestUtils.instance.setState(:abort, 'Failed assertion with failfast enabled.')
              return
            end


            ##
            # SaveAs
            ##
            if e[STEP_KEY].has_key?('saveas')
              # processSaveAs(e)

              _saveAs = e[STEP_KEY]['saveas']['file'].to_s

              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " == Process SaveAs #{_saveAs}=="

              begin
                _f=File.open(_saveAs, 'w')

                if _saveAs.match(/.*\.json\s*$/)
                  _f.puts Scoutui::Utils::TestUtils.instance.expandVars(e[STEP_KEY]['saveas']['data']).to_json

                elsif _saveAs.match(/.*\.(yml|yaml)\s*$/i)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Generate a YAML file"
                  _f.write(Scoutui::Utils::TestUtils.instance.expandVars(e[STEP_KEY]['saveas']['data'].to_yaml))
                else
                  Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Unknown file extension."
                end

              rescue => ex
                Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " #{ex}"
                Scoutui::Logger::LogMgr.instance.warn  ex.backtrace
              ensure
                _f.close
              end

            end

            if Scoutui::Utils::TestUtils.instance.screenShots?
              _saveScreenAs=Scoutui::Utils::TestUtils.instance.sanitize_filename(_name)
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ScreenSave : #{_saveScreenAs}"
              my_driver.save_screenshot("/tmp/#{_saveScreenAs}.png")
            end

            if isSnapIt(e)

              if QBrowser.existsAlert?(my_driver)
                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Snapit with existing Alert"
              end

              if !_region.nil?

                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " snapit.region: #{_region}"
                _frames = Scoutui::Base::Assertions.instance._parseFrameLocator(_region)

                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "*** frames: #{_frames}"



                if _frames.has_key?('frame')
                  my_driver.switch_to.default_content
                  Scoutui::Commands::Utils.instance.resetFrameSearch
                  Scoutui::Commands::Utils.instance.setEnableFrameSearch(_frames['frame'])

                  _obj=Scoutui::Base::QBrowser.findElement(my_driver, _frames['locator]'], Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
                  Scoutui::Base::QBrowser.highlight(my_driver, obj)

                  Scoutui::Base::QBrowser.switch_frame(my_driver, _frames['frame'])

                  eyeScout.check_window(_name, _frames['locator'])
                else
                  eyeScout.check_window(_name, Scoutui::Base::UserVars.instance.normalize(_region))
                end


              else
                eyeScout.check_window(_name)
              end
            end

          rescue => ex
            "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
          end

          next
        end


        if e[STEP_KEY].has_key?("url")
          url = e[STEP_KEY]["url"].to_s
          eyeScout.getStrategy().processCommand('navigate(' + url + ')', e)
        end

        Scoutui::Logger::LogMgr.instance.info "\to Expected:  #{e[STEP_KEY]['expected'].class.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?

        processExpected(my_driver, e)
        processAssertions(my_driver, e)
        _assertResult=processAsserts(my_driver, e[STEP_KEY]["asserts"])   # 5150
        Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " ======  assertResults : #{_assertResult}"

        if e[STEP_KEY].has_key?("highlight") && e[STEP_KEY]["highlight"].has_key?("locators")
          _cmd="Highlight"
          _c = Scoutui::Commands::Highlight.new('highlight')
          _c.run(driver: my_driver, dut: e[STEP_KEY])
        end

        if !_region.nil?
          eyeScout.check_window(_name, Scoutui::Base::UserVars.instance.normalize(_region))
        else
          eyeScout.check_window(_name)
        end

        Scoutui::Logger::LogMgr.instance.info "\to links : #{e[STEP_KEY]['links'].class.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?

        if e[STEP_KEY].has_key?('links')
          links=e[STEP_KEY]['links']

          links.each_pair do |link_name, xpath|
            Scoutui::Logger::LogMgr.instance.info "\t\t#{link_name} => #{xpath}"  if Scoutui::Utils::TestUtils.instance.isDebug?

            obj = QBrowser.getObject(my_driver, xpath, Scoutui::Commands::Utils.instance.getTimeout)
            Scoutui::Logger::LogMgr.instance.info __FILE__ + (__LINE__).to_s + " [click]: link object => #{obj.to_s}"  if Scoutui::Utils::TestUtils.instance.isDebug?
            obj.click

            if !_region.nil?
              eyeScout.check_window(_name, _region)
            else
              eyeScout.check_window(link_name)
            end

          end
        end

      end


    end

  end


end