module Watir
  class Locator
    include Watir
    include Watir::Exception

    def normalize_specifiers!(specifiers)
      specifiers.each do |how, what|
        case how
        when :index
          what = what.to_i
        when :url
          how = :href
        when :class
          how = :class_name
        when :caption
          how = :value
        when :method
          how = :form_method
        when :value
          what = what.is_a?(Regexp) ? what : what.to_s
        end

        @specifiers[how] = what
      end
    end

    def match_with_specifiers?(element)
      @specifiers.all? {|how, what| how == :index || match?(element, how, what)}
    end

    def set_specifier(how, what=nil)
      specifiers = what ? {how => what} : how
      @specifiers = {:index => Watir::Browser.base_index} # default if not specified
      normalize_specifiers! specifiers
    end

    def locate_by_xpath_css_ole
      if @specifiers[:xpath]
        return @container.element_by_xpath(@specifiers[:xpath])
      elsif @specifiers[:css]
        return @container.element_by_css(@specifiers[:css])
      elsif @specifiers[:ole_object]
        return @specifiers[:ole_object]
      end
    end
  end

  class TaggedElementLocator < Locator
    def initialize(container, tag, klass)
      @container = container
      @tag = tag
      @klass = klass || Element
    end

    def each_element tag
      @container.document.getElementsByTagName(tag).each do |ole_object|
        if @klass == Element
          element = Element.new(ole_object)
        else
          element = @klass.new(@container, @specifiers, nil)
          element.ole_object = ole_object
          def element.locate; @o; end unless @klass == TableRow
        end
        yield element
      end
    end

    def each
      each_element(@tag) do |element| 
        next unless match_with_specifiers?(element)
        yield element          
      end 
      nil
    end    

    def locate
      return locate_by_xpath_css_ole if @specifiers[:xpath] || @specifiers[:css] || @specifiers[:ole_object]

      count = Watir::Browser.base_index - 1
      each do |element|
        count += 1
        return element.ole_object if count == @specifiers[:index]
      end # elements
      nil
    end

    def match?(element, how, what)
      begin
        method = element.method(how)
      rescue NameError
        raise MissingWayOfFindingObjectException,
          "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
      end
      case method.arity
      when 0
        what.matches method.call
      when 1
        method.call(what)
      else
        raise MissingWayOfFindingObjectException,
          "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
      end
    end

  end

  class FrameLocator < TaggedElementLocator
    def initialize(container)
      @container = container
      @tags = Frame::TAG
    end

    def each_element tag
      frames = @container.document.frames
      i = 0
      @container.document.getElementsByTagName(tag).each do |ole_object|
        frame = Frame.new(@container, @specifiers, nil)
        frame.ole_object = ole_object
        frame.document = frames.item(i)
        def frame.locate; @o; end
        yield frame
        i += 1
      end
    end

    def each
      @tags.each do |tag|
        each_element(tag) do |element| 
          next unless match_with_specifiers?(element)
          yield element          
        end 
      end
      nil
    end        

    def locate
      return locate_by_xpath_css_ole if @specifiers[:xpath] || @specifiers[:css] || @specifiers[:ole_object]      

      count = Watir::Browser.base_index - 1
      each do |frame|
        count += 1
        return frame.ole_object, frame.document if count == @specifiers[:index]
      end
    end
  end

  class FormLocator < TaggedElementLocator
    def initialize(container)
      super(container, 'FORM', Form)
    end

    def each_element(tag)
      @container.document.forms.each do |form|
        form_element = Form.new(@container, @specifiers, nil)
        form_element.ole_object = form
        def form_element.locate; @o; end
        yield form_element
      end
    end
  end

  class InputElementLocator < Locator

    attr_accessor :document, :element, :elements, :klass

    def initialize container, types, klass
      @container = container
      @types = types
      @elements = nil
      @klass = klass || Element
    end

    def each_element
      @elements.each do |object|
        if @klass == Element
          element = Element.new(object)
        else
          element = @klass.new(@container, @specifiers, nil)
          element.ole_object = object
          def element.locate; @o; end          
        end
        yield element
      end
      nil
    end    

    def locate
      return locate_by_xpath_css_ole if @specifiers[:xpath] || @specifiers[:css] || @specifiers[:ole_object]

      count = Watir::Browser.base_index - 1
      each do |element|
        count += 1
        return element.ole_object if count == @specifiers[:index]
      end
    end

    def each
      each_element do |element| 
        next unless @types.include?(element.type) && match_with_specifiers?(element)
        yield element
      end 
      nil
    end    
    
    # return true if the element matches the provided how and what
    def match? element, how, what
      begin
        attribute = element.send(how)
      rescue NoMethodError
        raise MissingWayOfFindingObjectException,
          "#{how} is an unknown way of finding an <INPUT> element (#{what})"
      end

      what.matches(attribute)
    end

    def fast_locate
      # Searching through all elements returned by ole_inner_elements
      # is *significantly* slower than IE's getElementById() and
      # getElementsByName() calls when how is :id or :name.  However
      # IE doesn't match Regexps, so first we make sure what is a String.
      # In addition, IE's getElementById() will also return an element
      # where the :name matches, so we will only return the results of
      # getElementById() if the matching element actually HAS a matching
      # :id.

      the_id = @specifiers[:id]
      if the_id && the_id.class == String &&
          @specifiers[:index] == Watir::Browser.base_index && @specifiers.length == 2
        @element = @document.getElementById(the_id) rescue nil
        # Return if our fast match really HAS a matching :id
        return true if @element && @element.invoke('id') == the_id && @types.include?(@element.getAttribute('type'))
      end

      the_name = @specifiers[:name]
      if the_name && the_name.class == String
        @elements = @document.getElementsByName(the_name) rescue nil
      end
      false
    end
  end

  # This is like the TaggedElementLocator but
  # get all the elements by forcing @tag to be '*'
  class ElementLocator < TaggedElementLocator
    def initialize(container)
      super(container, "*", Element)
    end
  end  
end