class MovieMasher::FilterEvaluated

# File lib/graphs/filters.rb, line 51
def initialize(filter_config, mash_input = nil, applied_input = nil)
  # applied_input same as filter_config for themes
  @config = filter_config
  raise(Error::Parameter, 'no config') unless @config

  @parameters = @config[:parameters]
  @evaluated = {}
  @mash_input = mash_input
  @applied_input = applied_input
  unless @parameters
    sym = filter_config[:id].upcase.to_sym
    if Parameters.const_defined?(sym)
      @parameters = Parameters.const_get(sym)
    end
    @parameters ||= []
  end
  super @config[:id]
end

# File lib/graphs/filters.rb, line 8
def command_parameters(scope)
  cmds = []
  if @parameters
    __raise_unless(@parameters.is_a?(Array), 'parameters is not an array')
    @parameters.each do |parameter|
      __raise_unless(parameter.is_a?(Hash), 'parameter is not a hash')
      name = parameter[:name]
      evaluated = parameter[:value]
      cmds << __command_name_value(name, evaluated, scope)
    end
  end
  cmds.join(':')
end

# File lib/graphs/filters.rb, line 22
def filter_command(scope = nil)
  cmd = super
  return cmd if cmd.empty?

  @evaluated = {}
  cmds = []
  cmds << cmd
  if scope
    if Filter.__outsize['w'] && Filter.__outsize['h']
      scope[:mm_in_w] = Filter.__outsize['w']
      scope[:mm_in_h] = Filter.__outsize['h']
      # puts "<< #{scope[:mm_in_w]}x#{scope[:mm_in_h]} #{@id}"
    else
      scope[:mm_in_w] = 'in_w'
      scope[:mm_in_h] = 'in_h'
    end
  end
  cmd = command_parameters(scope)
  unless cmd.to_s.empty?
    cmds << '='
    cmds << cmd
  end
  cmd = cmds.join
  __set_output_dimension

  @evaluated = {}
  cmd
end

# File lib/graphs/filters.rb, line 71
def scope_value(scope, value_str)
  if scope
    # puts "1 value_str = #{value_str}"
    level = 0
    deepest = 0
    esc = '~'
    # expand variables
    value_str = value_str.to_s.dup
    value_str.gsub!(/(\w+)/) do |match|
      match_str = match.to_s
      match_sym = match_str.to_sym
      if scope[match_sym]
        scope[match_sym].to_s
      else
        match_str
      end
    end
    # puts "2 value_str = #{value_str}"
    value_str.gsub!(/[()]/) do |paren|
      result = paren.to_s
      case result
      when '('
        level += 1
        deepest = [deepest, level].max
        result = "(#{level}#{esc}"
      when ')'
        result = ")#{level}#{esc}"
        level -= 1
      end
      result
    end
    # puts "3 value_str = #{value_str}"
    while deepest.positive?
      # puts "PRE #{deepest}: #{value_str}"
      reg_str = "([a-z_]+)[(]#{deepest}[#{esc}](.*?)[)]#{deepest}[#{esc}]"
      regexp = Regexp.new(reg_str)
      value_str = value_str.gsub(regexp) do
        Regexp.last_match.captures[0]
        method = Regexp.last_match.captures.first
        param_str = Regexp.last_match.captures.last
        params = param_str.split(',').map(&:strip)
        if __is_filter_helper(method)
          result = FilterHelpers.send(
            method.to_sym, params, @mash_input[:mash], scope
          )
          __raise_unless(result, "got false #{method}(#{params.join ','})")
          result = result.to_s
          __raise_if_empty(result, "empty #{method}(#{params.join(',')})")
        else
          result = "#{method}(#{params.join ','})"
        end
        result
      end
      # puts "POST METHODS #{deepest}: #{value_str}"
      # replace all simple equations in parentheses
      reg_str = "[(]#{deepest}[#{esc}](.*?)[)]#{deepest}[#{esc}]"
      value_str = value_str.gsub(Regexp.new(reg_str)) do
        evaluated = Evaluate.equation(Regexp.last_match[1])
        evaluated = "(#{evaluated})" unless evaluated.respond_to?(:round)
        evaluated.to_s
      end
      # puts "POST EQUATIONS #{deepest}: #{value_str}"
      deepest -= 1
    end
    # remove any lingering markers
    regexp = Regexp.new("([()])[0-9]+[#{esc}]")
    value_str = value_str.gsub(regexp) { Regexp.last_match[1] }
    # remove whitespace
    # value_str.gsub!(/\s/, '')
    # puts "4 value_str = #{value_str}"
  end
  Evaluate.equation(value_str)
end