class Grape::API::Instance

def add_head_not_allowed_methods_and_options_methods
  # The paths we collected are prepared (cf. Path#prepare), so they
  # contain already versioning information when using path versioning.
  all_routes = self.class.endpoints.map(&:routes).flatten
  # Disable versioning so adding a route won't prepend versioning
  # informations again.
  without_root_prefix_and_versioning { collect_route_config_per_pattern(all_routes) }
end

def base=(grape_api)
  @base = grape_api
  grape_api.instances << self
end

def base_instance?
  self == base.base_instance
end

def call(env)
  compile!
  call!(env)
end

def call(env)
  status, headers, response = @router.call(env)
  unless cascade?
    headers = Grape::Util::Header.new.merge(headers)
    headers.delete(Grape::Http::Headers::X_CASCADE)
  end
  [status, headers, response]
end

def call!(env)
  instance.call(env)
end

def cascade(value = nil)
  if value.nil?
    inheritable_setting.namespace_inheritable.key?(:cascade) ? !namespace_inheritable(:cascade).nil? : true
  else
    namespace_inheritable(:cascade, value)
  end
end

def cascade?
  return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.key?(:cascade)
  return self.class.namespace_inheritable(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options)&.key?(:cascade)
  true
end

def change!
  @instance = nil
end

def collect_route_config_per_pattern(all_routes)
  routes_by_regexp = all_routes.group_by(&:pattern_regexp)
  # Build the configuration based on the first endpoint and the collection of methods supported.
  routes_by_regexp.each_value do |routes|
    last_route = routes.last # Most of the configuration is taken from the last endpoint
    next if routes.any? { |route| route.request_method == '*' }
    allowed_methods = routes.map(&:request_method)
    allowed_methods |= [Rack::HEAD] if !self.class.namespace_inheritable(:do_not_route_head) && allowed_methods.include?(Rack::GET)
    allow_header = self.class.namespace_inheritable(:do_not_route_options) ? allowed_methods : [Rack::OPTIONS] | allowed_methods
    last_route.app.options[:options_route_enabled] = true unless self.class.namespace_inheritable(:do_not_route_options) || allowed_methods.include?(Rack::OPTIONS)
    @router.associate_routes(last_route.pattern, {
                               endpoint: last_route.app,
                               allow_header: allow_header
                             })
  end
end

def compile
  @instance ||= new # rubocop:disable Naming/MemoizedInstanceVariableName
end

def compile!
  return if instance
  LOCK.synchronize { compile unless instance }
end

def evaluate_as_instance_with_configuration(block, lazy: false)
  lazy_block = Grape::Util::Lazy::Block.new do |configuration|
    value_for_configuration = configuration
    self.configuration = value_for_configuration.evaluate if value_for_configuration.respond_to?(:lazy?) && value_for_configuration.lazy?
    response = instance_eval(&block)
    self.configuration = value_for_configuration
    response
  end
  if base && base_instance? && lazy
    lazy_block
  else
    lazy_block.evaluate_from(configuration)
  end
end

def given(conditional_option, &block)
  evaluate_as_instance_with_configuration(block, lazy: true) if conditional_option && block
end

def inherit_settings(other_settings)
  top_level_setting.inherit_from other_settings.point_in_time_copy
  # Propagate any inherited params down to our endpoints, and reset any
  # compiled routes.
  endpoints.each do |e|
    e.inherit_settings(top_level_setting.namespace_stackable)
    e.reset_routes!
  end
  reset_routes!
end

def inherited(subclass)
  super
  subclass.reset!
  subclass.logger = logger.clone
end

def initialize
  @router = Router.new
  add_head_not_allowed_methods_and_options_methods
  self.class.endpoints.each do |endpoint|
    endpoint.mount_in(@router)
  end
  @router.compile!
  @router.freeze
end

def mounted(&block)
  evaluate_as_instance_with_configuration(block, lazy: true)
end

def nest(*blocks, &block)
  blocks.compact!
  if blocks.any?
    evaluate_as_instance_with_configuration(block) if block
    blocks.each { |b| evaluate_as_instance_with_configuration(b) }
    reset_validations!
  else
    instance_eval(&block)
  end
end

def prepare_routes
  endpoints.map(&:routes).flatten
end

def recognize_path(path)
  compile!
  instance.router.recognize_path(path)
end

def reset!
  reset_endpoints!
  reset_routes!
  reset_validations!
end

def to_s
  base&.to_s || super
end

def without_root_prefix_and_versioning
  old_version = self.class.namespace_inheritable(:version)
  old_version_options = self.class.namespace_inheritable(:version_options)
  old_root_prefix = self.class.namespace_inheritable(:root_prefix)
  self.class.namespace_inheritable_to_nil(:version)
  self.class.namespace_inheritable_to_nil(:version_options)
  self.class.namespace_inheritable_to_nil(:root_prefix)
  yield
  self.class.namespace_inheritable(:version, old_version)
  self.class.namespace_inheritable(:version_options, old_version_options)
  self.class.namespace_inheritable(:root_prefix, old_root_prefix)
end