class Sidekiq::Web::Action

def _erb(file, locals)
  locals&.each { |k, v| define_singleton_method(k) { v } unless singleton_methods.include? k }
  if file.is_a?(String)
    ERB.new(file).result(binding)
  else
    send(:"_erb_#{file}")
  end
end

def config
  env[:web_config]
end

def erb(content, options = {})
  if content.is_a? Symbol
    unless respond_to?(:"_erb_#{content}")
      views = options[:views] || Web.views
      filename = "#{views}/#{content}.erb"
      src = ERB.new(File.read(filename)).src
      # Need to use lineno less by 1 because erb generates a
      # comment before the source code.
      Action.class_eval <<-RUBY, filename, -1 # standard:disable Style/EvalWithLocation
        def _erb_#{content}
          #{src}
        end
      RUBY
    end
  end
  if @_erb
    _erb(content, options[:locals])
  else
    @_erb = true
    content = _erb(content, options[:locals])
    _render { content }
  end
end

def flash
  msg = yield
  logger.info msg
  session[:flash] = msg
end

def flash?
  session&.[](:flash)
end

def get_flash
  @flash ||= session.delete(:flash)
end

def halt(res)
  throw :halt, [res, {"content-type" => "text/plain"}, [res.to_s]]
end

def header(key, value)
  env["response_headers"][key] = value.to_s
end

def initialize(env, block)
  @_erb = false
  @env = env
  @block = block
end

def json(payload)
  [200,
    {"content-type" => "application/json", "cache-control" => "private, no-store"},
    [Sidekiq.dump_json(payload)]]
end

def logger
  Sidekiq.logger
end

def params
  warn { "Direct access to Rack parameters is discouraged, use `url_params` or `route_params` (at #{caller(3..3).first})" }
  request.params
end

def redirect(location)
  throw :halt, [302, {"location" => "#{request.base_url}#{location}"}, []]
end

def redirect_to(url)
  throw :halt, [302, {"location" => url}, []]
end

def reload_page
  current_location = request.referer.gsub(request.base_url, "")
  redirect current_location
end

def render(engine, content, options = {})
  raise "Only erb templates are supported" if engine != :erb
  erb(content, options)
end

def request
  @request ||= ::Rack::Request.new(env)
end

def route_params(key)
  warn { "Route parameter `#{key}` should be accessed via Symbol, not String (at #{caller(3..3).first})" } if key.is_a?(String)
  env["rack.route_params"][key.to_sym]
end

def session
  env["rack.session"] || fail(<<~EOM)
    Sidekiq::Web needs a valid Rack session. If this is a Rails app, make
    sure you mount Sidekiq::Web *inside* your application routes:
    Rails.application.routes.draw do
      mount Sidekiq::Web => "/sidekiq"
      ....
    end
    If this is a Rails app in API mode, you need to enable sessions.
      https://guides.rubyonrails.org/api_app.html#using-session-middlewares
    If this is a bare Rack app, use a session middleware before Sidekiq::Web:
      # first, use IRB to create a shared secret key for sessions and commit it
      require 'securerandom'; File.open(".session.key", "w") {|f| f.write(SecureRandom.hex(32)) }
      # now use the secret with a session cookie middleware
      use Rack::Session::Cookie, secret: File.read(".session.key"), same_site: true, max_age: 86400
      run Sidekiq::Web
  EOM
end

def url_params(key)
  warn { "URL parameter `#{key}` should be accessed via String, not Symbol (at #{caller(3..3).first})" } if key.is_a?(Symbol)
  request.params[key.to_s]
end

def warn
  Sidekiq.logger.warn yield
end