class HTML::Tag

def ==(node)
  return false unless super
  return false unless closing == node.closing && self.name == node.name
  attributes == node.attributes
end

def [](attr)
  @attributes ? @attributes[attr] : nil
end

def childless?(xml = false)
  return false if xml && @closing.nil?
  !@closing.nil? ||
    @name =~ /^(img|br|hr|link|meta|area|base|basefont|
                col|frame|input|isindex|param)$/ox
end

def find(conditions)
  match(conditions) && self || super
end

def initialize(parent, line, pos, name, attributes, closing)
  super(parent, line, pos)
  @name = name
  @attributes = attributes
  @closing = closing
end

def match(conditions)
  conditions = validate_conditions(conditions)
  # check content of child nodes
  if conditions[:content]
    if children.empty?
      return false unless match_condition("", conditions[:content])
    else
      return false unless children.find { |child| child.match(conditions[:content]) }
    end
  end
  # test the name
  return false unless match_condition(@name, conditions[:tag]) if conditions[:tag]
  # test attributes
  (conditions[:attributes] || {}).each do |key, value|
    return false unless match_condition(self[key], value)
  end
  # test parent
  return false unless parent.match(conditions[:parent]) if conditions[:parent]
  # test children
  return false unless children.find { |child| child.match(conditions[:child]) } if conditions[:child]
  # test ancestors
  if conditions[:ancestor]
    return false unless catch :found do
      p = self
      throw :found, true if p.match(conditions[:ancestor]) while p = p.parent
    end
  end
  # test descendants
  if conditions[:descendant]
    return false unless children.find do |child|
      # test the child
      child.match(conditions[:descendant]) ||
      # test the child's descendants
      child.match(:descendant => conditions[:descendant])
    end
  end
  # count children
  if opts = conditions[:children]
    matches = children.select do |c|
      (c.kind_of?(HTML::Tag) and (c.closing == :self or ! c.childless?))
    end
    matches = matches.select { |c| c.match(opts[:only]) } if opts[:only]
    opts.each do |key, value|
      next if key == :only
      case key
        when :count
          if Integer === value
            return false if matches.length != value
          else
            return false unless value.include?(matches.length)
          end
        when :less_than
          return false unless matches.length < value
        when :greater_than
          return false unless matches.length > value
        else raise "unknown count condition #{key}"
      end
    end
  end
  # test siblings
  if conditions[:sibling] || conditions[:before] || conditions[:after]
    siblings = parent ? parent.children : []
    self_index = siblings.index(self)
    if conditions[:sibling]
      return false unless siblings.detect do |s|
        s != self && s.match(conditions[:sibling])
      end
    end
    if conditions[:before]
      return false unless siblings[self_index+1..-1].detect do |s|
        s != self && s.match(conditions[:before])
      end
    end
    if conditions[:after]
      return false unless siblings[0,self_index].detect do |s|
        s != self && s.match(conditions[:after])
      end
    end
  end
  true
end

def match_condition(value, condition)
  case condition
    when String
      value && value == condition
    when Regexp
      value && value.match(condition)
    when Numeric
      value == condition.to_s
    when true
      !value.nil?
    when false, nil
      value.nil?
    else
      false
  end
end

def select(selector, *values)
  selector = HTML::Selector.new(selector, values)
  selector.select(self)
end

def tag?
  true
end

def to_s
  if @closing == :close
    "</#{@name}>"
  else
    s = "<#{@name}"
    @attributes.each do |k,v|
      s << " #{k}"
      s << "=\"#{v}\"" if String === v
    end
    s << " /" if @closing == :self
    s << ">"
    @children.each { |child| s << child.to_s }
    s << "</#{@name}>" if @closing != :self && !@children.empty?
    s
  end
end