module Roda::RodaPlugins::Base::RequestMethods

def _match_array(matcher)
  matcher.any? do |m|
    if matched = match(m)
      if m.is_a?(String)
        @captures.push(m)
      end
    end
    matched
  end
end

def _match_hash(hash)
  hash.all?{|k,v| send("match_#{k}", v)}
end

def _match_regexp(re)
  consume(self.class.cached_matcher(re){re})
end

def _match_string(str)
  consume(self.class.cached_matcher(str){Regexp.escape(str).gsub(/:(\w+)/){|m| _match_symbol_regexp($1)}})
end

def _match_symbol(sym)
  consume(self.class.cached_matcher(sym){_match_symbol_regexp(sym)})
end

def _match_symbol_regexp(s)
  SEGMENT
end

def _verb(args, &block)
  if args.empty?
    always(&block)
  else
    args << TERM
    if_match(args, &block)
  end
end

def always
  block_result(yield)
  throw :halt, response.finish
end

def block_result(result)
  res = response
  if res.empty? && (body = block_result_body(result))
    res.write(body)
  end
end

def block_result_body(result)
  if result.is_a?(String)
    result
  end
end

def consume(pattern)
  if matchdata = remaining_path.match(pattern)
    update_remaining_path(matchdata.post_match)
    @captures.concat(matchdata.captures)
  end
end

def default_redirect_path
  raise RodaError, "must provide path argument to redirect for get requests" if is_get?
  path
end

def default_redirect_status
  302
end

def empty_path?
  remaining_path == EMPTY_STRING
end

def get(*args, &block)
  _verb(args, &block) if is_get?
end

def halt(res=response.finish)
  throw :halt, res
end

def if_match(args)
  keep_remaining_path do
    # For every block, we make sure to reset captures so that
    # nesting matchers won't mess with each other's captures.
    @captures.clear
    return unless match_all(args)
    block_result(yield(*captures))
    throw :halt, response.finish
  end
end

def initialize(scope, env)
  @scope = scope
  @captures = []
  super(env)
end

def inspect
  "#<#{self.class.inspect} #{@env[REQUEST_METHOD]} #{path}>"
end

def is(*args, &block)
  if args.empty?
    if empty_path?
      always(&block)
    end
  else
    args << TERM
    if_match(args, &block)
  end
end

def is_get?
  @env[REQUEST_METHOD] == GET_REQUEST_METHOD
end

def keep_remaining_path
  env = @env
  script = env[sn = SCRIPT_NAME]
  path = env[pi = PATH_INFO]
  yield
ensure
  env[sn] = script
  env[pi] = path
end

def match(matcher)
  case matcher
  when String
    _match_string(matcher)
  when Regexp
    _match_regexp(matcher)
  when Symbol
    _match_symbol(matcher)
  when TERM
    empty_path?
  when Hash
    _match_hash(matcher)
  when Array
    _match_array(matcher)
  when Proc
    matcher.call
  else
    matcher
  end
end

def match_all(args)
  args.all?{|arg| match(arg)}
end

def match_extension(ext)
  consume(self.class.cached_matcher([:extension, ext]){/([^\\\/]+)\.#{ext}/})
end

def match_method(type)
  if type.is_a?(Array)
    type.any?{|t| match_method(t)}
  else
    type.to_s.upcase == @env[REQUEST_METHOD]
  end
end

def match_param(key)
  if v = self[key]
    @captures << v
  end
end

def match_param!(key)
  if (v = self[key]) && !v.empty?
    @captures << v
  end
end

def matched_path
  @env[SCRIPT_NAME]
end

def on(*args, &block)
  if args.empty?
    always(&block)
  else
    if_match(args, &block)
  end
end

def path
  e = @env
  "#{e[SCRIPT_NAME]}#{e[PATH_INFO]}"
end

def post(*args, &block)
  _verb(args, &block) if post?
end

def redirect(path=default_redirect_path, status=default_redirect_status)
  response.redirect(path, status)
  throw :halt, response.finish
end

def remaining_path
  @env[PATH_INFO]
end

def response
  scope.response
end

def roda_class
  self.class.roda_class
end

def root(&block)
  if remaining_path == SLASH && is_get?
    always(&block)
  end
end

def run(app)
  throw :halt, app.call(@env)
end

def session
  @env[SESSION_KEY] || raise(RodaError, "You're missing a session handler. You can get started by adding use Rack::Session::Cookie")
end

def update_remaining_path(remaining)
  e = @env
  # Don't mutate SCRIPT_NAME, breaks try
  e[SCRIPT_NAME] += e[pi = PATH_INFO].chomp(remaining)
  e[pi] = remaining
end