class JsonPath
  class Enumerable
    include ::Enumerable
    attr_reader :allow_eval
    alias_method :allow_eval?, :allow_eval

    def initialize(path, object, mode, options = nil)
      @path = path.path
      @object = object
      @mode = mode
      @options = options
      @allow_eval = if @options && @options.key?(:allow_eval)
                      @options[:allow_eval]
                    else
                      true
                    end
    end

    def each(context = @object, key = nil, pos = 0, &blk)
      node = key ? context[key] : context
      @_current_node = node
      return yield_value(blk, context, key) if pos == @path.size
      case expr = @path[pos]
      when '*', '..', '@'
        each(context, key, pos + 1, &blk)
      when '$'
        each(context, key, pos + 1, &blk) if node == @object
      when /^\[(.*)\]$/
        handle_wildecard(node, expr, context, key, pos, &blk)
      else
        if pos == (@path.size - 1) && node && allow_eval?
          yield_value(blk, context, key) if eval("node #{@path[pos]}")
        end
      end

      if pos > 0 && @path[pos - 1] == '..'
        case node
        when Hash  then node.each { |k, _| each(node, k, pos, &blk) }
        when Array then node.each_with_index { |_, i| each(node, i, pos, &blk) }
        end
      end
    end

    private

    def handle_wildecard(node, expr, context, key, pos, &blk)
      expr[1, expr.size - 2].split(',').each do |sub_path|
        case sub_path[0]
        when '\'', '"'
          next unless node.is_a?(Hash)
          k = sub_path[1, sub_path.size - 2]
          each(node, k, pos + 1, &blk) if node.key?(k)
        when '?'
          handle_question_mark(sub_path, node, pos, &blk)
        else
          next unless node.is_a?(Array) && !node.empty?
          array_args = sub_path.split(':')
          if array_args[0] == '*'
            start_idx = 0
            end_idx = node.size - 1
          else
            start_idx = process_function_or_literal(array_args[0], 0)
            next unless start_idx
            end_idx = (array_args[1] && process_function_or_literal(array_args[1], -1) || (sub_path.count(':') == 0 ? start_idx : -1))
            next unless end_idx
            next if start_idx == end_idx && start_idx > node.size
          end
          start_idx %= node.size
          end_idx %= node.size
          step = process_function_or_literal(array_args[2], 1)
          next unless step
          (start_idx..end_idx).step(step) { |i| each(node, i, pos + 1, &blk) }
        end
      end
    end

    def handle_question_mark(sub_path, node, pos, &blk)
      raise 'Cannot use ?(...) unless eval is enabled' unless allow_eval?
      case node
      when Array
        node.size.times do |index|
          @_current_node = node[index]
          if process_function_or_literal(sub_path[1, sub_path.size - 1])
            each(@_current_node, nil, pos + 1, &blk)
          end
        end
      when Hash
        if process_function_or_literal(sub_path[1, sub_path.size - 1])
          each(@_current_node, nil, pos + 1, &blk)
        end
      else
        yield node if process_function_or_literal(sub_path[1, sub_path.size - 1])
      end
    end

    def yield_value(blk, context, key)
      case @mode
      when nil
        blk.call(key ? context[key] : context)
      when :compact
        context.delete(key) if key && context[key].nil?
      when :delete
        context.delete(key) if key
      when :substitute
        if key
          context[key] = blk.call(context[key])
        else
          context.replace(blk.call(context[key]))
        end
      end
    end

    def process_function_or_literal(exp, default = nil)
      return default if exp.nil? || exp.empty?
      return Integer(exp) if exp[0] != '('
      return nil unless allow_eval? && @_current_node

      identifiers = /@?(\.(\w+))+/.match(exp)

      if !identifiers.nil? &&
         !@_current_node.methods.include?(identifiers[2].to_sym)

        exp_to_eval = exp.dup
        exp_to_eval[identifiers[0]] = identifiers[0].split('.').map do |el|
          el == '@' ? '@_current_node' : "['#{el}']"
        end.join

        begin
          return eval(exp_to_eval)
          # if eval failed because of bad arguments or missing methods
        rescue StandardError
          return default
        end
      end
      # otherwise eval as is
      # TODO: this eval is wrong, because hash accessor could be nil and nil
      # cannot be compared with anything, for instance,
      # @a_current_node['price'] - we can't be sure that 'price' are in every
      # node, but it's only in several nodes I wrapped this eval into rescue
      # returning false when error, but this eval should be refactored.
      begin
        eval(exp.gsub(/@/, '@_current_node'))
      rescue
        false
      end
    end
  end
end