class Opal::Compiler

def self.compiler_option(name, default_value, options = {})
  mid          = options[:as]
  valid_values = options[:valid_values]
  define_method(mid || name) do
    value = @options.fetch(name) { default_value }
    if valid_values and not(valid_values.include?(value))
      raise ArgumentError, "invalid value #{value.inspect} for option #{name.inspect} "+
                            "(valid values: #{valid_values.inspect})"
    end
    value
  end
end

def compile
  @parser = Parser.new
  parsed = begin
    @parser.parse(@source, self.file)
  rescue => error
    raise SyntaxError, error.message, error.backtrace
  end
  @sexp = s(:top, parsed || s(:nil))
  @eof_content = @parser.lexer.eof_content
  @fragments = process(@sexp).flatten
  @result = @fragments.map(&:code).join('')
rescue Exception => error
  message = "An error occurred while compiling: #{self.file}\n#{error.message}"
  raise error.class, message, error.backtrace
end

def error(msg, line = nil)
  raise SyntaxError, "#{msg} :#{file}:#{line}"
end

def fragment(str, scope, sexp = nil)
  Fragment.new(str, scope, sexp)
end

def handle_block_given_call(sexp)
  @scope.uses_block!
  if @scope.block_name
    fragment("(#{@scope.block_name} !== nil)", scope, sexp)
  elsif scope = @scope.find_parent_def and scope.block_name
    fragment("(#{scope.block_name} !== nil)", scope, sexp)
  else
    fragment("false", scope, sexp)
  end
end

def handlers
  @handlers ||= Opal::Nodes::Base.handlers
end

def has_break!
  @break_detected = true if @break_detected == false
end

def has_break?
  return @break_detected unless block_given?
  @break_detected = false
  result = yield
  detected = @break_detected
  @break_detected = nil
  detected
end

def helper(name)
  self.helpers << name
end

def helpers
  @helpers ||= Set.new([:breaker, :slice])
end

def in_case
  return unless block_given?
  old = @case_stmt
  @case_stmt = {}
  yield
  @case_stmt = old
end

def in_ensure
  return unless block_given?
  @in_ensure = true
  result = yield
  @in_ensure = false
  result
end

def in_ensure?
  @in_ensure
end

def in_while
  return unless block_given?
  @while_loop = @scope.push_while
  result = yield
  @scope.pop_while
  result
end

def in_while?
  @scope.in_while?
end

def indent(&block)
  indent = @indent
  @indent += INDENT
  @space = "\n#@indent"
  res = yield
  @indent = indent
  @space = "\n#@indent"
  res
end

def initialize(source, options = {})
  @source = source
  @indent = ''
  @unique = 0
  @options = options
end

def method_calls
  @method_calls ||= Set.new
end

def operator_helpers
  @operator_helpers ||= Set.new
end

def parser_indent
  @indent
end

def process(sexp, level = :expr)
  return fragment('', scope) if sexp == nil
  if handler = handlers[sexp.type]
    return handler.new(sexp, level, self).compile_to_fragments
  else
    raise "Unsupported sexp: #{sexp.type}"
  end
end

def required_trees
  @required_trees ||= []
end

def requires
  @requires ||= []
end

def returns(sexp)
  return returns s(:nil) unless sexp
  case sexp.type
  # Undefs go from 1 ruby undef a,b,c to multiple JS Opal.udef() calls, so need to treat them as individual statements
  # and put the return on the last one
  when :undef
    last = sexp.pop
    sexp << returns(last)
  when :break, :next, :redo
    sexp
  when :yield
    sexp[0] = :returnable_yield
    sexp
  when :scope
    sexp[1] = returns sexp[1]
    sexp
  when :block
    if sexp.length > 1
      sexp[-1] = returns sexp[-1]
    else
      sexp << returns(s(:nil))
    end
    sexp
  when :when
    sexp[2] = returns(sexp[2])
    sexp
  when :rescue
    sexp[1] = returns sexp[1]
    if sexp[2] and sexp[2][0] == :resbody
      if sexp[2][2]
        sexp[2][2] = returns sexp[2][2]
      else
        sexp[2][2] = returns s(:nil)
      end
    end
    sexp
  when :ensure
    sexp[1] = returns sexp[1]
    sexp
  when :begin
    sexp[1] = returns sexp[1]
    sexp
  when :rescue_mod
    sexp[1] = returns sexp[1]
    sexp[2] = returns sexp[2]
    sexp
  when :while
    # sexp[2] = returns(sexp[2])
    sexp
  when :return, :js_return
    sexp
  when :xstr
    sexp[1] = "return #{sexp[1]};" unless /return|;/ =~ sexp[1]
    sexp
  when :dxstr
    sexp[1] = "return #{sexp[1]}" unless /return|;|\n/ =~ sexp[1]
    sexp
  when :if
    sexp[2] = returns(sexp[2] || s(:nil))
    sexp[3] = returns(sexp[3] || s(:nil))
    sexp
  else
    return_sexp = s(:js_return, sexp)
    return_sexp.source = sexp.source
    return_sexp
  end
end

def s(*parts)
  Sexp.new(parts)
end

def source_map(source_file = nil)
  Opal::SourceMap.new(@fragments, source_file || self.file)
end

def unique_temp
  "TMP_#{@unique += 1}"
end

def warning(msg, line = nil)
  warn "WARNING: #{msg} -- #{file}:#{line}"
end

def with_temp(&block)
  tmp = @scope.new_temp
  res = yield tmp
  @scope.queue_temp tmp
  res
end