class Rage::Router::DSL::Handler

def __on(method, path, to, constraints, defaults)
  # handle calls without controller inside resources:
  #   resources :comments do
  #     post :like
  #   end
  if !to
    if @controllers.any?
      to = "#{@controllers.last}##{path}"
    else
      raise ArgumentError, "Missing :to key on routes definition, please check your routes."
    end
  end
  # process path to ensure it starts with "/" and doesn't end with "/"
  if path != "/"
    path = "/#{path}" unless path.start_with?("/")
    path = path.delete_suffix("/") if path.end_with?("/")
  end
  # correctly process root helpers inside `scope` calls
  if path == "/" && @path_prefixes.any?
    path = ""
  end
  path_prefix = @path_prefixes.any? ? "/#{@path_prefixes.join("/")}" : nil
  module_prefix = @module_prefixes.any? ? "#{@module_prefixes.join("/")}/" : nil
  defaults = (defaults ? @defaults + [defaults] : @defaults).reduce(&:merge)
  if to.is_a?(String)
    @router.on(method, "#{path_prefix}#{path}", "#{module_prefix}#{to}", constraints: constraints || {}, defaults: defaults)
  else
    @router.on(method, "#{path_prefix}#{path}", to, constraints: constraints || {}, defaults: defaults)
  end
end

def __with_on_scope(on, &block)
  case on
  when nil
    block.call
  when :member
    member(&block)
  when :collection
    collection(&block)
  else
    raise ArgumentError, "Unknown scope :#{on} given to :on"
  end
end

def collection(&block)
  orig_path_prefixes = @path_prefixes
  @path_prefixes = @path_prefixes[0...-1] if @path_prefixes.last&.start_with?(":")
  instance_eval(&block)
  @path_prefixes = orig_path_prefixes
end

def controller(controller, &block)
  @controllers << controller
  instance_eval(&block)
  @controllers.pop
end

def defaults(defaults, &block)
  @defaults << defaults
  instance_eval(&block)
  @defaults.pop
end

def delete(path, to: nil, constraints: nil, defaults: nil, on: nil)
  __with_on_scope(on) { __on("DELETE", path, to, constraints, defaults) }
end

def get(path, to: nil, constraints: nil, defaults: nil, on: nil)
  __with_on_scope(on) { __on("GET", path, to, constraints, defaults) }
end

def initialize(router)
  @router = router
  @default_actions = %i(index create show update destroy)
  @default_match_methods = %i(get post put patch delete head)
  @scope_opts = %i(module path controller)
  @path_prefixes = []
  @module_prefixes = []
  @defaults = []
  @controllers = []
end

def match(path, to:, constraints: {}, defaults: nil, via: :all)
  # via is either nil, or an array of symbols or its :all
  http_methods = via
  # if its :all or nil, then we use the default HTTP methods
  if via == :all || via.nil?
    http_methods = @default_match_methods
  else
    # if its an array of symbols, then we use the symbols as HTTP methods
    http_methods = Array(via)
    # then we check if the HTTP methods are valid
    http_methods.each do |method|
      raise ArgumentError, "Invalid HTTP method: #{method}" unless @default_match_methods.include?(method)
    end
  end
  http_methods.each do |method|
    __on(method.to_s.upcase, path, to, constraints, defaults)
  end
end

def member(&block)
  orig_path_prefixes = @path_prefixes
  if (param_prefix = @path_prefixes.last)&.start_with?(":") && @controllers.any?
    member_prefix = param_prefix.delete_prefix(":#{to_singular(@controllers.last)}_")
    @path_prefixes = [*@path_prefixes[0...-1], ":#{member_prefix}"]
  end
  instance_eval(&block)
  @path_prefixes = orig_path_prefixes
end

def mount(app, at:, via: :all)
  at = "/#{at}" unless at.start_with?("/")
  at = at.delete_suffix("/") if at.end_with?("/")
  http_methods = if via == :all || via.nil?
    @default_match_methods.map { |method| method.to_s.upcase! }
  else
    Array(via).map! do |method|
      raise ArgumentError, "Invalid HTTP method: #{method}" unless @default_match_methods.include?(method)
      method.to_s.upcase!
    end
  end
  @router.mount(at, app, http_methods)
end

def namespace(path, **options, &block)
  path_prefix = options[:path] || path
  module_prefix = options[:module] || path
  @path_prefixes << path_prefix
  @module_prefixes << module_prefix
  instance_eval(&block)
  @path_prefixes.pop
  @module_prefixes.pop
end

def patch(path, to: nil, constraints: nil, defaults: nil, on: nil)
  __with_on_scope(on) { __on("PATCH", path, to, constraints, defaults) }
end

def post(path, to: nil, constraints: nil, defaults: nil, on: nil)
  __with_on_scope(on) { __on("POST", path, to, constraints, defaults) }
end

def put(path, to: nil, constraints: nil, defaults: nil, on: nil)
  __with_on_scope(on) { __on("PUT", path, to, constraints, defaults) }
end

def resources(*_resources, **opts, &block)
  # support calls with multiple resources, e.g. `resources :albums, :photos`
  if _resources.length > 1
    _resources.each { |_resource| resources(_resource, **opts, &block) }
    return
  end
  _module, _path, _only, _except, _param = opts.values_at(:module, :path, :only, :except, :param)
  raise ArgumentError, ":param option can't contain colons" if _param.to_s.include?(":")
  _only = Array(_only) if _only
  _except = Array(_except) if _except
  actions = @default_actions.select do |action|
    (_only.nil? || _only.include?(action)) && (_except.nil? || !_except.include?(action))
  end
  resource = _resources[0].to_s
  _path ||= resource
  _param ||= "id"
  scope_opts = { path: _path }
  scope_opts[:module] = _module if _module
  scope(scope_opts) do
    get("/", to: "#{resource}#index") if actions.include?(:index)
    post("/", to: "#{resource}#create") if actions.include?(:create)
    get("/:#{_param}", to: "#{resource}#show") if actions.include?(:show)
    patch("/:#{_param}", to: "#{resource}#update") if actions.include?(:update)
    put("/:#{_param}", to: "#{resource}#update") if actions.include?(:update)
    delete("/:#{_param}", to: "#{resource}#destroy") if actions.include?(:destroy)
    scope(path: ":#{to_singular(resource)}_#{_param}", controller: resource, &block) if block
  end
end

def root(to:)
  __on("GET", "/", to, nil, nil)
end

def scope(opts, &block)
  raise ArgumentError, "only :module, :path, and :controller options are accepted" if (opts.keys - @scope_opts).any?
  @path_prefixes << opts[:path].delete_prefix("/").delete_suffix("/") if opts[:path]
  @module_prefixes << opts[:module] if opts[:module]
  @controllers << opts[:controller] if opts[:controller]
  instance_eval(&block)
  @path_prefixes.pop if opts[:path]
  @module_prefixes.pop if opts[:module]
  @controllers.pop if opts[:controller]
end

def to_singular(str)
  @active_support_loaded ||= str.respond_to?(:singularize) || :false
  return str.singularize if @active_support_loaded != :false
  @endings ||= {
    "ves" => "fe",
    "ies" => "y",
    "i" => "us",
    "zes" => "ze",
    "ses" => "s",
    "es" => "",
    "s" => ""
  }
  @regexp ||= Regexp.new("(#{@endings.keys.join("|")})$")
  str.sub(@regexp, @endings)
end