class Liquid::Condition

def self.operators
  @@operators
end

def self.parse_expression(parse_context, markup)
  @@method_literals[markup] || parse_context.parse_expression(markup)
end

def and(condition)
  @child_relation  = :and
  @child_condition = condition
end

def attach(attachment)
  @attachment = attachment
end

def deprecated_default_context
  warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
    " and will be removed from Liquid 6.0.0.")
  Context.new
end

def else?
  false
end

def equal_variables(left, right)
  if left.is_a?(MethodLiteral)
    if right.respond_to?(left.method_name)
      return right.send(left.method_name)
    else
      return nil
    end
  end
  if right.is_a?(MethodLiteral)
    if left.respond_to?(right.method_name)
      return left.send(right.method_name)
    else
      return nil
    end
  end
  left == right
end

def evaluate(context = deprecated_default_context)
  condition = self
  result = nil
  loop do
    result = interpret_condition(condition.left, condition.right, condition.operator, context)
    case condition.child_relation
    when :or
      break if Liquid::Utils.to_liquid_value(result)
    when :and
      break unless Liquid::Utils.to_liquid_value(result)
    else
      break
    end
    condition = condition.child_condition
  end
  result
end

def initialize(left = nil, operator = nil, right = nil)
  @left     = left
  @operator = operator
  @right    = right
  @child_relation  = nil
  @child_condition = nil
end

def inspect
  "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
end

def interpret_condition(left, right, op, context)
  # If the operator is empty this means that the decision statement is just
  # a single variable. We can just poll this variable from the context and
  # return this as the result.
  return context.evaluate(left) if op.nil?
  left  = Liquid::Utils.to_liquid_value(context.evaluate(left))
  right = Liquid::Utils.to_liquid_value(context.evaluate(right))
  operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
  if operation.respond_to?(:call)
    operation.call(self, left, right)
  elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
    begin
      left.send(operation, right)
    rescue ::ArgumentError => e
      raise Liquid::ArgumentError, e.message
    end
  end
end

def or(condition)
  @child_relation  = :or
  @child_condition = condition
end